/************************************************************************* * * $RCSfile: textitem.cxx,v $ * * $Revision: 1.43 $ * * last change: $Author: jp $ $Date: 2001-08-14 16:04:47 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ // include --------------------------------------------------------------- #ifndef _COM_SUN_STAR_STYLE_CASEMAP_HPP_ #include #endif #ifndef _SV_BITMAPEX_HXX #include #endif #ifndef _STREAM_HXX #include #endif #include #include #ifndef _TOOLS_SOLMATH_HXX #include #endif #include #pragma hdrstop #define ITEMID_FONTLIST 0 #define ITEMID_FONT 0 #define ITEMID_POSTURE 0 #define ITEMID_WEIGHT 0 #define ITEMID_FONTHEIGHT 0 #define ITEMID_UNDERLINE 0 #define ITEMID_CROSSEDOUT 0 #define ITEMID_SHADOWED 0 #define ITEMID_AUTOKERN 0 #define ITEMID_WORDLINEMODE 0 #define ITEMID_CONTOUR 0 #define ITEMID_PROPSIZE 0 #define ITEMID_COLOR 0 #define ITEMID_CHARSETCOLOR 0 #define ITEMID_KERNING 0 #define ITEMID_CASEMAP 0 #define ITEMID_ESCAPEMENT 0 #define ITEMID_LANGUAGE 0 #define ITEMID_NOLINEBREAK 0 #define ITEMID_NOHYPHENHERE 0 #define ITEMID_BLINK 0 #define ITEMID_EMPHASISMARK 0 #define ITEMID_TWOLINES 0 #define ITEMID_CHARROTATE 0 #define ITEMID_CHARSCALE_W 0 #define ITEMID_CHARRELIEF 0 #include #define GLOBALOVERFLOW3 #include #include "svxids.hrc" #include "svxitems.hrc" #ifndef NOOLDSV //autogen #include #endif #ifndef _VCL_VCLENUM_HXX #include #endif #ifndef _BIGINT_HXX //autogen #include #endif #ifndef _TOOLS_TENCCVT_HXX //autogen #include #endif #include #ifndef _ISOLANG_HXX #include #endif #ifndef _SFXITEMSET_HXX #include #endif #ifndef _SFXITEMPOOL_HXX #include #endif #ifndef _SV_SETTINGS_HXX #include #endif #ifndef _SV_SVAPP_HXX #include #endif #ifndef _COM_SUN_STAR_STYLE_CASEMAP_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_SIMPLEFONTMETRIC_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTWEIGHT_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTSLANT_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_CHARSET_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTDESCRIPTOR_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTWIDTH_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_XFONT_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTTYPE_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTUNDERLINE_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTSTRIKEOUT_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTFAMILY_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_FONTPITCH_HPP_ #include #endif #ifndef _COM_SUN_STAR_LANG_LOCALE_HPP_ #include #endif #ifndef _COM_SUN_STAR_TEXT_FONTEMPHASIS_HPP_ #include #endif #ifndef _SVX_UNOMID_HXX #include #endif #include "flstitem.hxx" #include "fontitem.hxx" #include "postitem.hxx" #include "wghtitem.hxx" #include "fhgtitem.hxx" #include "fwdtitem.hxx" #include "udlnitem.hxx" #include "crsditem.hxx" #include "shdditem.hxx" #include "akrnitem.hxx" #include "wrlmitem.hxx" #include "cntritem.hxx" #include "prszitem.hxx" #include "colritem.hxx" #include "cscoitem.hxx" #include "kernitem.hxx" #include "cmapitem.hxx" #include "escpitem.hxx" #include "langitem.hxx" #include "nlbkitem.hxx" #include "nhypitem.hxx" #include "lcolitem.hxx" #include "blnkitem.hxx" #include "emphitem.hxx" #include "twolinesitem.hxx" #include "scripttypeitem.hxx" #include "charrotateitem.hxx" #include "charscaleitem.hxx" #include "charreliefitem.hxx" #include "itemtype.hxx" #include "dialmgr.hxx" #include "langtab.hxx" #include "dlgutil.hxx" // #90477# #ifndef _TOOLS_TENCCVT_HXX #include #endif using namespace ::rtl; using namespace ::com::sun::star; using namespace ::com::sun::star::text; // Konvertierung fuer UNO #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L)) #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L)) // STATIC DATA ----------------------------------------------------------- // ----------------------------------------------------------------------- TYPEINIT1(SvxFontListItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxFontItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxPostureItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxWeightItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxFontHeightItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxFontWidthItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxUnderlineItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxCrossedOutItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxShadowedItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxAutoKernItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxWordLineModeItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxContourItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxPropSizeItem, SfxUInt16Item); TYPEINIT1_AUTOFACTORY(SvxColorItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxCharSetColorItem, SvxColorItem); TYPEINIT1_AUTOFACTORY(SvxKerningItem, SfxInt16Item); TYPEINIT1_AUTOFACTORY(SvxCaseMapItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxEscapementItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxLanguageItem, SfxEnumItem); TYPEINIT1_AUTOFACTORY(SvxNoLinebreakItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxNoHyphenItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxLineColorItem, SvxColorItem); TYPEINIT1_AUTOFACTORY(SvxBlinkItem, SfxBoolItem); TYPEINIT1_AUTOFACTORY(SvxEmphasisMarkItem, SfxUInt16Item); TYPEINIT1_AUTOFACTORY(SvxTwoLinesItem, SfxPoolItem); TYPEINIT1_AUTOFACTORY(SvxScriptTypeItem, SfxUInt16Item); TYPEINIT1_AUTOFACTORY(SvxCharRotateItem, SfxUInt16Item); TYPEINIT1_AUTOFACTORY(SvxCharScaleWidthItem, SfxUInt16Item); TYPEINIT1_AUTOFACTORY(SvxCharReliefItem, SfxEnumItem); TYPEINIT1(SvxScriptSetItem, SfxSetItem ); // class SvxFontListItem ------------------------------------------------- SvxFontListItem::SvxFontListItem( const FontList* pFontLst, const USHORT nId ) : SfxPoolItem( nId ), pFontList( pFontLst ) { } // ----------------------------------------------------------------------- SvxFontListItem::SvxFontListItem( const SvxFontListItem& rItem ) : SfxPoolItem( rItem ), pFontList( rItem.GetFontList() ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontListItem::Clone( SfxItemPool* ) const { return new SvxFontListItem( *this ); } // ----------------------------------------------------------------------- int SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const { DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); return( pFontList == ((SvxFontListItem&)rAttr).pFontList ); } //------------------------------------------------------------------------ SfxItemPresentation SvxFontListItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; } // class SvxFontItem ----------------------------------------------------- SvxFontItem::SvxFontItem( const USHORT nId ) : SfxPoolItem( nId ) { eFamily = FAMILY_SWISS; ePitch = PITCH_VARIABLE; eTextEncoding = RTL_TEXTENCODING_DONTKNOW; } // ----------------------------------------------------------------------- SvxFontItem::SvxFontItem( const FontFamily eFam, const XubString& aName, const XubString& aStName, const FontPitch eFontPitch, const rtl_TextEncoding eFontTextEncoding, const USHORT nId ) : SfxPoolItem( nId ), aFamilyName(aName), aStyleName(aStName) { eFamily = eFam; ePitch = eFontPitch; eTextEncoding = eFontTextEncoding; } // ----------------------------------------------------------------------- sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_FONT_FAMILY_NAME : rVal <<= OUString(aFamilyName.GetBuffer()); break; case MID_FONT_STYLE_NAME: rVal <<= OUString(aStyleName.GetBuffer()); break; case MID_FONT_FAMILY : rVal <<= (sal_Int16)(eFamily); break; case MID_FONT_CHAR_SET : rVal <<= (sal_Int16)(eTextEncoding); break; case MID_FONT_PITCH : rVal <<= (sal_Int16)(ePitch); break; } return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxFontItem::PutValue( const uno::Any& rVal, BYTE nMemberId) { switch(nMemberId) { case MID_FONT_FAMILY_NAME : { OUString aStr; if(!(rVal >>= aStr)) return sal_False; aFamilyName = aStr.getStr(); } break; case MID_FONT_STYLE_NAME: { OUString aStr; if(!(rVal >>= aStr)) return sal_False; aStyleName = aStr.getStr(); } break; case MID_FONT_FAMILY : { sal_Int16 nFamily; if(!(rVal >>= nFamily)) return sal_False; eFamily = (FontFamily)nFamily; } break; case MID_FONT_CHAR_SET : { sal_Int16 nSet; if(!(rVal >>= nSet)) return sal_False; eTextEncoding = (rtl_TextEncoding)nSet; } break; case MID_FONT_PITCH : { sal_Int16 nPitch; if(!(rVal >>= nPitch)) return sal_False; ePitch = (FontPitch)nPitch; } break; } return sal_True; } // ----------------------------------------------------------------------- int SvxFontItem::operator==( const SfxPoolItem& rAttr ) const { DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); const SvxFontItem& rItem = (const SvxFontItem&)rAttr; int bRet = ( eFamily == rItem.eFamily && aFamilyName == rItem.aFamilyName && aStyleName == rItem.aStyleName ); if ( bRet ) { if ( ePitch != rItem.ePitch || eTextEncoding != rItem.eTextEncoding ) { bRet = sal_False; DBG_WARNING( "FontItem::operator==(): nur Pitch oder rtl_TextEncoding unterschiedlich" ); } } return bRet; } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontItem::Clone( SfxItemPool * ) const { return new SvxFontItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxFontItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { BOOL bToBats = GetFamilyName().EqualsAscii( "StarSymbol", 0, sizeof("StarSymbol")-1 ) || GetFamilyName().EqualsAscii( "OpenSymbol", 0, sizeof("OpenSymbol")-1 ); // #90477# rStrm << (BYTE) GetFamily() // << (BYTE) GetPitch() // << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() ) ); rStrm << (BYTE) GetFamily() << (BYTE) GetPitch() << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())); if( bToBats ) { String sStarBats( "StarBats", sizeof("StarBats")-1, RTL_TEXTENCODING_ASCII_US ); rStrm.WriteByteString( sStarBats ); } else rStrm.WriteByteString(GetFamilyName()); // UNICODE: rStrm << GetFamilyName(); // UNICODE: rStrm << GetStyleName(); rStrm.WriteByteString(GetStyleName()); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, USHORT) const { BYTE eFamily, eFontPitch, eFontTextEncoding; String aName, aStyle; rStrm >> eFamily; rStrm >> eFontPitch; rStrm >> eFontTextEncoding; // UNICODE: rStrm >> aName; rStrm.ReadByteString(aName); // UNICODE: rStrm >> aStyle; rStrm.ReadByteString(aStyle); // Task 91008/90471: set the "correct" textencoding eFontTextEncoding = GetSOLoadTextEncoding( eFontTextEncoding, rStrm.GetVersion() ); // irgendwann wandelte sich der StarBats vom ANSI- zum SYMBOL-Font if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName.EqualsAscii("StarBats") ) eFontTextEncoding = RTL_TEXTENCODING_SYMBOL; return new SvxFontItem( (FontFamily)eFamily, aName, aStyle, (FontPitch)eFontPitch, (rtl_TextEncoding)eFontTextEncoding, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxFontItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = aFamilyName; return ePres; } return SFX_ITEM_PRESENTATION_NONE; } // class SvxPostureItem -------------------------------------------------- SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const USHORT nId ) : SfxEnumItem( nId, ePosture ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxPostureItem::Clone( SfxItemPool * ) const { return new SvxPostureItem( *this ); } // ----------------------------------------------------------------------- USHORT SvxPostureItem::GetValueCount() const { return ITALIC_NORMAL + 1; // auch ITALIC_NONE geh"ort dazu } // ----------------------------------------------------------------------- SvStream& SvxPostureItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, USHORT) const { BYTE nPosture; rStrm >> nPosture; return new SvxPostureItem( (const FontItalic)nPosture, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxPostureItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); return ePres; } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxPostureItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos <= (USHORT)ITALIC_NORMAL, "enum overflow!" ); XubString sTxt; FontItalic eItalic = (FontItalic)nPos; USHORT nId = 0; switch ( eItalic ) { case ITALIC_NONE: nId = RID_SVXITEMS_ITALIC_NONE; break; case ITALIC_OBLIQUE: nId = RID_SVXITEMS_ITALIC_OBLIQUE; break; case ITALIC_NORMAL: nId = RID_SVXITEMS_ITALIC_NORMAL; break; } if ( nId ) sTxt = SVX_RESSTR( nId ); return sTxt; } /*-----------------13.03.98 14:28------------------- --------------------------------------------------*/ sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch( nMemberId ) { case MID_ITALIC: rVal = Bool2Any(GetBoolValue()); break; case MID_POSTURE: rVal <<= (awt::FontSlant)GetValue(); // Werte von awt::FontSlant und FontItalic sind gleich break; } return sal_True; } /*-----------------13.03.98 14:28------------------- --------------------------------------------------*/ sal_Bool SvxPostureItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { switch( nMemberId ) { case MID_ITALIC: SetBoolValue(Any2Bool(rVal)); break; case MID_POSTURE: { awt::FontSlant eSlant; if(!(rVal >>= eSlant)) { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; eSlant = (awt::FontSlant)nValue; } SetValue((USHORT)eSlant); } } return sal_True; } // ----------------------------------------------------------------------- int SvxPostureItem::HasBoolValue() const { return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxPostureItem::GetBoolValue() const { return ( (FontItalic)GetValue() >= ITALIC_OBLIQUE ); } // ----------------------------------------------------------------------- void SvxPostureItem::SetBoolValue( sal_Bool bVal ) { SetValue( bVal ? ITALIC_NORMAL : ITALIC_NONE ); } // class SvxWeightItem --------------------------------------------------- SvxWeightItem::SvxWeightItem( const FontWeight eWght, const USHORT nId ) : SfxEnumItem( nId, eWght ) { } // ----------------------------------------------------------------------- int SvxWeightItem::HasBoolValue() const { return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxWeightItem::GetBoolValue() const { return (FontWeight)GetValue() >= WEIGHT_BOLD; } // ----------------------------------------------------------------------- void SvxWeightItem::SetBoolValue( sal_Bool bVal ) { SetValue( bVal ? WEIGHT_BOLD : WEIGHT_NORMAL ); } // ----------------------------------------------------------------------- USHORT SvxWeightItem::GetValueCount() const { return WEIGHT_BLACK; // WEIGHT_DONTKNOW geh"ort nicht dazu } // ----------------------------------------------------------------------- SfxPoolItem* SvxWeightItem::Clone( SfxItemPool * ) const { return new SvxWeightItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxWeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, USHORT) const { BYTE nWeight; rStrm >> nWeight; return new SvxWeightItem( (FontWeight)nWeight, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxWeightItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); return ePres; } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxWeightItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos <= (USHORT)WEIGHT_BLACK, "enum overflow!" ); return SVX_RESSTR( RID_SVXITEMS_WEIGHT_BEGIN + nPos ); } /*-----------------13.03.98 14:18------------------- --------------------------------------------------*/ sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch( nMemberId ) { case MID_BOLD : rVal = Bool2Any(GetBoolValue()); break; case MID_WEIGHT: { rVal <<= (float)( VCLUnoHelper::ConvertFontWeight( (FontWeight)GetValue() ) ); } break; } return sal_True; } /*-----------------13.03.98 14:18------------------- --------------------------------------------------*/ sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { switch( nMemberId ) { case MID_BOLD : SetBoolValue(Any2Bool(rVal)); break; case MID_WEIGHT: { double fValue; if(!(rVal >>= fValue)) { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; fValue = (float)nValue; } SetValue( VCLUnoHelper::ConvertFontWeight((float)fValue) ); } break; } return sal_True; } // class SvxFontHeightItem ----------------------------------------------- SvxFontHeightItem::SvxFontHeightItem( const ULONG nSz, const USHORT nPrp, const USHORT nId ) : SfxPoolItem( nId ) { SetHeight( nSz,nPrp ); // mit den Prozenten rechnen } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontHeightItem::Clone( SfxItemPool * ) const { return new SvxFontHeightItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxFontHeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (USHORT)GetHeight(); if( FONTHEIGHT_UNIT_VERSION <= nItemVersion ) rStrm << GetProp() << (USHORT)GetPropUnit(); else { // JP 30.06.98: beim Export in alte Versionen geht die relative // Angabe verloren, wenn es keine Prozentuale ist USHORT nProp = GetProp(); if( SFX_MAPUNIT_RELATIVE != GetPropUnit() ) nProp = 100; rStrm << nProp; } return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm, USHORT nVersion ) const { USHORT nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE; rStrm >> nsize; if( FONTHEIGHT_16_VERSION <= nVersion ) rStrm >> nprop; else { BYTE nP; rStrm >> nP; nprop = (USHORT)nP; } if( FONTHEIGHT_UNIT_VERSION <= nVersion ) rStrm >> nPropUnit; SvxFontHeightItem* pItem = new SvxFontHeightItem( nsize, 100, Which() ); pItem->SetProp( nprop, (SfxMapUnit)nPropUnit ); return pItem; } // ----------------------------------------------------------------------- int SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const { DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); return GetHeight() == ((SvxFontHeightItem&)rItem).GetHeight() && GetProp() == ((SvxFontHeightItem&)rItem).GetProp() && GetPropUnit() == ((SvxFontHeightItem&)rItem).GetPropUnit(); } /*-----------------13.03.98 14:53------------------- --------------------------------------------------*/ sal_Bool SvxFontHeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { // In StarOne sind im uno::Any immer 1/100mm. Ueber die MemberId wird // gesteuert, ob der Wert im Item 1/100mm oder Twips sind. sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); nMemberId &= ~CONVERT_TWIPS; switch( nMemberId ) { case MID_FONTHEIGHT: { // Point (also Twips) sind gefragt, // also umrechnen, wenn CONVERT_TWIPS nicht gesetzt ist if( bConvert ) { long nTwips = bConvert ? nHeight : MM100_TO_TWIP(nHeight); rVal <<= (float)( nTwips / 20.0 ); } else { double fPoints = MM100_TO_TWIP((long)nHeight) / 20.0; float fRoundPoints = static_cast(SolarMath::Round(fPoints, 1)); rVal <<= fRoundPoints; } } break; case MID_FONTHEIGHT_PROP: rVal <<= (sal_Int16)(SFX_MAPUNIT_RELATIVE == ePropUnit ? nProp : 100); break; case MID_FONTHEIGHT_DIFF: { float fRet = (float)(short)nProp; switch( ePropUnit ) { case SFX_MAPUNIT_RELATIVE: fRet = 0.; break; case SFX_MAPUNIT_100TH_MM: fRet = MM100_TO_TWIP(fRet); fRet /= 20.; break; case SFX_MAPUNIT_POINT: break; case SFX_MAPUNIT_TWIP: fRet /= 20.; break; } rVal <<= fRet; } break; } return sal_True; } /* -----------------01.07.98 13:43------------------- * Relative Abweichung aus der Hoehe herausrechnen * --------------------------------------------------*/ sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, SfxMapUnit eProp, sal_Bool bCoreInTwip) { sal_uInt32 nRet = nHeight; short nDiff = 0; switch( eProp ) { case SFX_MAPUNIT_RELATIVE: nRet *= 100; nRet /= nProp; break; case SFX_MAPUNIT_POINT: { short nTemp = (short)nProp; nDiff = nTemp * 20; if(!bCoreInTwip) nDiff = (short)TWIP_TO_MM100((long)(nDiff)); } break; case SFX_MAPUNIT_100TH_MM: //dann ist die Core doch wohl auch in 1/100 mm nDiff = (short)nProp; break; case SFX_MAPUNIT_TWIP: // hier doch sicher TWIP nDiff = ((short)nProp); break; } nRet -= nDiff; return nRet; } /*-----------------13.03.98 14:53------------------- --------------------------------------------------*/ sal_Bool SvxFontHeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); nMemberId &= ~CONVERT_TWIPS; switch( nMemberId ) { case MID_FONTHEIGHT: { ePropUnit = SFX_MAPUNIT_RELATIVE; nProp = 100; double fPoint; if(!(rVal >>= fPoint)) { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; fPoint = (float)nValue; } if(fPoint < 0. || fPoint > 10000.) return sal_False; nHeight = (long)( fPoint * 20.0 + 0.5 ); // Twips if (!bConvert) nHeight = TWIP_TO_MM100(nHeight); // umrechnen, wenn das Item 1/100mm enthaelt } break; case MID_FONTHEIGHT_PROP: { sal_Int16 nNew; if(!(rVal >>= nNew)) return sal_True; nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert); nHeight *= nNew; nHeight /= 100; nProp = nNew; ePropUnit = SFX_MAPUNIT_RELATIVE; } break; case MID_FONTHEIGHT_DIFF: { nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert); float fValue; if(!(rVal >>= fValue)) { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; fValue = (float)nValue; } sal_Int16 nCoreDiffValue = (sal_Int16)(fValue * 20.); nHeight += bConvert ? nCoreDiffValue : TWIP_TO_MM100(nCoreDiffValue); nProp = (sal_uInt16)((sal_Int16)fValue); ePropUnit = SFX_MAPUNIT_POINT; } break; } return sal_True; } //------------------------------------------------------------------------ SfxItemPresentation SvxFontHeightItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { if( SFX_MAPUNIT_RELATIVE != ePropUnit ) { ( rText = String::CreateFromInt32( (short)nProp ) ) += SVX_RESSTR( GetMetricId( ePropUnit ) ); if( 0 <= (short)nProp ) rText.Insert( sal_Unicode('+'), 0 ); } else if( 100 == nProp ) { rText = GetMetricText( (long)nHeight, eCoreUnit, SFX_MAPUNIT_POINT ); rText += SVX_RESSTR(GetMetricId(SFX_MAPUNIT_POINT)); } else ( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%'); return ePres; } } #endif return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- USHORT SvxFontHeightItem::GetVersion(USHORT nFileVersion) const { return (nFileVersion <= SOFFICE_FILEFORMAT_40) ? FONTHEIGHT_16_VERSION : FONTHEIGHT_UNIT_VERSION; } // ----------------------------------------------------------------------- int SvxFontHeightItem::ScaleMetrics( long nMult, long nDiv ) { nHeight = (sal_uInt32)Scale( nHeight, nMult, nDiv ); return 1; } // ----------------------------------------------------------------------- int SvxFontHeightItem::HasMetrics() const { return 1; } void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const USHORT nNewProp, SfxMapUnit eUnit ) { DBG_ASSERT( GetRef() == 0, "SetValue() with pooled item" ); #ifndef SVX_LIGHT if( SFX_MAPUNIT_RELATIVE != eUnit ) nHeight = nNewHeight + ::ItemToControl( (short)nNewProp, eUnit, SFX_FUNIT_TWIP ); else #endif // !SVX_LIGHT if( 100 != nNewProp ) nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 ); else nHeight = nNewHeight; nProp = nNewProp; ePropUnit = eUnit; } void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, USHORT nNewProp, SfxMapUnit eMetric, SfxMapUnit eCoreMetric ) { DBG_ASSERT( GetRef() == 0, "SetValue() with pooled item" ); #ifndef SVX_LIGHT if( SFX_MAPUNIT_RELATIVE != eMetric ) nHeight = nNewHeight + ::ControlToItem( ::ItemToControl((short)nNewProp, eMetric, SFX_FUNIT_TWIP ), SFX_FUNIT_TWIP, eCoreMetric ); else #endif // !SVX_LIGHT if( 100 != nNewProp ) nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 ); else nHeight = nNewHeight; nProp = nNewProp; ePropUnit = eMetric; } // class SvxFontWidthItem ----------------------------------------------- SvxFontWidthItem::SvxFontWidthItem( const USHORT nSz, const USHORT nPrp, const USHORT nId ) : SfxPoolItem( nId ) { nWidth = nSz; nProp = nPrp; } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontWidthItem::Clone( SfxItemPool * ) const { return new SvxFontWidthItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxFontWidthItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << GetWidth() << GetProp(); return rStrm; } // ----------------------------------------------------------------------- int SvxFontWidthItem::ScaleMetrics( long nMult, long nDiv ) { nWidth = (USHORT)Scale( nWidth, nMult, nDiv ); return 1; } // ----------------------------------------------------------------------- int SvxFontWidthItem::HasMetrics() const { return 1; } // ----------------------------------------------------------------------- SfxPoolItem* SvxFontWidthItem::Create( SvStream& rStrm, USHORT nVersion ) const { USHORT nS; USHORT nP; rStrm >> nS; rStrm >> nP; SvxFontWidthItem* pItem = new SvxFontWidthItem( 0, nP, Which() ); pItem->SetWidthValue( nS ); return pItem; } // ----------------------------------------------------------------------- int SvxFontWidthItem::operator==( const SfxPoolItem& rItem ) const { DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); return GetWidth() == ((SvxFontWidthItem&)rItem).GetWidth() && GetProp() == ((SvxFontWidthItem&)rItem).GetProp(); } /*-----------------13.03.98 16:03------------------- --------------------------------------------------*/ sal_Bool SvxFontWidthItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_FONTWIDTH: rVal <<= (sal_Int16)(nWidth); break; case MID_FONTWIDTH_PROP: rVal <<= (sal_Int16)(nProp); break; } return sal_True; } /*-----------------13.03.98 16:03------------------- --------------------------------------------------*/ sal_Bool SvxFontWidthItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_Int16 nVal; if(!(rVal >>= nVal)) return sal_False; switch(nMemberId) { case MID_FONTWIDTH: nProp = nVal; break; case MID_FONTWIDTH_PROP: nWidth = nVal; break; } return sal_True; } //------------------------------------------------------------------------ SfxItemPresentation SvxFontWidthItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { if ( 100 == nProp ) { rText = GetMetricText( (long)nWidth, eCoreUnit, SFX_MAPUNIT_POINT ); rText += SVX_RESSTR(GetMetricId(SFX_MAPUNIT_POINT)); } else ( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%'); return ePres; } } #endif return SFX_ITEM_PRESENTATION_NONE; } // class SvxUnderlineItem ------------------------------------------------ SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const USHORT nId ) : SfxEnumItem( nId, eSt ), mColor( COL_TRANSPARENT ) { } // ----------------------------------------------------------------------- int SvxUnderlineItem::HasBoolValue() const { return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxUnderlineItem::GetBoolValue() const { return (FontUnderline)GetValue() != UNDERLINE_NONE; } // ----------------------------------------------------------------------- void SvxUnderlineItem::SetBoolValue( sal_Bool bVal ) { SetValue( bVal ? UNDERLINE_SINGLE : UNDERLINE_NONE ); } // ----------------------------------------------------------------------- SfxPoolItem* SvxUnderlineItem::Clone( SfxItemPool * ) const { SvxUnderlineItem* pNew = new SvxUnderlineItem( *this ); pNew->SetColor( GetColor() ); return pNew; } // ----------------------------------------------------------------------- USHORT SvxUnderlineItem::GetValueCount() const { return UNDERLINE_DOTTED + 1; // auch UNDERLINE_NONE geh"ort dazu } // ----------------------------------------------------------------------- SvStream& SvxUnderlineItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, USHORT) const { BYTE nState; rStrm >> nState; return new SvxUnderlineItem( (FontUnderline)nState, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxUnderlineItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); if( !mColor.GetTransparency() ) ( rText += cpDelim ) += ::GetColorString( mColor ); return ePres; } #endif return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxUnderlineItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos <= (USHORT)UNDERLINE_BOLDWAVE, "enum overflow!" ); return SVX_RESSTR( RID_SVXITEMS_UL_BEGIN + nPos ); } /*-----------------13.03.98 16:25------------------- --------------------------------------------------*/ sal_Bool SvxUnderlineItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_UNDERLINED: rVal = Bool2Any(GetBoolValue()); break; case MID_UNDERLINE: rVal <<= (sal_Int16)(GetValue()); break; case MID_UL_COLOR: rVal <<= (sal_Int32)( mColor.GetColor() ); break; case MID_UL_HASCOLOR: rVal = Bool2Any( !mColor.GetTransparency() ); break; } return sal_True; } /*-----------------13.03.98 16:28------------------- --------------------------------------------------*/ sal_Bool SvxUnderlineItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_Bool bRet = sal_True; switch(nMemberId) { case MID_UNDERLINED: SetBoolValue(Any2Bool(rVal)); break; case MID_UNDERLINE: { sal_Int32 nValue; if(!(rVal >>= nValue)) bRet = sal_False; else SetValue((sal_Int16)nValue); } break; case MID_UL_COLOR: { sal_Int32 nCol; if( !( rVal >>= nCol ) ) bRet = sal_False; else { // Keep transparence, because it contains the information // whether the font color or the stored color should be used sal_uInt8 nTrans = mColor.GetTransparency(); mColor = Color( nCol ); mColor.SetTransparency( nTrans ); } } break; case MID_UL_HASCOLOR: mColor.SetTransparency( Any2Bool( rVal ) ? 0 : 0xff ); break; } return bRet; } int SvxUnderlineItem::operator==( const SfxPoolItem& rItem ) const { DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); return SfxEnumItem::operator==( rItem ) && GetColor() == ((SvxUnderlineItem&)rItem).GetColor(); } // class SvxCrossedOutItem ----------------------------------------------- SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const USHORT nId ) : SfxEnumItem( nId, eSt ) { } // ----------------------------------------------------------------------- int SvxCrossedOutItem::HasBoolValue() const { return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxCrossedOutItem::GetBoolValue() const { return (FontStrikeout)GetValue() != STRIKEOUT_NONE; } // ----------------------------------------------------------------------- void SvxCrossedOutItem::SetBoolValue( sal_Bool bVal ) { SetValue( bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE ); } // ----------------------------------------------------------------------- USHORT SvxCrossedOutItem::GetValueCount() const { return STRIKEOUT_DOUBLE + 1; // auch STRIKEOUT_NONE geh"ort dazu } // ----------------------------------------------------------------------- SfxPoolItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const { return new SvxCrossedOutItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxCrossedOutItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, USHORT) const { BYTE eCross; rStrm >> eCross; return new SvxCrossedOutItem( (FontStrikeout)eCross, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxCrossedOutItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); return ePres; } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxCrossedOutItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos <= (USHORT)STRIKEOUT_X, "enum overflow!" ); return SVX_RESSTR( RID_SVXITEMS_STRIKEOUT_BEGIN + nPos ); } /*-----------------13.03.98 16:28------------------- --------------------------------------------------*/ sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_CROSSED_OUT: rVal = Bool2Any(GetBoolValue()); break; case MID_CROSS_OUT: rVal <<= (sal_Int16)(GetValue()); break; } return sal_True; } /*-----------------13.03.98 16:29------------------- --------------------------------------------------*/ sal_Bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { switch(nMemberId) { case MID_CROSSED_OUT: SetBoolValue(Any2Bool(rVal)); break; case MID_CROSS_OUT: { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; SetValue((sal_Int16)nValue); } break; } return sal_True; } // class SvxShadowedItem ------------------------------------------------- SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const USHORT nId ) : SfxBoolItem( nId, bShadowed ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxShadowedItem::Clone( SfxItemPool * ) const { return new SvxShadowedItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxShadowedItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, USHORT) const { BYTE nState; rStrm >> nState; return new SvxShadowedItem( nState, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxShadowedItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { USHORT nId = RID_SVXITEMS_SHADOWED_FALSE; if ( GetValue() ) nId = RID_SVXITEMS_SHADOWED_TRUE; rText = SVX_RESSTR(nId); return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // class SvxAutoKernItem ------------------------------------------------- SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const USHORT nId ) : SfxBoolItem( nId, bAutoKern ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxAutoKernItem::Clone( SfxItemPool * ) const { return new SvxAutoKernItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxAutoKernItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, USHORT) const { BYTE nState; rStrm >> nState; return new SvxAutoKernItem( nState, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxAutoKernItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { USHORT nId = RID_SVXITEMS_AUTOKERN_FALSE; if ( GetValue() ) nId = RID_SVXITEMS_AUTOKERN_TRUE; rText = SVX_RESSTR(nId); return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // class SvxWordLineModeItem --------------------------------------------- SvxWordLineModeItem::SvxWordLineModeItem( const sal_Bool bWordLineMode, const USHORT nId ) : SfxBoolItem( nId, bWordLineMode ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const { return new SvxWordLineModeItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (sal_Bool) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, USHORT) const { sal_Bool bValue; rStrm >> bValue; return new SvxWordLineModeItem( bValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxWordLineModeItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { USHORT nId = RID_SVXITEMS_WORDLINE_FALSE; if ( GetValue() ) nId = RID_SVXITEMS_WORDLINE_TRUE; rText = SVX_RESSTR(nId); return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // class SvxContourItem -------------------------------------------------- SvxContourItem::SvxContourItem( const sal_Bool bContoured, const USHORT nId ) : SfxBoolItem( nId, bContoured ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxContourItem::Clone( SfxItemPool * ) const { return new SvxContourItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxContourItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (sal_Bool) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, USHORT) const { sal_Bool bValue; rStrm >> bValue; return new SvxContourItem( bValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxContourItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { USHORT nId = RID_SVXITEMS_CONTOUR_FALSE; if ( GetValue() ) nId = RID_SVXITEMS_CONTOUR_TRUE; rText = SVX_RESSTR(nId); return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // class SvxPropSizeItem ------------------------------------------------- SvxPropSizeItem::SvxPropSizeItem( const USHORT nPercent, const USHORT nId ) : SfxUInt16Item( nId, nPercent ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxPropSizeItem::Clone( SfxItemPool * ) const { return new SvxPropSizeItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxPropSizeItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (USHORT) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, USHORT) const { USHORT nSize; rStrm >> nSize; return new SvxPropSizeItem( nSize, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxPropSizeItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; } // class SvxColorItem ---------------------------------------------------- SvxColorItem::SvxColorItem( const USHORT nId ) : SfxPoolItem( nId ), mColor( COL_BLACK ) { } // ----------------------------------------------------------------------- SvxColorItem::SvxColorItem( const Color& rCol, const USHORT nId ) : SfxPoolItem( nId ), mColor( rCol ) { } // ----------------------------------------------------------------------- SvxColorItem::SvxColorItem( SvStream &rStrm, const USHORT nId ) : SfxPoolItem( nId ) { Color aColor; rStrm >> aColor; mColor = aColor; } // ----------------------------------------------------------------------- SvxColorItem::SvxColorItem( const SvxColorItem &rCopy ) : SfxPoolItem( rCopy ), mColor( rCopy.mColor ) { } // ----------------------------------------------------------------------- SvxColorItem::~SvxColorItem() { } // ----------------------------------------------------------------------- USHORT SvxColorItem::GetVersion( USHORT nFFVer ) const { DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || SOFFICE_FILEFORMAT_40==nFFVer || SOFFICE_FILEFORMAT_50==nFFVer, "SvxColorItem: Gibt es ein neues Fileformat?" ); return SOFFICE_FILEFORMAT_50 >= nFFVer ? VERSION_USEAUTOCOLOR : 0; } // ----------------------------------------------------------------------- int SvxColorItem::operator==( const SfxPoolItem& rAttr ) const { DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); return mColor == ( (const SvxColorItem&)rAttr ).mColor; } // ----------------------------------------------------------------------- sal_Bool SvxColorItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { rVal <<= (sal_Int32)(mColor.GetColor()); return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxColorItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_Int32 nColor; if(!(rVal >>= nColor)) return sal_False; mColor.SetColor( nColor ); return sal_True; } // ----------------------------------------------------------------------- SfxPoolItem* SvxColorItem::Clone( SfxItemPool * ) const { return new SvxColorItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { if( VERSION_USEAUTOCOLOR == nItemVersion && COL_AUTO == mColor.GetColor() ) rStrm << Color( COL_BLACK ); else rStrm << mColor; return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, USHORT nVer ) const { return new SvxColorItem( rStrm, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxColorItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = ::GetColorString( mColor ); return ePres; } #endif return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- void SvxColorItem::SetValue( const Color& rNewCol ) { mColor = rNewCol; } // class SvxCharSetColorItem --------------------------------------------- SvxCharSetColorItem::SvxCharSetColorItem( const USHORT nId ) : SvxColorItem( nId ), eFrom( RTL_TEXTENCODING_DONTKNOW ) { } // ----------------------------------------------------------------------- SvxCharSetColorItem::SvxCharSetColorItem( const Color& rCol, const rtl_TextEncoding eFrom, const USHORT nId ) : SvxColorItem( rCol, nId ), eFrom( eFrom ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxCharSetColorItem::Clone( SfxItemPool * ) const { return new SvxCharSetColorItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { // #90477# rStrm << (BYTE) GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() ) // << GetValue(); rStrm << (BYTE)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()) << GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, USHORT) const { BYTE cSet; Color aColor; rStrm >> cSet >> aColor; return new SvxCharSetColorItem( aColor, (rtl_TextEncoding)cSet, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxCharSetColorItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; } // class SvxKerningItem -------------------------------------------------- SvxKerningItem::SvxKerningItem( const short nKern, const USHORT nId ) : SfxInt16Item( nId, nKern ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxKerningItem::Clone( SfxItemPool * ) const { return new SvxKerningItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxKerningItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (short) GetValue(); return rStrm; } // ----------------------------------------------------------------------- int SvxKerningItem::ScaleMetrics( long nMult, long nDiv ) { SetValue( (sal_Int16)Scale( GetValue(), nMult, nDiv ) ); return 1; } // ----------------------------------------------------------------------- int SvxKerningItem::HasMetrics() const { return 1; } // ----------------------------------------------------------------------- SfxPoolItem* SvxKerningItem::Create(SvStream& rStrm, USHORT) const { short nValue; rStrm >> nValue; return new SvxKerningItem( nValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxKerningItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: rText = GetMetricText( (long)GetValue(), eCoreUnit, ePresUnit ); rText += SVX_RESSTR(GetMetricId(ePresUnit)); return ePres; case SFX_ITEM_PRESENTATION_COMPLETE: { rText = SVX_RESSTR(RID_SVXITEMS_KERNING_COMPLETE); USHORT nId = 0; if ( GetValue() > 0 ) nId = RID_SVXITEMS_KERNING_EXPANDED; else if ( GetValue() < 0 ) nId = RID_SVXITEMS_KERNING_CONDENSED; if ( nId ) rText += SVX_RESSTR(nId); rText += GetMetricText( (long)GetValue(), eCoreUnit, ePresUnit ); rText += SVX_RESSTR(GetMetricId(ePresUnit)); return ePres; } } #endif return SFX_ITEM_PRESENTATION_NONE; } /* -----------------------------19.02.01 12:21-------------------------------- ---------------------------------------------------------------------------*/ sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { sal_Int16 nVal = GetValue(); if(nMemberId & CONVERT_TWIPS) nVal = (sal_Int16)TWIP_TO_MM100(nVal); rVal <<= nVal; return sal_True; } // ----------------------------------------------------------------------- sal_Bool SvxKerningItem::PutValue( const uno::Any& rVal, BYTE nMemberId) { sal_Int16 nVal; if(!(rVal >>= nVal)) return sal_False; if(nMemberId & CONVERT_TWIPS) nVal = (sal_Int16)MM100_TO_TWIP(nVal); SetValue(nVal); return sal_True; } // class SvxCaseMapItem -------------------------------------------------- SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const USHORT nId ) : SfxEnumItem( nId, eMap ) { } // ----------------------------------------------------------------------- USHORT SvxCaseMapItem::GetValueCount() const { return SVX_CASEMAP_END; // SVX_CASEMAP_KAPITAELCHEN + 1 } // ----------------------------------------------------------------------- SfxPoolItem* SvxCaseMapItem::Clone( SfxItemPool * ) const { return new SvxCaseMapItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxCaseMapItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, USHORT) const { BYTE cMap; rStrm >> cMap; return new SvxCaseMapItem( (const SvxCaseMap)cMap, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxCaseMapItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); return ePres; } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxCaseMapItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos < (USHORT)SVX_CASEMAP_END, "enum overflow!" ); return SVX_RESSTR( RID_SVXITEMS_CASEMAP_BEGIN + nPos ); } /*-----------------13.03.98 16:29------------------- --------------------------------------------------*/ sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { sal_Int16 nRet = style::CaseMap::NONE; switch( GetValue() ) { // case SVX_CASEMAP_NOT_MAPPED : nRet = style::CaseMap::NONE ; break; case SVX_CASEMAP_VERSALIEN : nRet = style::CaseMap::UPPERCASE; break; case SVX_CASEMAP_GEMEINE : nRet = style::CaseMap::LOWERCASE; break; case SVX_CASEMAP_TITEL : nRet = style::CaseMap::TITLE ; break; case SVX_CASEMAP_KAPITAELCHEN: nRet = style::CaseMap::SMALLCAPS; break; } rVal <<= (sal_Int16)(nRet); return sal_True; } /*-----------------13.03.98 16:29------------------- --------------------------------------------------*/ sal_Bool SvxCaseMapItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_uInt16 nVal; if(!(rVal >>= nVal)) return sal_False; switch( nVal ) { case style::CaseMap::NONE : nVal = SVX_CASEMAP_NOT_MAPPED ; break; case style::CaseMap::UPPERCASE: nVal = SVX_CASEMAP_VERSALIEN ; break; case style::CaseMap::LOWERCASE: nVal = SVX_CASEMAP_GEMEINE ; break; case style::CaseMap::TITLE : nVal = SVX_CASEMAP_TITEL ; break; case style::CaseMap::SMALLCAPS: nVal = SVX_CASEMAP_KAPITAELCHEN; break; } SetValue(nVal); return sal_True; } // class SvxEscapementItem ----------------------------------------------- SvxEscapementItem::SvxEscapementItem( const USHORT nId ) : SfxEnumItemInterface( nId ), nEsc ( 0 ), nProp ( 100 ) { } // ----------------------------------------------------------------------- SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape, const USHORT nId ) : SfxEnumItemInterface( nId ), nProp( 100 ) { SetEscapement( eEscape ); if( nEsc ) nProp = 58; } // ----------------------------------------------------------------------- SvxEscapementItem::SvxEscapementItem( const short nEsc, const BYTE nProp, const USHORT nId ) : SfxEnumItemInterface( nId ), nEsc ( nEsc ), nProp ( nProp ) { } // ----------------------------------------------------------------------- int SvxEscapementItem::operator==( const SfxPoolItem& rAttr ) const { DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); return( nEsc == ((SvxEscapementItem&)rAttr).nEsc && nProp == ((SvxEscapementItem&)rAttr).nProp ); } // ----------------------------------------------------------------------- SfxPoolItem* SvxEscapementItem::Clone( SfxItemPool * ) const { return new SvxEscapementItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxEscapementItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { short nEsc = GetEsc(); if( SOFFICE_FILEFORMAT_31 == rStrm.GetVersion() ) { if( DFLT_ESC_AUTO_SUPER == nEsc ) nEsc = DFLT_ESC_SUPER; else if( DFLT_ESC_AUTO_SUB == nEsc ) nEsc = DFLT_ESC_SUB; } rStrm << (BYTE) GetProp() << (short) nEsc; return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, USHORT) const { BYTE nProp; short nEsc; rStrm >> nProp >> nEsc; return new SvxEscapementItem( nEsc, nProp, Which() ); } // ----------------------------------------------------------------------- USHORT SvxEscapementItem::GetValueCount() const { return SVX_ESCAPEMENT_END; // SVX_ESCAPEMENT_SUBSCRIPT + 1 } //------------------------------------------------------------------------ SfxItemPresentation SvxEscapementItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { rText = GetValueTextByPos( GetEnumValue() ); if ( nEsc != 0 ) { if( DFLT_ESC_AUTO_SUPER == nEsc || DFLT_ESC_AUTO_SUB == nEsc ) rText += String( SVX_RESSTR(RID_SVXITEMS_ESCAPEMENT_AUTO) ); else ( rText += String::CreateFromInt32( nEsc )) += sal_Unicode('%'); } return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- XubString SvxEscapementItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( nPos < (USHORT)SVX_ESCAPEMENT_END, "enum overflow!" ); return SVX_RESSTR(RID_SVXITEMS_ESCAPEMENT_BEGIN + nPos); } // ----------------------------------------------------------------------- USHORT SvxEscapementItem::GetEnumValue() const { if ( nEsc < 0 ) return SVX_ESCAPEMENT_SUBSCRIPT; else if ( nEsc > 0 ) return SVX_ESCAPEMENT_SUPERSCRIPT; return SVX_ESCAPEMENT_OFF; } // ----------------------------------------------------------------------- void SvxEscapementItem::SetEnumValue( USHORT nVal ) { SetEscapement( (const SvxEscapement)nVal ); } /*-----------------13.03.98 17:05------------------- --------------------------------------------------*/ sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_ESC: rVal <<= (sal_Int16)(nEsc); break; case MID_ESC_HEIGHT: rVal <<= (sal_Int8)(nProp); break; case MID_AUTO_ESC: rVal = Bool2Any(DFLT_ESC_AUTO_SUB == nEsc || DFLT_ESC_AUTO_SUPER == nEsc); break; } return sal_True; } /*-----------------13.03.98 17:05------------------- --------------------------------------------------*/ sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { switch(nMemberId) { case MID_ESC: { sal_Int16 nVal; if( (rVal >>= nVal) && (Abs(nVal) <= 101)) nEsc = nVal; else return sal_False; } break; case MID_ESC_HEIGHT: { sal_Int8 nVal; if( (rVal >>= nVal) && (nVal <= 100)) nProp = nVal; else return sal_False; } break; case MID_AUTO_ESC: { BOOL bVal = Any2Bool(rVal); if(bVal) { if(nEsc < 0) nEsc = DFLT_ESC_AUTO_SUB; else nEsc = DFLT_ESC_AUTO_SUPER; } else if(DFLT_ESC_AUTO_SUPER == nEsc ) --nEsc; else if(DFLT_ESC_AUTO_SUB == nEsc) ++nEsc; } break; } return sal_True; } // class SvxLanguageItem ------------------------------------------------- SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const USHORT nId ) : SfxEnumItem( nId , eLang ) { } // ----------------------------------------------------------------------- USHORT SvxLanguageItem::GetValueCount() const { return LANGUAGE_COUNT; // aus tlintl.hxx } // ----------------------------------------------------------------------- SfxPoolItem* SvxLanguageItem::Clone( SfxItemPool * ) const { return new SvxLanguageItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxLanguageItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (USHORT) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, USHORT) const { USHORT nValue; rStrm >> nValue; return new SvxLanguageItem( (LanguageType)nValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxLanguageItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { SvxLanguageTable aLangTable; rText = aLangTable.GetString( (LanguageType)GetValue() ); return ePres; } } #endif // !SVX_LIGHT return SFX_ITEM_PRESENTATION_NONE; } /*-----------------14.03.98 14:13------------------- --------------------------------------------------*/ sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch(nMemberId) { case MID_LANG_INT: rVal <<= (sal_Int16)(GetValue()); break; case MID_LANG_LOCALE: String sLanguage, sCountry; ::ConvertLanguageToIsoNames( GetValue(), sLanguage, sCountry ); lang::Locale aRet; aRet.Language = sLanguage; aRet.Country = sCountry; rVal <<= aRet; break; } return sal_True; } /*-----------------14.03.98 14:13------------------- --------------------------------------------------*/ sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { switch(nMemberId) { case MID_LANG_INT: { sal_Int32 nValue; if(!(rVal >>= nValue)) return sal_False; SetValue((sal_Int16)nValue); } break; case MID_LANG_LOCALE: { lang::Locale aLocale; if(!(rVal >>= aLocale)) return sal_False; if (aLocale.Language.getLength() || aLocale.Country.getLength()) SetValue(ConvertIsoNamesToLanguage( aLocale.Language, aLocale.Country )); else SetValue(LANGUAGE_NONE); } break; } return sal_True; } // class SvxNoLinebreakItem ---------------------------------------------- SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const USHORT nId ) : SfxBoolItem( nId, bBreak ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxNoLinebreakItem::Clone( SfxItemPool* ) const { return new SvxNoLinebreakItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (sal_Bool)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxNoLinebreakItem::Create(SvStream& rStrm, USHORT) const { sal_Bool bValue; rStrm >> bValue; return new SvxNoLinebreakItem( bValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxNoLinebreakItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; } // class SvxNoHyphenItem ------------------------------------------------- SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const USHORT nId ) : SfxBoolItem( nId , bHyphen ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const { return new SvxNoHyphenItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (sal_Bool) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxNoHyphenItem::Create( SvStream& rStrm, USHORT ) const { sal_Bool bValue; rStrm >> bValue; return new SvxNoHyphenItem( bValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxNoHyphenItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; } /* * Dummy-Item fuer ToolBox-Controls: * */ // ----------------------------------------------------------------------- // class SvxLineColorItem (== SvxColorItem) // ----------------------------------------------------------------------- SvxLineColorItem::SvxLineColorItem( const USHORT nId ) : SvxColorItem( nId ) { } // ----------------------------------------------------------------------- SvxLineColorItem::SvxLineColorItem( const Color& rCol, const USHORT nId ) : SvxColorItem( rCol, nId ) { } // ----------------------------------------------------------------------- SvxLineColorItem::SvxLineColorItem( SvStream &rStrm, const USHORT nId ) : SvxColorItem( rStrm, nId ) { } // ----------------------------------------------------------------------- SvxLineColorItem::SvxLineColorItem( const SvxLineColorItem &rCopy ) : SvxColorItem( rCopy ) { } // ----------------------------------------------------------------------- SvxLineColorItem::~SvxLineColorItem() { } //------------------------------------------------------------------------ SfxItemPresentation SvxLineColorItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * pIntlWrapper ) const { return SvxColorItem::GetPresentation( ePres, eCoreUnit, ePresUnit, rText, pIntlWrapper ); } // class SvxBlinkItem ------------------------------------------------- SvxBlinkItem::SvxBlinkItem( const sal_Bool bBlink, const USHORT nId ) : SfxBoolItem( nId, bBlink ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxBlinkItem::Clone( SfxItemPool * ) const { return new SvxBlinkItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxBlinkItem::Store( SvStream& rStrm , USHORT nItemVersion ) const { rStrm << (BYTE) GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, USHORT) const { BYTE nState; rStrm >> nState; return new SvxBlinkItem( nState, Which() ); } // ----------------------------------------------------------------------- SfxItemPresentation SvxBlinkItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { USHORT nId = RID_SVXITEMS_BLINK_FALSE; if ( GetValue() ) nId = RID_SVXITEMS_BLINK_TRUE; rText = SVX_RESSTR(nId); return ePres; } } return SFX_ITEM_PRESENTATION_NONE; } // class SvxEmphaisMarkItem --------------------------------------------------- SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue, const USHORT nId ) : SfxUInt16Item( nId, nValue ) { } // ----------------------------------------------------------------------- SfxPoolItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const { return new SvxEmphasisMarkItem( *this ); } // ----------------------------------------------------------------------- SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm, USHORT nItemVersion ) const { rStrm << (sal_uInt16)GetValue(); return rStrm; } // ----------------------------------------------------------------------- SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, USHORT ) const { sal_uInt16 nValue; rStrm >> nValue; return new SvxEmphasisMarkItem( (FontEmphasisMark)nValue, Which() ); } //------------------------------------------------------------------------ SfxItemPresentation SvxEmphasisMarkItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return ePres; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { sal_uInt16 nVal = GetValue(); rText = SVX_RESSTR( RID_SVXITEMS_EMPHASIS_BEGIN_STYLE + ( EMPHASISMARK_STYLE & nVal )); USHORT nId = ( EMPHASISMARK_POS_ABOVE & nVal ) ? RID_SVXITEMS_EMPHASIS_ABOVE_POS : ( EMPHASISMARK_POS_BELOW & nVal ) ? RID_SVXITEMS_EMPHASIS_BELOW_POS : 0; if( nId ) rText += SVX_RESSTR( nId ); return ePres; } break; } return SFX_ITEM_PRESENTATION_NONE; } // ----------------------------------------------------------------------- sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const { switch( nMemberId ) { case MID_EMPHASIS: { sal_Int16 nValue = GetValue(); sal_Int16 nRet = 0; switch(nValue & EMPHASISMARK_STYLE) { case EMPHASISMARK_NONE : nRet = FontEmphasis::NONE; break; case EMPHASISMARK_DOT : nRet = FontEmphasis::DOT_ABOVE; break; case EMPHASISMARK_CIRCLE : nRet = FontEmphasis::CIRCLE_ABOVE; break; case EMPHASISMARK_DISC : nRet = FontEmphasis::DISK_ABOVE; break; case EMPHASISMARK_ACCENT : nRet = FontEmphasis::ACCENT_ABOVE; break; } if(nRet && nValue & EMPHASISMARK_POS_BELOW) nRet += 10; rVal <<= nRet; } break; } return sal_True; } sal_Bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) { sal_Bool bRet = sal_True; switch( nMemberId ) { case MID_EMPHASIS: { sal_Int32 nValue = -1; rVal >>= nValue; switch(nValue) { case FontEmphasis::NONE : nValue = EMPHASISMARK_NONE; break; case FontEmphasis::DOT_ABOVE : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_ABOVE; break; case FontEmphasis::CIRCLE_ABOVE: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_ABOVE; break; case FontEmphasis::DISK_ABOVE : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_ABOVE; break; case FontEmphasis::ACCENT_ABOVE: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_ABOVE; break; case FontEmphasis::DOT_BELOW : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_BELOW; break; case FontEmphasis::CIRCLE_BELOW: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_BELOW; break; case FontEmphasis::DISK_BELOW : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_BELOW; break; case FontEmphasis::ACCENT_BELOW: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_BELOW; break; default: return sal_False; } SetValue( (sal_Int16)nValue ); } break; } return bRet; } USHORT SvxEmphasisMarkItem::GetVersion( USHORT nFFVer ) const { DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || SOFFICE_FILEFORMAT_40==nFFVer || SOFFICE_FILEFORMAT_50==nFFVer, "SvxEmphasisMarkItem: Gibt es ein neues Fileformat?" ); return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; } /************************************************************************* |* class SvxTwoLinesItem *************************************************************************/ SvxTwoLinesItem::SvxTwoLinesItem( sal_Bool bFlag, sal_Unicode nStartBracket, sal_Unicode nEndBracket, sal_uInt16 nW ) : SfxPoolItem( nW ), bOn( bFlag ), cStartBracket( nStartBracket ), cEndBracket( nEndBracket ) { } SvxTwoLinesItem::SvxTwoLinesItem( const SvxTwoLinesItem& rAttr ) : SfxPoolItem( rAttr.Which() ), bOn( rAttr.bOn ), cStartBracket( rAttr.cStartBracket ), cEndBracket( rAttr.cEndBracket ) { } SvxTwoLinesItem::~SvxTwoLinesItem() { } int SvxTwoLinesItem::operator==( const SfxPoolItem& rAttr ) const { DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "not equal attribute types" ); return bOn == ((SvxTwoLinesItem&)rAttr).bOn && cStartBracket == ((SvxTwoLinesItem&)rAttr).cStartBracket && cEndBracket == ((SvxTwoLinesItem&)rAttr).cEndBracket; } SfxPoolItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const { return new SvxTwoLinesItem( *this ); } sal_Bool SvxTwoLinesItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE nMemberId ) const { sal_Bool bRet = sal_True; switch( nMemberId ) { case MID_TWOLINES: rVal = Bool2Any( bOn ); break; case MID_START_BRACKET: { OUString s; if( cStartBracket ) s = OUString( cStartBracket ); rVal <<= s; } break; case MID_END_BRACKET: { OUString s; if( cEndBracket ) s = OUString( cEndBracket ); rVal <<= s; } break; default: bRet = sal_False; break; } return bRet; } sal_Bool SvxTwoLinesItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE nMemberId ) { sal_Bool bRet = sal_False; OUString s; switch( nMemberId ) { case MID_TWOLINES: bOn = Any2Bool( rVal ); bRet = sal_True; break; case MID_START_BRACKET: if( rVal >>= s ) { cStartBracket = s.getLength() ? s[ 0 ] : 0; bRet = sal_True; } break; case MID_END_BRACKET: if( rVal >>= s ) { cEndBracket = s.getLength() ? s[ 0 ] : 0; bRet = sal_True; } break; } return bRet; } SfxItemPresentation SvxTwoLinesItem::GetPresentation( SfxItemPresentation ePres, SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, String &rText, const IntlWrapper* pIntl ) const { switch( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); break; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { if( !GetValue() ) rText = SVX_RESSTR( RID_SVXITEMS_TWOLINES_OFF ); else { rText = SVX_RESSTR( RID_SVXITEMS_TWOLINES ); if( GetStartBracket() ) rText.Insert( GetStartBracket(), 0 ); if( GetEndBracket() ) rText += GetEndBracket(); } return ePres; } break; } return SFX_ITEM_PRESENTATION_NONE; } SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, USHORT nVer) const { sal_Bool bOn; sal_Unicode cStart, cEnd; rStrm >> bOn >> cStart >> cEnd; return new SvxTwoLinesItem( bOn, cStart, cEnd, Which() ); } SvStream& SvxTwoLinesItem::Store(SvStream & rStrm, USHORT nIVer) const { rStrm << GetValue() << GetStartBracket() << GetEndBracket(); return rStrm; } USHORT SvxTwoLinesItem::GetVersion( USHORT nFFVer ) const { DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || SOFFICE_FILEFORMAT_40==nFFVer || SOFFICE_FILEFORMAT_50==nFFVer, "SvxTwoLinesItem: Gibt es ein neues Fileformat?" ); return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; } /************************************************************************* |* class SvxCharRotateItem *************************************************************************/ SvxCharRotateItem::SvxCharRotateItem( sal_uInt16 nValue, sal_Bool bFitIntoLine, const sal_uInt16 nW ) : SfxUInt16Item( nW, nValue ), bFitToLine( bFitIntoLine ) { } SfxPoolItem* SvxCharRotateItem::Clone( SfxItemPool* ) const { return new SvxCharRotateItem( GetValue(), IsFitToLine(), Which() ); } SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, USHORT ) const { sal_uInt16 nVal; sal_Bool b; rStrm >> nVal >> b; return new SvxCharRotateItem( nVal, b, Which() ); } SvStream& SvxCharRotateItem::Store( SvStream & rStrm, USHORT ) const { sal_Bool bFlag = IsFitToLine(); rStrm << GetValue() << bFlag; return rStrm; } USHORT SvxCharRotateItem::GetVersion( USHORT nFFVer ) const { return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; } SfxItemPresentation SvxCharRotateItem::GetPresentation( SfxItemPresentation ePres, SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, String &rText, const IntlWrapper* ) const { switch( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); break; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { if( !GetValue() ) rText = SVX_RESSTR( RID_SVXITEMS_CHARROTATE_OFF ); else { rText = SVX_RESSTR( RID_SVXITEMS_CHARROTATE ); rText.SearchAndReplaceAscii( "$(ARG1)", String::CreateFromInt32( GetValue() / 10 )); if( IsFitToLine() ) rText += SVX_RESSTR( RID_SVXITEMS_CHARROTATE_FITLINE ); } return ePres; } break; } return SFX_ITEM_PRESENTATION_NONE; } sal_Bool SvxCharRotateItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE nMemberId ) const { sal_Bool bRet = sal_True; switch( nMemberId ) { case MID_ROTATE: rVal <<= (sal_Int16)GetValue(); break; case MID_FITTOLINE: rVal = Bool2Any( IsFitToLine() ); break; default: bRet = sal_False; break; } return bRet; } sal_Bool SvxCharRotateItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE nMemberId ) { sal_Bool bRet = sal_True; sal_Int16 nVal; switch( nMemberId ) { case MID_ROTATE: rVal >>= nVal; if(!nVal || 900 == nVal || 2700 == nVal) SetValue( (USHORT)nVal ); else bRet = sal_False; break; case MID_FITTOLINE: SetFitToLine( Any2Bool( rVal ) ); break; default: bRet = sal_False; } return bRet; } int SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const { DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); return SfxUInt16Item::operator==( rItem ) && IsFitToLine() == ((const SvxCharRotateItem&)rItem).IsFitToLine(); } /************************************************************************* |* class SvxCharScaleItem *************************************************************************/ SvxCharScaleWidthItem::SvxCharScaleWidthItem( sal_uInt16 nValue, const sal_uInt16 nW ) : SfxUInt16Item( nW, nValue ) { } SfxPoolItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const { return new SvxCharScaleWidthItem( GetValue(), Which() ); } SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, USHORT ) const { sal_uInt16 nVal; rStrm >> nVal; SvxCharScaleWidthItem* pItem = new SvxCharScaleWidthItem( nVal, Which() ); if ( Which() == EE_CHAR_FONTWIDTH ) { // #87271#: Was a SvxFontWidthItem in 5.2 // USHORT nFixWidth, USHORT nPropWidth. // nFixWidth has never been used... rStrm >> nVal; USHORT nTest; rStrm >> nTest; if ( nTest == 0x1234 ) pItem->SetValue( nVal ); else rStrm.SeekRel( -2*(long)sizeof(sal_uInt16) ); } return pItem; } SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, USHORT nVer ) const { SvStream& rRet = SfxUInt16Item::Store( rStream, nVer ); if ( Which() == EE_CHAR_FONTWIDTH ) { // see comment in Create().... rRet.SeekRel( -1*(long)sizeof(USHORT) ); rRet << (USHORT)0; rRet << GetValue(); // Really ugly, but not a problem for reading the doc in 5.2 rRet << (USHORT)0x1234; } return rRet; } USHORT SvxCharScaleWidthItem::GetVersion( USHORT nFFVer ) const { return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; } SfxItemPresentation SvxCharScaleWidthItem::GetPresentation( SfxItemPresentation ePres, SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, String &rText, const IntlWrapper* ) const { switch( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); break; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: { if( !GetValue() ) rText = SVX_RESSTR( RID_SVXITEMS_CHARSCALE_OFF ); else { rText = SVX_RESSTR( RID_SVXITEMS_CHARSCALE ); rText.SearchAndReplaceAscii( "$(ARG1)", String::CreateFromInt32( GetValue() )); } return ePres; } break; } return SFX_ITEM_PRESENTATION_NONE; } /************************************************************************* |* class SvxCharReliefItem *************************************************************************/ SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue, const sal_uInt16 nId ) : SfxEnumItem( nId, eValue ) { } SfxPoolItem* SvxCharReliefItem::Clone( SfxItemPool *pPool ) const { return new SvxCharReliefItem( *this ); } SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, USHORT) const { sal_uInt16 nVal; rStrm >> nVal; return new SvxCharReliefItem( (FontRelief)nVal, Which() ); } SvStream& SvxCharReliefItem::Store(SvStream & rStrm, USHORT nIVer) const { sal_uInt16 nVal = GetValue(); rStrm << nVal; return rStrm; } USHORT SvxCharReliefItem::GetVersion( USHORT nFFVer ) const { return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; } String SvxCharReliefItem::GetValueTextByPos( USHORT nPos ) const { DBG_ASSERT( RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE, "enum overflow" ); return String( SVX_RES( RID_SVXITEMS_RELIEF_BEGIN + nPos )); } USHORT SvxCharReliefItem::GetValueCount() const { return RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE; } SfxItemPresentation SvxCharReliefItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper * ) const { SfxItemPresentation eRet = ePres; switch( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); break; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueTextByPos( GetValue() ); break; default: eRet = SFX_ITEM_PRESENTATION_NONE; } return eRet; } sal_Bool SvxCharReliefItem::PutValue( const com::sun::star::uno::Any& rVal, BYTE nMemberId ) { sal_Bool bRet = sal_True; switch( nMemberId ) { case MID_RELIEF: { sal_Int16 nVal = -1; rVal >>= nVal; if(nVal >= 0 && nVal <= RELIEF_ENGRAVED) SetValue( (FontRelief)nVal ); else bRet = sal_False; } break; default: bRet = sal_False; break; } return bRet; } sal_Bool SvxCharReliefItem::QueryValue( com::sun::star::uno::Any& rVal, BYTE nMemberId ) const { sal_Bool bRet = sal_True; switch( nMemberId ) { case MID_RELIEF: rVal <<= (sal_Int16)GetValue(); break; default: bRet = sal_False; break; } return bRet; } /************************************************************************* |* class SvxScriptTypeItemItem *************************************************************************/ SvxScriptTypeItem::SvxScriptTypeItem( sal_uInt16 nType ) : SfxUInt16Item( SID_ATTR_CHAR_SCRIPTTYPE, nType ) { } SfxPoolItem* SvxScriptTypeItem::Clone( SfxItemPool *pPool ) const { return new SvxScriptTypeItem( GetValue() ); } /************************************************************************* |* class SvxScriptSetItem *************************************************************************/ SvxScriptSetItem::SvxScriptSetItem( USHORT nSlotId, SfxItemPool& rPool ) : SfxSetItem( nSlotId, new SfxItemSet( rPool, SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONT )) { USHORT nLatin, nAsian, nComplex; GetWhichIds( nLatin, nAsian, nComplex ); USHORT aIds[ 9 ] = { 0 }; aIds[ 0 ] = aIds[ 1 ] = nLatin; aIds[ 2 ] = aIds[ 3 ] = nAsian; aIds[ 4 ] = aIds[ 5 ] = nComplex; aIds[ 6 ] = aIds[ 7 ] = SID_ATTR_CHAR_SCRIPTTYPE; aIds[ 8 ] = 0; GetItemSet().SetRanges( aIds ); } SfxPoolItem* SvxScriptSetItem::Clone( SfxItemPool *pPool ) const { SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() ); p->GetItemSet().Put( GetItemSet(), FALSE ); return p; } SfxPoolItem* SvxScriptSetItem::Create( SvStream &, USHORT ) const { return 0; } const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet( const SfxItemSet& rSet, USHORT nId ) { const SfxPoolItem* pI; SfxItemState eSt = rSet.GetItemState( nId, FALSE, &pI ); if( SFX_ITEM_SET != eSt ) pI = SFX_ITEM_DEFAULT == eSt ? &rSet.Get( nId ) : 0; return pI; } const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( USHORT nScript ) const { USHORT nLatin, nAsian, nComplex; GetWhichIds( nLatin, nAsian, nComplex ); const SfxItemSet& rSet = GetItemSet(); const SfxPoolItem *pRet, *pAsn, *pCmplx; switch( nScript ) { default: //no one valid -> match to latin // case SCRIPTTYPE_LATIN: pRet = GetItemOfScriptSet( rSet, nLatin ); break; case SCRIPTTYPE_ASIAN: pRet = GetItemOfScriptSet( rSet, nAsian ); break; case SCRIPTTYPE_COMPLEX: pRet = GetItemOfScriptSet( rSet, nComplex ); break; case SCRIPTTYPE_LATIN|SCRIPTTYPE_ASIAN: if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) || 0 == (pAsn = GetItemOfScriptSet( rSet, nAsian )) || *pRet != *pAsn ) pRet = 0; break; break; case SCRIPTTYPE_LATIN|SCRIPTTYPE_COMPLEX: if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) || 0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) || *pRet != *pCmplx ) pRet = 0; break; case SCRIPTTYPE_ASIAN|SCRIPTTYPE_COMPLEX: if( 0 == (pRet = GetItemOfScriptSet( rSet, nAsian )) || 0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) || *pRet != *pCmplx ) pRet = 0; break; case SCRIPTTYPE_LATIN|SCRIPTTYPE_ASIAN|SCRIPTTYPE_COMPLEX: if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) || 0 == (pAsn = GetItemOfScriptSet( rSet, nAsian )) || 0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) || *pRet != *pAsn || *pRet != *pCmplx ) pRet = 0; break; } return pRet; } void SvxScriptSetItem::PutItemForScriptType( USHORT nScriptType, const SfxPoolItem& rItem ) { USHORT nLatin, nAsian, nComplex; GetWhichIds( nLatin, nAsian, nComplex ); SfxPoolItem* pCpy = rItem.Clone(); if( SCRIPTTYPE_LATIN & nScriptType ) { pCpy->SetWhich( nLatin ); GetItemSet().Put( *pCpy ); } if( SCRIPTTYPE_ASIAN & nScriptType ) { pCpy->SetWhich( nAsian ); GetItemSet().Put( *pCpy ); } if( SCRIPTTYPE_COMPLEX & nScriptType ) { pCpy->SetWhich( nComplex ); GetItemSet().Put( *pCpy ); } delete pCpy; } void SvxScriptSetItem::GetWhichIds( USHORT& rLatin, USHORT& rAsian, USHORT& rComplex ) const { const SfxItemPool& rPool = *GetItemSet().GetPool(); GetSlotIds( Which(), rLatin, rAsian, rComplex ); rLatin = rPool.GetWhich( rLatin ); rAsian = rPool.GetWhich( rAsian ); rComplex = rPool.GetWhich( rComplex ); } void SvxScriptSetItem::GetSlotIds( USHORT nSlotId, USHORT& rLatin, USHORT& rAsian, USHORT& rComplex ) { switch( nSlotId ) { default: DBG_ASSERT( FALSE, "wrong SlotId for class SvxScriptSetItem" ); // no break - default to font - Id Range !! case SID_ATTR_CHAR_FONT: rLatin = SID_ATTR_CHAR_FONT; rAsian = SID_ATTR_CHAR_CJK_FONT; rComplex = SID_ATTR_CHAR_CTL_FONT; break; case SID_ATTR_CHAR_FONTHEIGHT: rLatin = SID_ATTR_CHAR_FONTHEIGHT; rAsian = SID_ATTR_CHAR_CJK_FONTHEIGHT; rComplex = SID_ATTR_CHAR_CTL_FONTHEIGHT; break; case SID_ATTR_CHAR_WEIGHT: rLatin = SID_ATTR_CHAR_WEIGHT; rAsian = SID_ATTR_CHAR_CJK_WEIGHT; rComplex = SID_ATTR_CHAR_CTL_WEIGHT; break; case SID_ATTR_CHAR_POSTURE: rLatin = SID_ATTR_CHAR_POSTURE; rAsian = SID_ATTR_CHAR_CJK_POSTURE; rComplex = SID_ATTR_CHAR_CTL_POSTURE; break; case SID_ATTR_CHAR_LANGUAGE: rLatin = SID_ATTR_CHAR_LANGUAGE; rAsian = SID_ATTR_CHAR_CJK_LANGUAGE; rComplex = SID_ATTR_CHAR_CTL_LANGUAGE; break; } } void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex ) { const USHORT nItemCnt = 3; static struct { USHORT nFntType, nLanguage; } aOutTypeArr[ nItemCnt ] = { { DEFAULTFONT_LATIN_TEXT, LANGUAGE_ENGLISH_US }, { DEFAULTFONT_CJK_TEXT, LANGUAGE_ENGLISH_US }, { DEFAULTFONT_CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA } }; SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex }; for( USHORT n = 0; n < nItemCnt; ++n ) { Font aFnt( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFntType, aOutTypeArr[ n ].nLanguage, DEFAULTFONT_FLAGS_ONLYONE, 0 )); SvxFontItem* pI = aItemArr[ n ]; pI->GetFamily() = aFnt.GetFamily(); pI->GetFamilyName() = aFnt.GetName(); pI->GetStyleName().Erase(); pI->GetPitch() = aFnt.GetPitch(); pI->GetCharSet() = aFnt.GetCharSet(); } } // returns for a language the scripttype USHORT GetScriptTypeOfLanguage( USHORT nLang ) { if( LANGUAGE_DONTKNOW == nLang ) nLang = LANGUAGE_ENGLISH_US; else if( LANGUAGE_SYSTEM == nLang ) nLang = Application::GetSettings().GetLanguage(); USHORT nScript; switch( nLang ) { case LANGUAGE_CHINESE: case LANGUAGE_CHINESE_TRADITIONAL: case LANGUAGE_CHINESE_SIMPLIFIED: case LANGUAGE_CHINESE_HONGKONG: case LANGUAGE_CHINESE_SINGAPORE: case LANGUAGE_CHINESE_MACAU: case LANGUAGE_JAPANESE: case LANGUAGE_KOREAN: case LANGUAGE_KOREAN_JOHAB: nScript = SCRIPTTYPE_ASIAN; break; case LANGUAGE_ARABIC: case LANGUAGE_ARABIC_SAUDI_ARABIA: case LANGUAGE_ARABIC_IRAQ: case LANGUAGE_ARABIC_EGYPT: case LANGUAGE_ARABIC_LIBYA: case LANGUAGE_ARABIC_ALGERIA: case LANGUAGE_ARABIC_MOROCCO: case LANGUAGE_ARABIC_TUNISIA: case LANGUAGE_ARABIC_OMAN: case LANGUAGE_ARABIC_YEMEN: case LANGUAGE_ARABIC_SYRIA: case LANGUAGE_ARABIC_JORDAN: case LANGUAGE_ARABIC_LEBANON: case LANGUAGE_ARABIC_KUWAIT: case LANGUAGE_ARABIC_UAE: case LANGUAGE_ARABIC_BAHRAIN: case LANGUAGE_ARABIC_QATAR: case LANGUAGE_HEBREW: case LANGUAGE_URDU: case LANGUAGE_URDU_PAKISTAN: case LANGUAGE_URDU_INDIA: case LANGUAGE_THAI: case LANGUAGE_VIETNAMESE: nScript = SCRIPTTYPE_COMPLEX; break; // currently not knowing scripttype - defaultet to LATIN: /* #define LANGUAGE_AFRIKAANS 0x0436 #define LANGUAGE_ARMENIAN 0x042B #define LANGUAGE_ASSAMESE 0x044D #define LANGUAGE_AZERI 0x002C #define LANGUAGE_AZERI_LATIN 0x042C #define LANGUAGE_AZERI_CYRILLIC 0x082C #define LANGUAGE_BASQUE 0x042D #define LANGUAGE_BELARUSIAN 0x0423 #define LANGUAGE_BENGALI 0x0445 #define LANGUAGE_GUJARATI 0x0447 #define LANGUAGE_HINDI 0x0439 #define LANGUAGE_INDONESIAN 0x0421 #define LANGUAGE_KASHMIRI 0x0460 #define LANGUAGE_KASHMIRI_INDIA 0x0860 #define LANGUAGE_KAZAK 0x043F #define LANGUAGE_KONKANI 0x0457 #define LANGUAGE_LATVIAN 0x0426 #define LANGUAGE_LITHUANIAN 0x0427 #define LANGUAGE_LITHUANIAN_CLASSIC 0x0827 #define LANGUAGE_MACEDONIAN 0x042F #define LANGUAGE_MALAY 0x003E #define LANGUAGE_MALAY_MALAYSIA 0x043E #define LANGUAGE_MALAY_BRUNEI_DARUSSALAM 0x083E #define LANGUAGE_MALAYALAM 0x044C #define LANGUAGE_MANIPURI 0x0458 #define LANGUAGE_MARATHI 0x044E #define LANGUAGE_NEPALI 0x0461 #define LANGUAGE_NEPALI_INDIA 0x0861 #define LANGUAGE_ORIYA 0x0448 #define LANGUAGE_PUNJABI 0x0446 #define LANGUAGE_SANSKRIT 0x044F #define LANGUAGE_SERBIAN 0x041A #define LANGUAGE_SERBIAN_LATIN 0x081A #define LANGUAGE_SERBIAN_CYRILLIC 0x0C1A #define LANGUAGE_SINDHI 0x0459 #define LANGUAGE_SWAHILI 0x5041 #define LANGUAGE_TAMIL 0x0449 #define LANGUAGE_TATAR 0x0444 #define LANGUAGE_TELUGU 0x044A #define LANGUAGE_TURKISH 0x041F #define LANGUAGE_UKRAINIAN 0x0422 #define LANGUAGE_UZBEK 0x0043 #define LANGUAGE_UZBEK_LATIN 0x0443 #define LANGUAGE_UZBEK_CYRILLIC 0x0843 */ default: nScript = SCRIPTTYPE_LATIN; break; } return nScript; }