/**************************************************************
*
* 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 ---------------------------------------------------------------
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/awt/FontDescriptor.hpp>
#include <com/sun/star/frame/status/FontHeight.hpp>
#include <vcl/bitmapex.hxx>
#include <tools/stream.hxx>
#include <toolkit/unohlp.hxx>
#include <math.h>
#include <rtl/math.hxx>
#include <unotools/fontdefs.hxx>
#include <vcl/outdev.hxx>
#include <editeng/eeitem.hxx>
#include <svtools/unitconv.hxx>
#define GLOBALOVERFLOW3
#include <svl/memberid.hrc>
#include <editeng/editids.hrc>
#include <editeng/editrids.hrc>
#include <vcl/vclenum.hxx>
#include <tools/bigint.hxx>
#include <tools/tenccvt.hxx>
#include <rtl/ustring.hxx>
#include <i18npool/mslangid.hxx>
#include <svl/itemset.hxx>
#include <svtools/langtab.hxx>
#include <svl/itempool.hxx>
#include <svtools/ctrltool.hxx>
#include <vcl/settings.hxx>
#include <vcl/svapp.hxx>
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/awt/SimpleFontMetric.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/awt/CharSet.hpp>
#include <com/sun/star/awt/FontDescriptor.hpp>
#include <com/sun/star/awt/FontWidth.hpp>
#include <com/sun/star/awt/XFont.hpp>
#include <com/sun/star/awt/FontType.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontStrikeout.hpp>
#include <com/sun/star/awt/FontFamily.hpp>
#include <com/sun/star/awt/FontPitch.hpp>
#include <com/sun/star/lang/Locale.hpp>
#include <com/sun/star/text/FontEmphasis.hpp>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <editeng/memberids.hrc>
#include <editeng/flstitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/fwdtitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/crsditem.hxx>
#include <editeng/shdditem.hxx>
#include <editeng/akrnitem.hxx>
#include <editeng/wrlmitem.hxx>
#include <editeng/cntritem.hxx>
#include <editeng/prszitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/cscoitem.hxx>
#include <editeng/kernitem.hxx>
#include <editeng/cmapitem.hxx>
#include <editeng/escpitem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/nlbkitem.hxx>
#include <editeng/nhypitem.hxx>
#include <editeng/lcolitem.hxx>
#include <editeng/blnkitem.hxx>
#include <editeng/emphitem.hxx>
#include <editeng/twolinesitem.hxx>
#include <editeng/scripttypeitem.hxx>
#include <editeng/charrotateitem.hxx>
#include <editeng/charscaleitem.hxx>
#include <editeng/charreliefitem.hxx>
#include <editeng/itemtype.hxx>
#include <editeng/eerdll.hxx>
// #90477#
#include <tools/tenccvt.hxx>
#define STORE_UNICODE_MAGIC_MARKER 0xFE331188
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))
#define TWIP_TO_MM100_UNSIGNED(TWIP) ((((TWIP)*127L+36L)/72L))
#define MM100_TO_TWIP_UNSIGNED(MM100) ((((MM100)*72L+63L)/127L))
sal_Bool SvxFontItem::bEnableStoreUnicodeNames = sal_False;
// STATIC DATA -----------------------------------------------------------
// -----------------------------------------------------------------------
TYPEINIT1(SvxFontListItem, SfxPoolItem);
TYPEINIT1_FACTORY(SvxFontItem, SfxPoolItem, new SvxFontItem(0));
TYPEINIT1_FACTORY(SvxPostureItem, SfxEnumItem, new SvxPostureItem(ITALIC_NONE, 0));
TYPEINIT1_FACTORY(SvxWeightItem, SfxEnumItem, new SvxWeightItem(WEIGHT_NORMAL, 0));
TYPEINIT1_FACTORY(SvxFontHeightItem, SfxPoolItem, new SvxFontHeightItem(240, 100, 0));
TYPEINIT1_FACTORY(SvxFontWidthItem, SfxPoolItem, new SvxFontWidthItem(0, 100, 0));
TYPEINIT1_FACTORY(SvxTextLineItem, SfxEnumItem, new SvxTextLineItem(UNDERLINE_NONE, 0));
TYPEINIT1_FACTORY(SvxUnderlineItem, SfxEnumItem, new SvxUnderlineItem(UNDERLINE_NONE, 0));
TYPEINIT1_FACTORY(SvxOverlineItem, SfxEnumItem, new SvxOverlineItem(UNDERLINE_NONE, 0));
TYPEINIT1_FACTORY(SvxCrossedOutItem, SfxEnumItem, new SvxCrossedOutItem(STRIKEOUT_NONE, 0));
TYPEINIT1_FACTORY(SvxShadowedItem, SfxBoolItem, new SvxShadowedItem(sal_False, 0));
TYPEINIT1_FACTORY(SvxAutoKernItem, SfxBoolItem, new SvxAutoKernItem(sal_False, 0));
TYPEINIT1_FACTORY(SvxWordLineModeItem, SfxBoolItem, new SvxWordLineModeItem(sal_False, 0));
TYPEINIT1_FACTORY(SvxContourItem, SfxBoolItem, new SvxContourItem(sal_False, 0));
TYPEINIT1_FACTORY(SvxPropSizeItem, SfxUInt16Item, new SvxPropSizeItem(100, 0));
TYPEINIT1_FACTORY(SvxColorItem, SfxPoolItem, new SvxColorItem(0));
TYPEINIT1_FACTORY(SvxCharSetColorItem, SvxColorItem, new SvxCharSetColorItem(0));
TYPEINIT1_FACTORY(SvxKerningItem, SfxInt16Item, new SvxKerningItem(0, 0));
TYPEINIT1_FACTORY(SvxCaseMapItem, SfxEnumItem, new SvxCaseMapItem(SVX_CASEMAP_NOT_MAPPED, 0));
TYPEINIT1_FACTORY(SvxEscapementItem, SfxPoolItem, new SvxEscapementItem(0));
TYPEINIT1_FACTORY(SvxLanguageItem, SfxEnumItem, new SvxLanguageItem(LANGUAGE_GERMAN, 0));
TYPEINIT1_FACTORY(SvxNoLinebreakItem, SfxBoolItem, new SvxNoLinebreakItem(sal_True, 0));
TYPEINIT1_FACTORY(SvxNoHyphenItem, SfxBoolItem, new SvxNoHyphenItem(sal_True, 0));
TYPEINIT1_FACTORY(SvxLineColorItem, SvxColorItem, new SvxLineColorItem(0));
TYPEINIT1_FACTORY(SvxBlinkItem, SfxBoolItem, new SvxBlinkItem(sal_False, 0));
TYPEINIT1_FACTORY(SvxEmphasisMarkItem, SfxUInt16Item, new SvxEmphasisMarkItem(EMPHASISMARK_NONE, 0));
TYPEINIT1_FACTORY(SvxTwoLinesItem, SfxPoolItem, new SvxTwoLinesItem(sal_True, 0, 0, 0));
TYPEINIT1_FACTORY(SvxScriptTypeItem, SfxUInt16Item, new SvxScriptTypeItem);
TYPEINIT1_FACTORY(SvxCharRotateItem, SfxUInt16Item, new SvxCharRotateItem(0, sal_False, 0));
TYPEINIT1_FACTORY(SvxCharScaleWidthItem, SfxUInt16Item, new SvxCharScaleWidthItem(100, 0));
TYPEINIT1_FACTORY(SvxCharReliefItem, SfxEnumItem, new SvxCharReliefItem(RELIEF_NONE, 0));
TYPEINIT1(SvxScriptSetItem, SfxSetItem );
// class SvxFontListItem -------------------------------------------------
SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
const sal_uInt16 nId ) :
SfxPoolItem( nId ),
pFontList( pFontLst )
{
if ( pFontList )
{
sal_Int32 nCount = pFontList->GetFontNameCount();
aFontNameSeq.realloc( nCount );
for ( sal_uInt16 i = 0; i < nCount; i++ )
aFontNameSeq[i] = pFontList->GetFontName(i).GetName();
}
}
// -----------------------------------------------------------------------
SvxFontListItem::SvxFontListItem( const SvxFontListItem& rItem ) :
SfxPoolItem( rItem ),
pFontList( rItem.GetFontList() ),
aFontNameSeq( rItem.aFontNameSeq )
{
}
// -----------------------------------------------------------------------
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 );
}
sal_Bool SvxFontListItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
{
rVal <<= aFontNameSeq;
return sal_True;
}
//------------------------------------------------------------------------
SfxItemPresentation SvxFontListItem::GetPresentation
(
SfxItemPresentation /*ePres*/,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
rText.Erase();
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxFontItem -----------------------------------------------------
SvxFontItem::SvxFontItem( const sal_uInt16 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 sal_uInt16 nId ) :
SfxPoolItem( nId ),
aFamilyName(aName),
aStyleName(aStName)
{
eFamily = eFam;
ePitch = eFontPitch;
eTextEncoding = eFontTextEncoding;
}
// -----------------------------------------------------------------------
SvxFontItem& SvxFontItem::operator=(const SvxFontItem& rFont)
{
aFamilyName = rFont.GetFamilyName();
aStyleName = rFont.GetStyleName();
eFamily = rFont.GetFamily();
ePitch = rFont.GetPitch();
eTextEncoding = rFont.GetCharSet();
return *this;
}
// -----------------------------------------------------------------------
sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case 0:
{
com::sun::star::awt::FontDescriptor aFontDescriptor;
aFontDescriptor.Name = aFamilyName.GetBuffer();
aFontDescriptor.StyleName = aStyleName.GetBuffer();
aFontDescriptor.Family = (sal_Int16)(eFamily);
aFontDescriptor.CharSet = (sal_Int16)(eTextEncoding);
aFontDescriptor.Pitch = (sal_Int16)(ePitch);
rVal <<= aFontDescriptor;
}
break;
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, sal_uInt8 nMemberId)
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case 0:
{
com::sun::star::awt::FontDescriptor aFontDescriptor;
if ( !( rVal >>= aFontDescriptor ))
return sal_False;
aFamilyName = aFontDescriptor.Name;
aStyleName = aFontDescriptor.StyleName;
eFamily = (FontFamily)aFontDescriptor.Family;
eTextEncoding = (rtl_TextEncoding)aFontDescriptor.CharSet;
ePitch = (FontPitch)aFontDescriptor.Pitch;
}
break;
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 = sal_Int16();
if(!(rVal >>= nFamily))
return sal_False;
eFamily = (FontFamily)nFamily;
}
break;
case MID_FONT_CHAR_SET :
{
sal_Int16 nSet = sal_Int16();
if(!(rVal >>= nSet))
return sal_False;
eTextEncoding = (rtl_TextEncoding)nSet;
}
break;
case MID_FONT_PITCH :
{
sal_Int16 nPitch = sal_Int16();
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 , sal_uInt16 /*nItemVersion*/ ) const
{
sal_Bool bToBats =
GetFamilyName().EqualsAscii( "StarSymbol", 0, sizeof("StarSymbol")-1 ) ||
GetFamilyName().EqualsAscii( "OpenSymbol", 0, sizeof("OpenSymbol")-1 );
// #90477# rStrm << (sal_uInt8) GetFamily()
// << (sal_uInt8) GetPitch()
// << (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() ) );
rStrm << (sal_uInt8) GetFamily() << (sal_uInt8) GetPitch()
<< (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()));
String aStoreFamilyName( GetFamilyName() );
if( bToBats )
aStoreFamilyName = String( "StarBats", sizeof("StarBats")-1, RTL_TEXTENCODING_ASCII_US );
rStrm.WriteByteString(aStoreFamilyName);
rStrm.WriteByteString(GetStyleName());
// #96441# Kach for EditEngine, only set while creating clipboard stream.
if ( bEnableStoreUnicodeNames )
{
sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER;
rStrm << nMagic;
rStrm.WriteByteString( aStoreFamilyName, RTL_TEXTENCODING_UNICODE );
rStrm.WriteByteString( GetStyleName(), RTL_TEXTENCODING_UNICODE );
}
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 _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 = (sal_uInt8)GetSOLoadTextEncoding( eFontTextEncoding, (sal_uInt16)rStrm.GetVersion() );
// irgendwann wandelte sich der StarBats vom ANSI- zum SYMBOL-Font
if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName.EqualsAscii("StarBats") )
eFontTextEncoding = RTL_TEXTENCODING_SYMBOL;
// Check if we have stored unicode
sal_Size nStreamPos = rStrm.Tell();
sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER;
rStrm >> nMagic;
if ( nMagic == STORE_UNICODE_MAGIC_MARKER )
{
rStrm.ReadByteString( aName, RTL_TEXTENCODING_UNICODE );
rStrm.ReadByteString( aStyle, RTL_TEXTENCODING_UNICODE );
}
else
{
rStrm.Seek( nStreamPos );
}
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 * /*pIntl*/
) 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;
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
//------------------------------------------------------------------------
void SvxFontItem::EnableStoreUnicodeNames( sal_Bool bEnable )
{
bEnableStoreUnicodeNames = bEnable;
}
// class SvxPostureItem --------------------------------------------------
SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const sal_uInt16 nId ) :
SfxEnumItem( nId, (sal_uInt16)ePosture )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxPostureItem::Clone( SfxItemPool * ) const
{
return new SvxPostureItem( *this );
}
// -----------------------------------------------------------------------
sal_uInt16 SvxPostureItem::GetValueCount() const
{
return ITALIC_NORMAL + 1; // auch ITALIC_NONE geh"ort dazu
}
// -----------------------------------------------------------------------
SvStream& SvxPostureItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nPosture;
rStrm >> nPosture;
return new SvxPostureItem( (const FontItalic)nPosture, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxPostureItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ;//prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxPostureItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos <= (sal_uInt16)ITALIC_NORMAL, "enum overflow!" );
XubString sTxt;
FontItalic eItalic = (FontItalic)nPos;
sal_uInt16 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;
default: ;//prevent warning
}
if ( nId )
sTxt = EditResId( nId );
return sTxt;
}
/*-----------------13.03.98 14:28-------------------
--------------------------------------------------*/
sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch( nMemberId )
{
case MID_ITALIC:
SetBoolValue(Any2Bool(rVal));
break;
case MID_POSTURE:
{
awt::FontSlant eSlant;
if(!(rVal >>= eSlant))
{
sal_Int32 nValue = 0;
if(!(rVal >>= nValue))
return sal_False;
eSlant = (awt::FontSlant)nValue;
}
SetValue((sal_uInt16)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( (sal_uInt16)(bVal ? ITALIC_NORMAL : ITALIC_NONE) );
}
// class SvxWeightItem ---------------------------------------------------
SvxWeightItem::SvxWeightItem( const FontWeight eWght, const sal_uInt16 nId ) :
SfxEnumItem( nId, (sal_uInt16)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( (sal_uInt16)(bVal ? WEIGHT_BOLD : WEIGHT_NORMAL) );
}
// -----------------------------------------------------------------------
sal_uInt16 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 , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nWeight;
rStrm >> nWeight;
return new SvxWeightItem( (FontWeight)nWeight, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxWeightItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ;//prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxWeightItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos <= (sal_uInt16)WEIGHT_BLACK, "enum overflow!" );
return EE_RESSTR( RID_SVXITEMS_WEIGHT_BEGIN + nPos );
}
/*-----------------13.03.98 14:18-------------------
--------------------------------------------------*/
sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch( nMemberId )
{
case MID_BOLD :
SetBoolValue(Any2Bool(rVal));
break;
case MID_WEIGHT:
{
double fValue = 0;
if(!(rVal >>= fValue))
{
sal_Int32 nValue = 0;
if(!(rVal >>= nValue))
return sal_False;
fValue = (float)nValue;
}
SetValue( (sal_uInt16)VCLUnoHelper::ConvertFontWeight((float)fValue) );
}
break;
}
return sal_True;
}
// class SvxFontHeightItem -----------------------------------------------
SvxFontHeightItem::SvxFontHeightItem( const sal_uLong nSz,
const sal_uInt16 nPrp,
const sal_uInt16 nId ) :
SfxPoolItem( nId )
{
SetHeight( nSz,nPrp ); // mit den Prozenten rechnen
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxFontHeightItem::Clone( SfxItemPool * ) const
{
return new SvxFontHeightItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxFontHeightItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
{
rStrm << (sal_uInt16)GetHeight();
if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
rStrm << GetProp() << (sal_uInt16)GetPropUnit();
else
{
// JP 30.06.98: beim Export in alte Versionen geht die relative
// Angabe verloren, wenn es keine Prozentuale ist
sal_uInt16 _nProp = GetProp();
if( SFX_MAPUNIT_RELATIVE != GetPropUnit() )
_nProp = 100;
rStrm << _nProp;
}
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm,
sal_uInt16 nVersion ) const
{
sal_uInt16 nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE;
rStrm >> nsize;
if( FONTHEIGHT_16_VERSION <= nVersion )
rStrm >> nprop;
else
{
sal_uInt8 nP;
rStrm >> nP;
nprop = (sal_uInt16)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, sal_uInt8 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 0:
{
::com::sun::star::frame::status::FontHeight aFontHeight;
// Point (also Twips) sind gefragt,
// also umrechnen, wenn CONVERT_TWIPS nicht gesetzt ist
if( bConvert )
{
long nTwips = bConvert ? nHeight : MM100_TO_TWIP_UNSIGNED(nHeight);
aFontHeight.Height = (float)( nTwips / 20.0 );
}
else
{
double fPoints = MM100_TO_TWIP_UNSIGNED(nHeight) / 20.0;
float fRoundPoints =
static_cast<float>(::rtl::math::round(fPoints, 1));
aFontHeight.Height = fRoundPoints;
}
aFontHeight.Prop = (sal_Int16)(SFX_MAPUNIT_RELATIVE == ePropUnit ? nProp : 100);
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;
default: ;//prevent warning
}
aFontHeight.Diff = fRet;
rVal <<= aFontHeight;
}
break;
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_UNSIGNED(nHeight);
rVal <<= (float)( nTwips / 20.0 );
}
else
{
double fPoints = MM100_TO_TWIP_UNSIGNED(nHeight) / 20.0;
float fRoundPoints =
static_cast<float>(::rtl::math::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;
default: ;//prevent warning
}
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;
default: ;//prevent warning
}
nRet -= nDiff;
return nRet;
}
/*-----------------13.03.98 14:53-------------------
--------------------------------------------------*/
sal_Bool SvxFontHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch( nMemberId )
{
case 0:
{
::com::sun::star::frame::status::FontHeight aFontHeight;
if ( rVal >>= aFontHeight )
{
// Height
ePropUnit = SFX_MAPUNIT_RELATIVE;
nProp = 100;
double fPoint = aFontHeight.Height;
if( fPoint < 0. || fPoint > 10000. )
return sal_False;
nHeight = (long)( fPoint * 20.0 + 0.5 ); // Twips
if (!bConvert)
nHeight = TWIP_TO_MM100_UNSIGNED(nHeight); // umrechnen, wenn das Item 1/100mm enthaelt
nProp = aFontHeight.Prop;
}
else
return sal_False;
}
break;
case MID_FONTHEIGHT:
{
ePropUnit = SFX_MAPUNIT_RELATIVE;
nProp = 100;
double fPoint = 0;
if(!(rVal >>= fPoint))
{
sal_Int32 nValue = 0;
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_UNSIGNED(nHeight); // umrechnen, wenn das Item 1/100mm enthaelt
}
break;
case MID_FONTHEIGHT_PROP:
{
sal_Int16 nNew = sal_Int16();
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 = 0;
if(!(rVal >>= fValue))
{
sal_Int32 nValue = 0;
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 *pIntl
) 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 );
rText += sal_Unicode(' ');
rText += EE_RESSTR( GetMetricId( ePropUnit ) );
if( 0 <= (short)nProp )
rText.Insert( sal_Unicode('+'), 0 );
}
else if( 100 == nProp )
{
rText = GetMetricText( (long)nHeight,
eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
rText += sal_Unicode(' ');
rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
}
else
( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%');
return ePres;
}
default: ; //prevent warning
}
#endif
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
sal_uInt16 SvxFontHeightItem::GetVersion(sal_uInt16 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 sal_uInt16 nNewProp,
SfxMapUnit eUnit )
{
DBG_ASSERT( GetRefCount() == 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, sal_uInt16 nNewProp,
SfxMapUnit eMetric, SfxMapUnit eCoreMetric )
{
DBG_ASSERT( GetRefCount() == 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 sal_uInt16 nSz, const sal_uInt16 nPrp, const sal_uInt16 nId ) :
SfxPoolItem( nId )
{
nWidth = nSz;
nProp = nPrp;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxFontWidthItem::Clone( SfxItemPool * ) const
{
return new SvxFontWidthItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxFontWidthItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << GetWidth() << GetProp();
return rStrm;
}
// -----------------------------------------------------------------------
int SvxFontWidthItem::ScaleMetrics( long nMult, long nDiv )
{
nWidth = (sal_uInt16)Scale( nWidth, nMult, nDiv );
return 1;
}
// -----------------------------------------------------------------------
int SvxFontWidthItem::HasMetrics() const
{
return 1;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxFontWidthItem::Create( SvStream& rStrm,
sal_uInt16 /*nVersion*/ ) const
{
sal_uInt16 nS;
sal_uInt16 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, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Int16 nVal = sal_Int16();
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 *pIntl
) 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, pIntl );
rText += sal_Unicode(' ');
rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
}
else
( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%');
return ePres;
}
default: ; //prevent warning
}
#endif
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxTextLineItem ------------------------------------------------
SvxTextLineItem::SvxTextLineItem( const FontUnderline eSt, const sal_uInt16 nId )
: SfxEnumItem( nId, (sal_uInt16)eSt ), mColor( COL_TRANSPARENT )
{
}
// -----------------------------------------------------------------------
int SvxTextLineItem::HasBoolValue() const
{
return sal_True;
}
// -----------------------------------------------------------------------
sal_Bool SvxTextLineItem::GetBoolValue() const
{
return (FontUnderline)GetValue() != UNDERLINE_NONE;
}
// -----------------------------------------------------------------------
void SvxTextLineItem::SetBoolValue( sal_Bool bVal )
{
SetValue( (sal_uInt16)(bVal ? UNDERLINE_SINGLE : UNDERLINE_NONE) );
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxTextLineItem::Clone( SfxItemPool * ) const
{
SvxTextLineItem* pNew = new SvxTextLineItem( *this );
pNew->SetColor( GetColor() );
return pNew;
}
// -----------------------------------------------------------------------
sal_uInt16 SvxTextLineItem::GetValueCount() const
{
return UNDERLINE_DOTTED + 1; // auch UNDERLINE_NONE geh"ort dazu
}
// -----------------------------------------------------------------------
SvStream& SvxTextLineItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxTextLineItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxTextLineItem( (FontUnderline)nState, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxTextLineItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ; //prevent warning
}
#endif
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxTextLineItem::GetValueTextByPos( sal_uInt16 /*nPos*/ ) const
{
DBG_ERROR("SvxTextLineItem::GetValueTextByPos: Pure virtual method");
return XubString();
}
/*-----------------13.03.98 16:25-------------------
--------------------------------------------------*/
sal_Bool SvxTextLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_TEXTLINED:
rVal = Bool2Any(GetBoolValue());
break;
case MID_TL_STYLE:
rVal <<= (sal_Int16)(GetValue());
break;
case MID_TL_COLOR:
rVal <<= (sal_Int32)( mColor.GetColor() );
break;
case MID_TL_HASCOLOR:
rVal = Bool2Any( !mColor.GetTransparency() );
break;
}
return sal_True;
}
/*-----------------13.03.98 16:28-------------------
--------------------------------------------------*/
sal_Bool SvxTextLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch(nMemberId)
{
case MID_TEXTLINED:
SetBoolValue(Any2Bool(rVal));
break;
case MID_TL_STYLE:
{
sal_Int32 nValue = 0;
if(!(rVal >>= nValue))
bRet = sal_False;
else
SetValue((sal_Int16)nValue);
}
break;
case MID_TL_COLOR:
{
sal_Int32 nCol = 0;
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_TL_HASCOLOR:
mColor.SetTransparency( Any2Bool( rVal ) ? 0 : 0xff );
break;
}
return bRet;
}
int SvxTextLineItem::operator==( const SfxPoolItem& rItem ) const
{
DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
return SfxEnumItem::operator==( rItem ) &&
GetColor() == ((SvxTextLineItem&)rItem).GetColor();
}
// class SvxUnderlineItem ------------------------------------------------
SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const sal_uInt16 nId )
: SvxTextLineItem( eSt, nId )
{
}
//------------------------------------------------------------------------
SfxPoolItem* SvxUnderlineItem::Clone( SfxItemPool * ) const
{
SvxUnderlineItem* pNew = new SvxUnderlineItem( *this );
pNew->SetColor( GetColor() );
return pNew;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxUnderlineItem( (FontUnderline)nState, Which() );
}
// -----------------------------------------------------------------------
XubString SvxUnderlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
return EE_RESSTR( RID_SVXITEMS_UL_BEGIN + nPos );
}
// class SvxOverlineItem ------------------------------------------------
SvxOverlineItem::SvxOverlineItem( const FontUnderline eSt, const sal_uInt16 nId )
: SvxTextLineItem( eSt, nId )
{
}
//------------------------------------------------------------------------
SfxPoolItem* SvxOverlineItem::Clone( SfxItemPool * ) const
{
SvxOverlineItem* pNew = new SvxOverlineItem( *this );
pNew->SetColor( GetColor() );
return pNew;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxOverlineItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxOverlineItem( (FontUnderline)nState, Which() );
}
// -----------------------------------------------------------------------
XubString SvxOverlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
return EE_RESSTR( RID_SVXITEMS_OL_BEGIN + nPos );
}
// class SvxCrossedOutItem -----------------------------------------------
SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const sal_uInt16 nId )
: SfxEnumItem( nId, (sal_uInt16)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( (sal_uInt16)(bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE) );
}
// -----------------------------------------------------------------------
sal_uInt16 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 , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 eCross;
rStrm >> eCross;
return new SvxCrossedOutItem( (FontStrikeout)eCross, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxCrossedOutItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ;//prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxCrossedOutItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos <= (sal_uInt16)STRIKEOUT_X, "enum overflow!" );
return EE_RESSTR( RID_SVXITEMS_STRIKEOUT_BEGIN + nPos );
}
/*-----------------13.03.98 16:28-------------------
--------------------------------------------------*/
sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_CROSSED_OUT:
SetBoolValue(Any2Bool(rVal));
break;
case MID_CROSS_OUT:
{
sal_Int32 nValue = 0;
if(!(rVal >>= nValue))
return sal_False;
SetValue((sal_Int16)nValue);
}
break;
}
return sal_True;
}
// class SvxShadowedItem -------------------------------------------------
SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const sal_uInt16 nId ) :
SfxBoolItem( nId, bShadowed )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxShadowedItem::Clone( SfxItemPool * ) const
{
return new SvxShadowedItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxShadowedItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxShadowedItem( nState, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxShadowedItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
switch ( ePres )
{
case SFX_ITEM_PRESENTATION_NONE:
rText.Erase();
return ePres;
case SFX_ITEM_PRESENTATION_NAMELESS:
case SFX_ITEM_PRESENTATION_COMPLETE:
{
sal_uInt16 nId = RID_SVXITEMS_SHADOWED_FALSE;
if ( GetValue() )
nId = RID_SVXITEMS_SHADOWED_TRUE;
rText = EE_RESSTR(nId);
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxAutoKernItem -------------------------------------------------
SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const sal_uInt16 nId ) :
SfxBoolItem( nId, bAutoKern )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxAutoKernItem::Clone( SfxItemPool * ) const
{
return new SvxAutoKernItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxAutoKernItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxAutoKernItem( nState, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxAutoKernItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
switch ( ePres )
{
case SFX_ITEM_PRESENTATION_NONE:
rText.Erase();
return ePres;
case SFX_ITEM_PRESENTATION_NAMELESS:
case SFX_ITEM_PRESENTATION_COMPLETE:
{
sal_uInt16 nId = RID_SVXITEMS_AUTOKERN_FALSE;
if ( GetValue() )
nId = RID_SVXITEMS_AUTOKERN_TRUE;
rText = EE_RESSTR(nId);
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxWordLineModeItem ---------------------------------------------
SvxWordLineModeItem::SvxWordLineModeItem( const sal_Bool bWordLineMode,
const sal_uInt16 nId ) :
SfxBoolItem( nId, bWordLineMode )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const
{
return new SvxWordLineModeItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_Bool) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_Bool bValue;
rStrm >> bValue;
return new SvxWordLineModeItem( bValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxWordLineModeItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
switch ( ePres )
{
case SFX_ITEM_PRESENTATION_NONE:
rText.Erase();
return ePres;
case SFX_ITEM_PRESENTATION_NAMELESS:
case SFX_ITEM_PRESENTATION_COMPLETE:
{
sal_uInt16 nId = RID_SVXITEMS_WORDLINE_FALSE;
if ( GetValue() )
nId = RID_SVXITEMS_WORDLINE_TRUE;
rText = EE_RESSTR(nId);
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxContourItem --------------------------------------------------
SvxContourItem::SvxContourItem( const sal_Bool bContoured, const sal_uInt16 nId ) :
SfxBoolItem( nId, bContoured )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxContourItem::Clone( SfxItemPool * ) const
{
return new SvxContourItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxContourItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_Bool) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_Bool bValue;
rStrm >> bValue;
return new SvxContourItem( bValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxContourItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
switch ( ePres )
{
case SFX_ITEM_PRESENTATION_NONE:
rText.Erase();
return ePres;
case SFX_ITEM_PRESENTATION_NAMELESS:
case SFX_ITEM_PRESENTATION_COMPLETE:
{
sal_uInt16 nId = RID_SVXITEMS_CONTOUR_FALSE;
if ( GetValue() )
nId = RID_SVXITEMS_CONTOUR_TRUE;
rText = EE_RESSTR(nId);
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxPropSizeItem -------------------------------------------------
SvxPropSizeItem::SvxPropSizeItem( const sal_uInt16 nPercent, const sal_uInt16 nId ) :
SfxUInt16Item( nId, nPercent )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxPropSizeItem::Clone( SfxItemPool * ) const
{
return new SvxPropSizeItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxPropSizeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt16) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt16 nSize;
rStrm >> nSize;
return new SvxPropSizeItem( nSize, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxPropSizeItem::GetPresentation
(
SfxItemPresentation /*ePres*/,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
rText.Erase();
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxColorItem ----------------------------------------------------
SvxColorItem::SvxColorItem( const sal_uInt16 nId ) :
SfxPoolItem( nId ),
mColor( COL_BLACK )
{
}
// -----------------------------------------------------------------------
SvxColorItem::SvxColorItem( const Color& rCol, const sal_uInt16 nId ) :
SfxPoolItem( nId ),
mColor( rCol )
{
}
// -----------------------------------------------------------------------
SvxColorItem::SvxColorItem( SvStream &rStrm, const sal_uInt16 nId ) :
SfxPoolItem( nId )
{
Color aColor;
rStrm >> aColor;
mColor = aColor;
}
// -----------------------------------------------------------------------
SvxColorItem::SvxColorItem( const SvxColorItem &rCopy ) :
SfxPoolItem( rCopy ),
mColor( rCopy.mColor )
{
}
// -----------------------------------------------------------------------
SvxColorItem::~SvxColorItem()
{
}
// -----------------------------------------------------------------------
sal_uInt16 SvxColorItem::GetVersion( sal_uInt16 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, sal_uInt8 /*nMemberId*/ ) const
{
rVal <<= (sal_Int32)(mColor.GetColor());
return sal_True;
}
// -----------------------------------------------------------------------
sal_Bool SvxColorItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
{
sal_Int32 nColor = 0;
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 , sal_uInt16 nItemVersion ) const
{
if( VERSION_USEAUTOCOLOR == nItemVersion &&
COL_AUTO == mColor.GetColor() )
rStrm << Color( COL_BLACK );
else
rStrm << mColor;
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, sal_uInt16 /*nVer*/ ) const
{
return new SvxColorItem( rStrm, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxColorItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ; //prevent warning
}
#endif
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
void SvxColorItem::SetValue( const Color& rNewCol )
{
mColor = rNewCol;
}
// class SvxCharSetColorItem ---------------------------------------------
SvxCharSetColorItem::SvxCharSetColorItem( const sal_uInt16 nId ) :
SvxColorItem( nId ),
eFrom( RTL_TEXTENCODING_DONTKNOW )
{
}
// -----------------------------------------------------------------------
SvxCharSetColorItem::SvxCharSetColorItem( const Color& rCol,
const rtl_TextEncoding _eFrom,
const sal_uInt16 nId ) :
SvxColorItem( rCol, nId ),
eFrom( _eFrom )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxCharSetColorItem::Clone( SfxItemPool * ) const
{
return new SvxCharSetColorItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
// #90477# rStrm << (sal_uInt8) GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() )
// << GetValue();
rStrm << (sal_uInt8)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())
<< GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 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 * /*pIntl*/
) const
{
rText.Erase();
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxKerningItem --------------------------------------------------
SvxKerningItem::SvxKerningItem( const short nKern, const sal_uInt16 nId ) :
SfxInt16Item( nId, nKern )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxKerningItem::Clone( SfxItemPool * ) const
{
return new SvxKerningItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxKerningItem::Store( SvStream& rStrm , sal_uInt16 /*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, sal_uInt16) const
{
short nValue;
rStrm >> nValue;
return new SvxKerningItem( nValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxKerningItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit eCoreUnit,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper *pIntl
) 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, SFX_MAPUNIT_POINT, pIntl );
rText += sal_Unicode(' ');
rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
return ePres;
case SFX_ITEM_PRESENTATION_COMPLETE:
{
rText = EE_RESSTR(RID_SVXITEMS_KERNING_COMPLETE);
sal_uInt16 nId = 0;
if ( GetValue() > 0 )
nId = RID_SVXITEMS_KERNING_EXPANDED;
else if ( GetValue() < 0 )
nId = RID_SVXITEMS_KERNING_CONDENSED;
if ( nId )
rText += EE_RESSTR(nId);
rText += GetMetricText( (long)GetValue(), eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
rText += sal_Unicode(' ');
rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
return ePres;
}
default: ; //prevent warning
}
#endif
return SFX_ITEM_PRESENTATION_NONE;
}
/* -----------------------------19.02.01 12:21--------------------------------
---------------------------------------------------------------------------*/
sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, sal_uInt8 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, sal_uInt8 nMemberId)
{
sal_Int16 nVal = sal_Int16();
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 sal_uInt16 nId ) :
SfxEnumItem( nId, (sal_uInt16)eMap )
{
}
// -----------------------------------------------------------------------
sal_uInt16 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 , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 cMap;
rStrm >> cMap;
return new SvxCaseMapItem( (const SvxCaseMap)cMap, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxCaseMapItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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;
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxCaseMapItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos < (sal_uInt16)SVX_CASEMAP_END, "enum overflow!" );
return EE_RESSTR( RID_SVXITEMS_CASEMAP_BEGIN + nPos );
}
/*-----------------13.03.98 16:29-------------------
--------------------------------------------------*/
sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, sal_uInt8 /*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, sal_uInt8 /*nMemberId*/ )
{
sal_uInt16 nVal = sal_uInt16();
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 sal_uInt16 nId ) :
SfxEnumItemInterface( nId ),
nEsc ( 0 ),
nProp ( 100 )
{
}
// -----------------------------------------------------------------------
SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
const sal_uInt16 nId ) :
SfxEnumItemInterface( nId ),
nProp( 100 )
{
SetEscapement( eEscape );
if( nEsc )
nProp = 58;
}
// -----------------------------------------------------------------------
SvxEscapementItem::SvxEscapementItem( const short _nEsc,
const sal_uInt8 _nProp,
const sal_uInt16 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 , sal_uInt16 /*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 << (sal_uInt8) GetProp()
<< (short) _nEsc;
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 _nProp;
short _nEsc;
rStrm >> _nProp >> _nEsc;
return new SvxEscapementItem( _nEsc, _nProp, Which() );
}
// -----------------------------------------------------------------------
sal_uInt16 SvxEscapementItem::GetValueCount() const
{
return SVX_ESCAPEMENT_END; // SVX_ESCAPEMENT_SUBSCRIPT + 1
}
//------------------------------------------------------------------------
SfxItemPresentation SvxEscapementItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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( EE_RESSTR(RID_SVXITEMS_ESCAPEMENT_AUTO) );
else
( rText += String::CreateFromInt32( nEsc )) += sal_Unicode('%');
}
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
XubString SvxEscapementItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( nPos < (sal_uInt16)SVX_ESCAPEMENT_END, "enum overflow!" );
return EE_RESSTR(RID_SVXITEMS_ESCAPEMENT_BEGIN + nPos);
}
// -----------------------------------------------------------------------
sal_uInt16 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( sal_uInt16 nVal )
{
SetEscapement( (const SvxEscapement)nVal );
}
/*-----------------13.03.98 17:05-------------------
--------------------------------------------------*/
sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_ESC:
{
sal_Int16 nVal = sal_Int16();
if( (rVal >>= nVal) && (Abs(nVal) <= 101))
nEsc = nVal;
else
return sal_False;
}
break;
case MID_ESC_HEIGHT:
{
sal_Int8 nVal = sal_Int8();
if( (rVal >>= nVal) && (nVal <= 100))
nProp = nVal;
else
return sal_False;
}
break;
case MID_AUTO_ESC:
{
sal_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 sal_uInt16 nId )
: SfxEnumItem( nId , eLang )
{
}
// -----------------------------------------------------------------------
sal_uInt16 SvxLanguageItem::GetValueCount() const
{
// #i50205# got rid of class International
DBG_ERRORFILE("SvxLanguageItem::GetValueCount: supposed to return a count of what?");
// FIXME: previously returned LANGUAGE_COUNT from tools/intn.hxx which was wrong anyway.
// Could be SvtLanguageTable::GetEntryCount() (all locales with resource string)?
// Could be LocaleDataWrapper::getInstalledLanguageTypes() (all locales with locale data)?
return 0;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxLanguageItem::Clone( SfxItemPool * ) const
{
return new SvxLanguageItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxLanguageItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt16) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt16 nValue;
rStrm >> nValue;
return new SvxLanguageItem( (LanguageType)nValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxLanguageItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) 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:
{
SvtLanguageTable aLangTable;
rText = aLangTable.GetString( (LanguageType)GetValue() );
return ePres;
}
default: ; //prevent warning
}
#endif // !SVX_LIGHT
return SFX_ITEM_PRESENTATION_NONE;
}
/*-----------------14.03.98 14:13-------------------
--------------------------------------------------*/
sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_LANG_INT: // for basic conversions!
rVal <<= (sal_Int16)(GetValue());
break;
case MID_LANG_LOCALE:
lang::Locale aRet( MsLangId::convertLanguageToLocale( GetValue(), false));
rVal <<= aRet;
break;
}
return sal_True;
}
/*-----------------14.03.98 14:13-------------------
--------------------------------------------------*/
sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_LANG_INT: // for basic conversions!
{
sal_Int32 nValue = 0;
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(MsLangId::convertLocaleToLanguage( aLocale ));
else
SetValue(LANGUAGE_NONE);
}
break;
}
return sal_True;
}
// class SvxNoLinebreakItem ----------------------------------------------
SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const sal_uInt16 nId ) :
SfxBoolItem( nId, bBreak )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxNoLinebreakItem::Clone( SfxItemPool* ) const
{
return new SvxNoLinebreakItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_Bool)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxNoLinebreakItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_Bool bValue;
rStrm >> bValue;
return new SvxNoLinebreakItem( bValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxNoLinebreakItem::GetPresentation
(
SfxItemPresentation /*ePres*/,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
rText.Erase();
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxNoHyphenItem -------------------------------------------------
SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const sal_uInt16 nId ) :
SfxBoolItem( nId , bHyphen )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const
{
return new SvxNoHyphenItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_Bool) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxNoHyphenItem::Create( SvStream& rStrm, sal_uInt16 ) const
{
sal_Bool bValue;
rStrm >> bValue;
return new SvxNoHyphenItem( bValue, Which() );
}
//------------------------------------------------------------------------
SfxItemPresentation SvxNoHyphenItem::GetPresentation
(
SfxItemPresentation /*ePres*/,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
rText.Erase();
return SFX_ITEM_PRESENTATION_NONE;
}
/*
* Dummy-Item fuer ToolBox-Controls:
*
*/
// -----------------------------------------------------------------------
// class SvxLineColorItem (== SvxColorItem)
// -----------------------------------------------------------------------
SvxLineColorItem::SvxLineColorItem( const sal_uInt16 nId ) :
SvxColorItem( nId )
{
}
// -----------------------------------------------------------------------
SvxLineColorItem::SvxLineColorItem( const Color& rCol, const sal_uInt16 nId ) :
SvxColorItem( rCol, nId )
{
}
// -----------------------------------------------------------------------
SvxLineColorItem::SvxLineColorItem( SvStream &rStrm, const sal_uInt16 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 sal_uInt16 nId ) :
SfxBoolItem( nId, bBlink )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxBlinkItem::Clone( SfxItemPool * ) const
{
return new SvxBlinkItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxBlinkItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt8) GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, sal_uInt16) const
{
sal_uInt8 nState;
rStrm >> nState;
return new SvxBlinkItem( nState, Which() );
}
// -----------------------------------------------------------------------
SfxItemPresentation SvxBlinkItem::GetPresentation
(
SfxItemPresentation ePres,
SfxMapUnit /*eCoreUnit*/,
SfxMapUnit /*ePresUnit*/,
XubString& rText, const IntlWrapper * /*pIntl*/
) const
{
switch ( ePres )
{
case SFX_ITEM_PRESENTATION_NONE:
rText.Erase();
return ePres;
case SFX_ITEM_PRESENTATION_NAMELESS:
case SFX_ITEM_PRESENTATION_COMPLETE:
{
sal_uInt16 nId = RID_SVXITEMS_BLINK_FALSE;
if ( GetValue() )
nId = RID_SVXITEMS_BLINK_TRUE;
rText = EE_RESSTR(nId);
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// class SvxEmphaisMarkItem ---------------------------------------------------
SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue,
const sal_uInt16 nId )
: SfxUInt16Item( nId, nValue )
{
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const
{
return new SvxEmphasisMarkItem( *this );
}
// -----------------------------------------------------------------------
SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm,
sal_uInt16 /*nItemVersion*/ ) const
{
rStrm << (sal_uInt16)GetValue();
return rStrm;
}
// -----------------------------------------------------------------------
SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, sal_uInt16 ) 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 * /*pIntl*/
) 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 = EE_RESSTR( RID_SVXITEMS_EMPHASIS_BEGIN_STYLE +
( EMPHASISMARK_STYLE & nVal ));
sal_uInt16 nId = ( EMPHASISMARK_POS_ABOVE & nVal )
? RID_SVXITEMS_EMPHASIS_ABOVE_POS
: ( EMPHASISMARK_POS_BELOW & nVal )
? RID_SVXITEMS_EMPHASIS_BELOW_POS
: 0;
if( nId )
rText += EE_RESSTR( nId );
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
// -----------------------------------------------------------------------
sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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, sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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;
}
sal_uInt16 SvxEmphasisMarkItem::GetVersion( sal_uInt16 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 ),
cStartBracket( nStartBracket ), cEndBracket( nEndBracket ), bOn( bFlag )
{
}
SvxTwoLinesItem::SvxTwoLinesItem( const SvxTwoLinesItem& rAttr )
: SfxPoolItem( rAttr.Which() ),
cStartBracket( rAttr.cStartBracket ),
cEndBracket( rAttr.cEndBracket ),
bOn( rAttr.bOn )
{
}
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,
sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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,
sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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 = EE_RESSTR( RID_SVXITEMS_TWOLINES_OFF );
else
{
rText = EE_RESSTR( RID_SVXITEMS_TWOLINES );
if( GetStartBracket() )
rText.Insert( GetStartBracket(), 0 );
if( GetEndBracket() )
rText += GetEndBracket();
}
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, sal_uInt16 /*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, sal_uInt16 /*nIVer*/) const
{
rStrm << GetValue() << GetStartBracket() << GetEndBracket();
return rStrm;
}
sal_uInt16 SvxTwoLinesItem::GetVersion( sal_uInt16 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, sal_uInt16 ) const
{
sal_uInt16 nVal;
sal_Bool b;
rStrm >> nVal >> b;
return new SvxCharRotateItem( nVal, b, Which() );
}
SvStream& SvxCharRotateItem::Store( SvStream & rStrm, sal_uInt16 ) const
{
sal_Bool bFlag = IsFitToLine();
rStrm << GetValue() << bFlag;
return rStrm;
}
sal_uInt16 SvxCharRotateItem::GetVersion( sal_uInt16 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 = EE_RESSTR( RID_SVXITEMS_CHARROTATE_OFF );
else
{
rText = EE_RESSTR( RID_SVXITEMS_CHARROTATE );
rText.SearchAndReplaceAscii( "$(ARG1)",
String::CreateFromInt32( GetValue() / 10 ));
if( IsFitToLine() )
rText += EE_RESSTR( RID_SVXITEMS_CHARROTATE_FITLINE );
}
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
sal_Bool SvxCharRotateItem::QueryValue( com::sun::star::uno::Any& rVal,
sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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,
sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch( nMemberId )
{
case MID_ROTATE:
{
sal_Int16 nVal = 0;
if((rVal >>= nVal) && (0 == nVal || 900 == nVal || 2700 == nVal))
SetValue( (sal_uInt16)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, sal_uInt16 ) const
{
sal_uInt16 nVal;
rStrm >> nVal;
SvxCharScaleWidthItem* pItem = new SvxCharScaleWidthItem( nVal, Which() );
if ( Which() == EE_CHAR_FONTWIDTH )
{
// #87271#: Was a SvxFontWidthItem in 5.2
// sal_uInt16 nFixWidth, sal_uInt16 nPropWidth.
// nFixWidth has never been used...
rStrm >> nVal;
sal_uInt16 nTest;
rStrm >> nTest;
if ( nTest == 0x1234 )
pItem->SetValue( nVal );
else
rStrm.SeekRel( -2*(long)sizeof(sal_uInt16) );
}
return pItem;
}
SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, sal_uInt16 nVer ) const
{
SvStream& rRet = SfxUInt16Item::Store( rStream, nVer );
if ( Which() == EE_CHAR_FONTWIDTH )
{
// see comment in Create()....
rRet.SeekRel( -1*(long)sizeof(sal_uInt16) );
rRet << (sal_uInt16)0;
rRet << GetValue();
// Really ugly, but not a problem for reading the doc in 5.2
rRet << (sal_uInt16)0x1234;
}
return rRet;
}
sal_uInt16 SvxCharScaleWidthItem::GetVersion( sal_uInt16 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 = EE_RESSTR( RID_SVXITEMS_CHARSCALE_OFF );
else
{
rText = EE_RESSTR( RID_SVXITEMS_CHARSCALE );
rText.SearchAndReplaceAscii( "$(ARG1)",
String::CreateFromInt32( GetValue() ));
}
return ePres;
}
default: ; //prevent warning
}
return SFX_ITEM_PRESENTATION_NONE;
}
sal_Bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
{
// SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
// where we still want this to be a sal_Int16
sal_Int16 nValue = sal_Int16();
if (rVal >>= nValue)
{
SetValue( (sal_uInt16) nValue );
return sal_True;
}
DBG_ERROR( "SvxCharScaleWidthItem::PutValue - Wrong type!" );
return sal_False;
}
sal_Bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
{
// SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
// where we still want this to be a sal_Int16
rVal <<= (sal_Int16)GetValue();
return sal_True;
}
/*************************************************************************
|* class SvxCharReliefItem
*************************************************************************/
SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue,
const sal_uInt16 nId )
: SfxEnumItem( nId, (sal_uInt16)eValue )
{
}
SfxPoolItem* SvxCharReliefItem::Clone( SfxItemPool * ) const
{
return new SvxCharReliefItem( *this );
}
SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, sal_uInt16) const
{
sal_uInt16 nVal;
rStrm >> nVal;
return new SvxCharReliefItem( (FontRelief)nVal, Which() );
}
SvStream& SvxCharReliefItem::Store(SvStream & rStrm, sal_uInt16 /*nIVer*/) const
{
sal_uInt16 nVal = GetValue();
rStrm << nVal;
return rStrm;
}
sal_uInt16 SvxCharReliefItem::GetVersion( sal_uInt16 nFFVer ) const
{
return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
}
String SvxCharReliefItem::GetValueTextByPos( sal_uInt16 nPos ) const
{
DBG_ASSERT( RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE,
"enum overflow" );
return String( EditResId( RID_SVXITEMS_RELIEF_BEGIN + nPos ));
}
sal_uInt16 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 * /*pIntl*/
) 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,
sal_uInt8 nMemberId )
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch( nMemberId )
{
case MID_RELIEF:
{
sal_Int16 nVal = -1;
rVal >>= nVal;
if(nVal >= 0 && nVal <= RELIEF_ENGRAVED)
SetValue( (sal_uInt16)nVal );
else
bRet = sal_False;
}
break;
default:
bRet = sal_False;
break;
}
return bRet;
}
sal_Bool SvxCharReliefItem::QueryValue( com::sun::star::uno::Any& rVal,
sal_uInt8 nMemberId ) const
{
// sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
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 * ) const
{
return new SvxScriptTypeItem( GetValue() );
}
/*************************************************************************
|* class SvxScriptSetItem
*************************************************************************/
SvxScriptSetItem::SvxScriptSetItem( sal_uInt16 nSlotId, SfxItemPool& rPool )
: SfxSetItem( nSlotId, new SfxItemSet( rPool,
SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONT ))
{
sal_uInt16 nLatin, nAsian, nComplex;
GetWhichIds( nLatin, nAsian, nComplex );
sal_uInt16 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 * ) const
{
SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() );
p->GetItemSet().Put( GetItemSet(), sal_False );
return p;
}
SfxPoolItem* SvxScriptSetItem::Create( SvStream &, sal_uInt16 ) const
{
return 0;
}
const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet(
const SfxItemSet& rSet, sal_uInt16 nId )
{
const SfxPoolItem* pI;
SfxItemState eSt = rSet.GetItemState( nId, sal_False, &pI );
if( SFX_ITEM_SET != eSt )
pI = SFX_ITEM_DEFAULT == eSt ? &rSet.Get( nId ) : 0;
return pI;
}
const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16 nScript )
{
sal_uInt16 nLatin, nAsian, nComplex;
GetWhichIds( nSlotId, rSet, nLatin, nAsian, nComplex );
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;
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;
}
const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nScript ) const
{
return GetItemOfScript( Which(), GetItemSet(), nScript );
}
void SvxScriptSetItem::PutItemForScriptType( sal_uInt16 nScriptType,
const SfxPoolItem& rItem )
{
sal_uInt16 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( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16& rLatin, sal_uInt16& rAsian, sal_uInt16& rComplex )
{
const SfxItemPool& rPool = *rSet.GetPool();
GetSlotIds( nSlotId, rLatin, rAsian, rComplex );
rLatin = rPool.GetWhich( rLatin );
rAsian = rPool.GetWhich( rAsian );
rComplex = rPool.GetWhich( rComplex );
}
void SvxScriptSetItem::GetWhichIds( sal_uInt16& rLatin, sal_uInt16& rAsian,
sal_uInt16& rComplex ) const
{
GetWhichIds( Which(), GetItemSet(), rLatin, rAsian, rComplex );
}
void SvxScriptSetItem::GetSlotIds( sal_uInt16 nSlotId, sal_uInt16& rLatin,
sal_uInt16& rAsian, sal_uInt16& rComplex )
{
switch( nSlotId )
{
default:
DBG_ASSERT( sal_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;
case SID_ATTR_CHAR_SHADOWED:
rLatin = SID_ATTR_CHAR_SHADOWED;
rAsian = SID_ATTR_CHAR_SHADOWED;
rComplex = SID_ATTR_CHAR_SHADOWED;
break;
case SID_ATTR_CHAR_STRIKEOUT:
rLatin = SID_ATTR_CHAR_STRIKEOUT;
rAsian = SID_ATTR_CHAR_STRIKEOUT;
rComplex = SID_ATTR_CHAR_STRIKEOUT;
break;
}
}
void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex )
{
const sal_uInt16 nItemCnt = 3;
static struct
{
sal_uInt16 nFontType;
sal_uInt16 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 ( sal_uInt16 n = 0; n < nItemCnt; ++n )
{
Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType,
aOutTypeArr[ n ].nLanguage,
DEFAULTFONT_FLAGS_ONLYONE, 0 ) );
SvxFontItem* pItem = aItemArr[ n ];
pItem->SetFamily( aFont.GetFamily() );
pItem->SetFamilyName( aFont.GetName() );
pItem->SetStyleName( String() );
pItem->SetPitch( aFont.GetPitch());
pItem->SetCharSet(aFont.GetCharSet());
}
}
sal_uInt16 GetI18NScriptTypeOfLanguage( sal_uInt16 nLang )
{
return GetI18NScriptType( SvtLanguageOptions::GetScriptTypeOfLanguage( nLang ) );
}
sal_uInt16 GetItemScriptType( short nI18NType )
{
switch ( nI18NType )
{
case i18n::ScriptType::LATIN: return SCRIPTTYPE_LATIN;
case i18n::ScriptType::ASIAN: return SCRIPTTYPE_ASIAN;
case i18n::ScriptType::COMPLEX: return SCRIPTTYPE_COMPLEX;
}
return 0;
}
short GetI18NScriptType( sal_uInt16 nItemType )
{
switch ( nItemType )
{
case SCRIPTTYPE_LATIN: return i18n::ScriptType::LATIN;
case SCRIPTTYPE_ASIAN: return i18n::ScriptType::ASIAN;
case SCRIPTTYPE_COMPLEX: return i18n::ScriptType::COMPLEX;
}
return 0;
}