| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_editeng.hxx" |
| |
| #include <tools/stream.hxx> |
| #include <vcl/outdev.hxx> |
| #define _SVX_BULITEM_CXX |
| #include <editeng/bulitem.hxx> |
| #include <editeng/editrids.hrc> |
| #include <tools/tenccvt.hxx> |
| #include <vcl/dibtools.hxx> |
| |
| #define BULITEM_VERSION ((sal_uInt16)2) |
| |
| // ----------------------------------------------------------------------- |
| |
| TYPEINIT1(SvxBulletItem,SfxPoolItem); |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxBulletItem::StoreFont( SvStream& rStream, const Font& rFont ) |
| { |
| sal_uInt16 nTemp; |
| |
| rStream << rFont.GetColor(); |
| nTemp = (sal_uInt16)rFont.GetFamily(); rStream << nTemp; |
| |
| // #90477# nTemp = (sal_uInt16)GetStoreCharSet( rFont.GetCharSet(), rStream.GetVersion() ); |
| nTemp = (sal_uInt16)GetSOStoreTextEncoding((rtl_TextEncoding)rFont.GetCharSet(), (sal_uInt16)rStream.GetVersion()); |
| rStream << nTemp; |
| |
| nTemp = (sal_uInt16)rFont.GetPitch(); rStream << nTemp; |
| nTemp = (sal_uInt16)rFont.GetAlign(); rStream << nTemp; |
| nTemp = (sal_uInt16)rFont.GetWeight(); rStream << nTemp; |
| nTemp = (sal_uInt16)rFont.GetUnderline(); rStream << nTemp; |
| nTemp = (sal_uInt16)rFont.GetStrikeout(); rStream << nTemp; |
| nTemp = (sal_uInt16)rFont.GetItalic(); rStream << nTemp; |
| |
| // UNICODE: rStream << rFont.GetName(); |
| rStream.WriteByteString(rFont.GetName()); |
| |
| rStream << rFont.IsOutline(); |
| rStream << rFont.IsShadow(); |
| rStream << rFont.IsTransparent(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Font SvxBulletItem::CreateFont( SvStream& rStream, sal_uInt16 nVer ) |
| { |
| Font aFont; |
| Color aColor; |
| rStream >> aColor; aFont.SetColor( aColor ); |
| sal_uInt16 nTemp; |
| rStream >> nTemp; aFont.SetFamily((FontFamily)nTemp); |
| |
| // #90477# |
| rStream >> nTemp; |
| nTemp = (sal_uInt16)GetSOLoadTextEncoding((rtl_TextEncoding)nTemp, (sal_uInt16)rStream.GetVersion()); |
| aFont.SetCharSet((rtl_TextEncoding)nTemp); |
| |
| rStream >> nTemp; aFont.SetPitch((FontPitch)nTemp); |
| rStream >> nTemp; aFont.SetAlign((FontAlign)nTemp); |
| rStream >> nTemp; aFont.SetWeight((FontWeight)nTemp); |
| rStream >> nTemp; aFont.SetUnderline((FontUnderline)nTemp); |
| rStream >> nTemp; aFont.SetStrikeout((FontStrikeout)nTemp); |
| rStream >> nTemp; aFont.SetItalic((FontItalic)nTemp); |
| |
| // UNICODE: rStream >> aName; aFont.SetName( aName ); |
| String aName; |
| rStream.ReadByteString(aName); |
| aFont.SetName( aName ); |
| |
| if( nVer == 1 ) |
| { |
| long nHeight, nWidth; |
| rStream >> nHeight; rStream >> nWidth; Size aSize( nWidth, nHeight ); |
| aFont.SetSize( aSize ); |
| } |
| |
| sal_Bool bTemp; |
| rStream >> bTemp; aFont.SetOutline( bTemp ); |
| rStream >> bTemp; aFont.SetShadow( bTemp ); |
| rStream >> bTemp; aFont.SetTransparent( bTemp ); |
| return aFont; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( sal_uInt16 _nWhich ) : SfxPoolItem( _nWhich ) |
| { |
| SetDefaultFont_Impl(); |
| SetDefaults_Impl(); |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( sal_uInt8 nNewStyle, const Font& rFont, sal_uInt16 /*nStart*/, sal_uInt16 _nWhich ) : SfxPoolItem( _nWhich ) |
| { |
| SetDefaults_Impl(); |
| nStyle = nNewStyle; |
| aFont = rFont; |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( const Font& rFont, xub_Unicode cSymb, sal_uInt16 _nWhich ) : SfxPoolItem( _nWhich ) |
| { |
| SetDefaults_Impl(); |
| aFont = rFont; |
| cSymbol = cSymb; |
| nStyle = BS_BULLET; |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( const Bitmap& rBmp, sal_uInt16 _nWhich ) : SfxPoolItem( _nWhich ) |
| { |
| SetDefaults_Impl(); |
| |
| if( !rBmp.IsEmpty() ) |
| { |
| pGraphicObject = new GraphicObject( rBmp ); |
| nStyle = BS_BMP; |
| } |
| |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( const GraphicObject& rGraphicObject, sal_uInt16 _nWhich ) : SfxPoolItem( _nWhich ) |
| { |
| SetDefaults_Impl(); |
| |
| if( ( GRAPHIC_NONE != pGraphicObject->GetType() ) && ( GRAPHIC_DEFAULT != pGraphicObject->GetType() ) ) |
| { |
| pGraphicObject = new GraphicObject( rGraphicObject ); |
| nStyle = BS_BMP; |
| } |
| |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( SvStream& rStrm, sal_uInt16 _nWhich ) : |
| SfxPoolItem( _nWhich ), |
| pGraphicObject( NULL ) |
| { |
| rStrm >> nStyle; |
| |
| if( nStyle != BS_BMP ) |
| aFont = CreateFont( rStrm, BULITEM_VERSION ); |
| else |
| { |
| // Sicheres Laden mit Test auf leere Bitmap |
| Bitmap aBmp; |
| const sal_uInt32 nOldPos = rStrm.Tell(); |
| // #69345# Errorcode beim Bitmap lesen ignorieren, |
| // siehe Kommentar #67581# in SvxBulletItem::Store() |
| sal_Bool bOldError = rStrm.GetError() ? sal_True : sal_False; |
| ReadDIB(aBmp, rStrm, true); |
| |
| if ( !bOldError && rStrm.GetError() ) |
| { |
| rStrm.ResetError(); |
| // #71493# Keine Warnung: Das BulletItem interessiert seit 5.0 im Dateiformat nicht mehr. |
| // rStrm.SetError(ERRCODE_CLASS_READ | ERRCODE_SVX_BULLETITEM_NOBULLET | ERRCODE_WARNING_MASK); |
| } |
| |
| if( aBmp.IsEmpty() ) |
| { |
| rStrm.Seek( nOldPos ); |
| nStyle = BS_NONE; |
| } |
| else |
| pGraphicObject = new GraphicObject( aBmp ); |
| } |
| |
| rStrm >> nWidth; |
| rStrm >> nStart; |
| rStrm >> nJustify; |
| |
| char cTmpSymbol; |
| rStrm >> cTmpSymbol; |
| cSymbol = ByteString::ConvertToUnicode( cTmpSymbol, aFont.GetCharSet() ); |
| |
| rStrm >> nScale; |
| |
| // UNICODE: rStrm >> aPrevText; |
| rStrm.ReadByteString(aPrevText); |
| |
| // UNICODE: rStrm >> aFollowText; |
| rStrm.ReadByteString(aFollowText); |
| |
| nValidMask = 0xFFFF; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::SvxBulletItem( const SvxBulletItem& rItem) : SfxPoolItem( rItem ) |
| { |
| aFont = rItem.aFont; |
| pGraphicObject = ( rItem.pGraphicObject ? new GraphicObject( *rItem.pGraphicObject ) : NULL ); |
| aPrevText = rItem.aPrevText; |
| aFollowText = rItem.aFollowText; |
| nStart = rItem.nStart; |
| nStyle = rItem.nStyle; |
| nWidth = rItem.nWidth; |
| nScale = rItem.nScale; |
| cSymbol = rItem.cSymbol; |
| nJustify = rItem.nJustify; |
| nValidMask = rItem.nValidMask; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvxBulletItem::~SvxBulletItem() |
| { |
| if( pGraphicObject ) |
| delete pGraphicObject; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SfxPoolItem* SvxBulletItem::Clone( SfxItemPool * /*pPool*/ ) const |
| { |
| return new SvxBulletItem( *this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SfxPoolItem* SvxBulletItem::Create( SvStream& rStrm, sal_uInt16 /*nVersion*/ ) const |
| { |
| return new SvxBulletItem( rStrm, Which() ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxBulletItem::SetDefaultFont_Impl() |
| { |
| aFont = OutputDevice::GetDefaultFont( DEFAULTFONT_FIXED, LANGUAGE_SYSTEM, 0 ); |
| aFont.SetAlign( ALIGN_BOTTOM); |
| aFont.SetTransparent( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxBulletItem::SetDefaults_Impl() |
| { |
| pGraphicObject = NULL; |
| nWidth = 1200; // 1.2cm |
| nStart = 1; |
| nStyle = BS_123; |
| nJustify = BJ_HLEFT | BJ_VCENTER; |
| cSymbol = sal_Unicode(' '); |
| nScale = 75; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 SvxBulletItem::GetVersion( sal_uInt16 /*nVersion*/ ) const |
| { |
| return BULITEM_VERSION; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SvxBulletItem::CopyValidProperties( const SvxBulletItem& rCopyFrom ) |
| { |
| Font _aFont = GetFont(); |
| Font aNewFont = rCopyFrom.GetFont(); |
| if ( rCopyFrom.IsValid( VALID_FONTNAME ) ) |
| { |
| _aFont.SetName( aNewFont.GetName() ); |
| _aFont.SetFamily( aNewFont.GetFamily() ); |
| _aFont.SetStyleName( aNewFont.GetStyleName() ); |
| } |
| if ( rCopyFrom.IsValid( VALID_FONTCOLOR ) ) |
| _aFont.SetColor( aNewFont.GetColor() ); |
| if ( rCopyFrom.IsValid( VALID_SYMBOL ) ) |
| SetSymbol( rCopyFrom.GetSymbol() ); |
| if ( rCopyFrom.IsValid( VALID_BITMAP ) ) |
| SetGraphicObject( rCopyFrom.GetGraphicObject() ); |
| if ( rCopyFrom.IsValid( VALID_SCALE ) ) |
| SetScale( rCopyFrom.GetScale() ); |
| if ( rCopyFrom.IsValid( VALID_START ) ) |
| SetStart( rCopyFrom.GetStart() ); |
| if ( rCopyFrom.IsValid( VALID_STYLE ) ) |
| SetStyle( rCopyFrom.GetStyle() ); |
| if ( rCopyFrom.IsValid( VALID_PREVTEXT ) ) |
| SetPrevText( rCopyFrom.GetPrevText() ); |
| if ( rCopyFrom.IsValid( VALID_FOLLOWTEXT ) ) |
| SetFollowText( rCopyFrom.GetFollowText() ); |
| |
| SetFont( _aFont ); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| int SvxBulletItem::operator==( const SfxPoolItem& rItem ) const |
| { |
| DBG_ASSERT(rItem.ISA(SvxBulletItem),"operator==Types not matching"); |
| const SvxBulletItem& rBullet = (const SvxBulletItem&)rItem; |
| // ValidMask mitvergleichen, da sonst kein Putten in ein AttrSet moeglich, |
| // wenn sich das Item nur in der ValidMask von einem existierenden unterscheidet. |
| if( nValidMask != rBullet.nValidMask || |
| nStyle != rBullet.nStyle || |
| nScale != rBullet.nScale || |
| nJustify != rBullet.nJustify || |
| nWidth != rBullet.nWidth || |
| nStart != rBullet.nStart || |
| cSymbol != rBullet.cSymbol || |
| aPrevText != rBullet.aPrevText || |
| aFollowText != rBullet.aFollowText ) |
| return 0; |
| |
| if( ( nStyle != BS_BMP ) && ( aFont != rBullet.aFont ) ) |
| return 0; |
| |
| if( nStyle == BS_BMP ) |
| { |
| if( ( pGraphicObject && !rBullet.pGraphicObject ) || ( !pGraphicObject && rBullet.pGraphicObject ) ) |
| return 0; |
| |
| if( ( pGraphicObject && rBullet.pGraphicObject ) && |
| ( ( *pGraphicObject != *rBullet.pGraphicObject ) || |
| ( pGraphicObject->GetPrefSize() != rBullet.pGraphicObject->GetPrefSize() ) ) ) |
| { |
| return 0; |
| } |
| } |
| |
| return 1; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvStream& SvxBulletItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const |
| { |
| // Korrektur bei leerer Bitmap |
| if( ( nStyle == BS_BMP ) && |
| ( !pGraphicObject || ( GRAPHIC_NONE == pGraphicObject->GetType() ) || ( GRAPHIC_DEFAULT == pGraphicObject->GetType() ) ) ) |
| { |
| if( pGraphicObject ) |
| { |
| delete( const_cast< SvxBulletItem* >( this )->pGraphicObject ); |
| const_cast< SvxBulletItem* >( this )->pGraphicObject = NULL; |
| } |
| |
| const_cast< SvxBulletItem* >( this )->nStyle = BS_NONE; |
| } |
| |
| rStrm << nStyle; |
| |
| if( nStyle != BS_BMP ) |
| StoreFont( rStrm, aFont ); |
| else |
| { |
| sal_uLong _nStart = rStrm.Tell(); |
| |
| // Kleine Vorab-Schaetzung der Groesse... |
| sal_uInt16 nFac = ( rStrm.GetCompressMode() != COMPRESSMODE_NONE ) ? 3 : 1; |
| const Bitmap aBmp( pGraphicObject->GetGraphic().GetBitmap() ); |
| sal_uLong nBytes = aBmp.GetSizeBytes(); |
| if ( nBytes < sal_uLong(0xFF00*nFac) ) |
| { |
| WriteDIB(aBmp, rStrm, false, true); |
| } |
| |
| sal_uLong nEnd = rStrm.Tell(); |
| // #67581# Item darf mit Overhead nicht mehr als 64K schreiben, |
| // sonst platzt der SfxMultiRecord |
| // Dann lieber auf die Bitmap verzichten, ist nur fuer Outliner |
| // und auch nur fuer <= 5.0 wichtig. |
| // Beim Einlesen merkt der Stream-Operator der Bitmap, dass dort keine steht. |
| // Hiermit funktioniert jetzt der Fall das die grosse Bitmap aus einem anderen |
| // Fileformat entstanden ist, welches keine 64K belegt, aber wenn eine |
| // Bitmap > 64K verwendet wird, hat das SvxNumBulletItem beim Laden ein Problem, |
| // stuerzt aber nicht ab. |
| |
| if ( (nEnd-_nStart) > 0xFF00 ) |
| rStrm.Seek( _nStart ); |
| } |
| rStrm << nWidth; |
| rStrm << nStart; |
| rStrm << nJustify; |
| rStrm << (char)ByteString::ConvertFromUnicode( cSymbol, aFont.GetCharSet() ); |
| rStrm << nScale; |
| |
| // UNICODE: rStrm << aPrevText; |
| rStrm.WriteByteString(aPrevText); |
| |
| // UNICODE: rStrm << aFollowText; |
| rStrm.WriteByteString(aFollowText); |
| |
| return rStrm; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| XubString SvxBulletItem::GetFullText() const |
| { |
| XubString aStr( aPrevText ); |
| aStr += cSymbol; |
| aStr += aFollowText; |
| return aStr; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| SfxItemPresentation SvxBulletItem::GetPresentation |
| ( |
| SfxItemPresentation ePres, |
| SfxMapUnit /*eCoreUnit*/, |
| SfxMapUnit /*ePresUnit*/, |
| XubString& rText, const IntlWrapper * |
| ) const |
| { |
| SfxItemPresentation eRet = SFX_ITEM_PRESENTATION_NONE; |
| switch ( ePres ) |
| { |
| case SFX_ITEM_PRESENTATION_NONE: |
| rText.Erase(); |
| eRet = SFX_ITEM_PRESENTATION_NONE; |
| break; |
| |
| case SFX_ITEM_PRESENTATION_NAMELESS: |
| case SFX_ITEM_PRESENTATION_COMPLETE: |
| rText = GetFullText(); |
| eRet = SFX_ITEM_PRESENTATION_COMPLETE; |
| break; |
| default: ; //prevent warning |
| } |
| return eRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| Bitmap SvxBulletItem::GetBitmap() const |
| { |
| if( pGraphicObject ) |
| return pGraphicObject->GetGraphic().GetBitmap(); |
| else |
| { |
| const Bitmap aDefaultBitmap; |
| return aDefaultBitmap; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| void SvxBulletItem::SetBitmap( const Bitmap& rBmp ) |
| { |
| if( rBmp.IsEmpty() ) |
| { |
| if( pGraphicObject ) |
| { |
| delete pGraphicObject; |
| pGraphicObject = NULL; |
| } |
| } |
| else |
| { |
| delete pGraphicObject; |
| pGraphicObject = new GraphicObject( rBmp ); |
| |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| const GraphicObject& SvxBulletItem::GetGraphicObject() const |
| { |
| if( pGraphicObject ) |
| return *pGraphicObject; |
| else |
| { |
| static const GraphicObject aDefaultObject; |
| return aDefaultObject; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| void SvxBulletItem::SetGraphicObject( const GraphicObject& rGraphicObject ) |
| { |
| if( ( GRAPHIC_NONE == rGraphicObject.GetType() ) || ( GRAPHIC_DEFAULT == rGraphicObject.GetType() ) ) |
| { |
| if( pGraphicObject ) |
| { |
| delete pGraphicObject; |
| pGraphicObject = NULL; |
| } |
| } |
| else |
| { |
| delete pGraphicObject; |
| pGraphicObject = new GraphicObject( rGraphicObject ); |
| } |
| } |