xref: /aoo42x/main/editeng/source/items/textitem.cxx (revision b63233d8)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_editeng.hxx"
26 
27 // include ---------------------------------------------------------------
28 #include <com/sun/star/style/CaseMap.hpp>
29 #include <com/sun/star/awt/FontDescriptor.hpp>
30 #include <com/sun/star/frame/status/FontHeight.hpp>
31 #include <vcl/bitmapex.hxx>
32 #include <tools/stream.hxx>
33 #include <toolkit/helper/vclunohelper.hxx>
34 #include <math.h>
35 #include <rtl/math.hxx>
36 #include <unotools/fontdefs.hxx>
37 #include <vcl/outdev.hxx>
38 #include <editeng/eeitem.hxx>
39 #include <svtools/unitconv.hxx>
40 
41 #define GLOBALOVERFLOW3
42 
43 #include <svl/memberid.hrc>
44 #include <editeng/editids.hrc>
45 #include <editeng/editrids.hrc>
46 #include <vcl/vclenum.hxx>
47 #include <tools/bigint.hxx>
48 #include <tools/tenccvt.hxx>
49 
50 #include <rtl/ustring.hxx>
51 #include <i18npool/mslangid.hxx>
52 #include <svl/itemset.hxx>
53 
54 #include <svtools/langtab.hxx>
55 #include <svl/itempool.hxx>
56 #include <svtools/ctrltool.hxx>
57 #include <vcl/settings.hxx>
58 #include <vcl/svapp.hxx>
59 #include <com/sun/star/style/CaseMap.hpp>
60 #include <com/sun/star/awt/SimpleFontMetric.hpp>
61 #include <com/sun/star/awt/FontWeight.hpp>
62 #include <com/sun/star/awt/FontSlant.hpp>
63 #include <com/sun/star/awt/CharSet.hpp>
64 #include <com/sun/star/awt/FontDescriptor.hpp>
65 #include <com/sun/star/awt/FontWidth.hpp>
66 #include <com/sun/star/awt/XFont.hpp>
67 #include <com/sun/star/awt/FontType.hpp>
68 #include <com/sun/star/awt/FontUnderline.hpp>
69 #include <com/sun/star/awt/FontStrikeout.hpp>
70 #include <com/sun/star/awt/FontFamily.hpp>
71 #include <com/sun/star/awt/FontPitch.hpp>
72 #include <com/sun/star/lang/Locale.hpp>
73 #include <com/sun/star/text/FontEmphasis.hpp>
74 #include <com/sun/star/i18n/ScriptType.hpp>
75 #include <editeng/memberids.hrc>
76 #include <editeng/flstitem.hxx>
77 #include <editeng/fontitem.hxx>
78 #include <editeng/postitem.hxx>
79 #include <editeng/wghtitem.hxx>
80 #include <editeng/fhgtitem.hxx>
81 #include <editeng/fwdtitem.hxx>
82 #include <editeng/udlnitem.hxx>
83 #include <editeng/crsditem.hxx>
84 #include <editeng/shdditem.hxx>
85 #include <editeng/akrnitem.hxx>
86 #include <editeng/wrlmitem.hxx>
87 #include <editeng/cntritem.hxx>
88 #include <editeng/prszitem.hxx>
89 #include <editeng/colritem.hxx>
90 #include <editeng/cscoitem.hxx>
91 #include <editeng/kernitem.hxx>
92 #include <editeng/cmapitem.hxx>
93 #include <editeng/escpitem.hxx>
94 #include <editeng/langitem.hxx>
95 #include <editeng/nlbkitem.hxx>
96 #include <editeng/nhypitem.hxx>
97 #include <editeng/lcolitem.hxx>
98 #include <editeng/blnkitem.hxx>
99 #include <editeng/emphitem.hxx>
100 #include <editeng/twolinesitem.hxx>
101 #include <editeng/scripttypeitem.hxx>
102 #include <editeng/charrotateitem.hxx>
103 #include <editeng/charscaleitem.hxx>
104 #include <editeng/charreliefitem.hxx>
105 #include <editeng/itemtype.hxx>
106 #include <editeng/eerdll.hxx>
107 
108 // #90477#
109 #include <tools/tenccvt.hxx>
110 
111 #define STORE_UNICODE_MAGIC_MARKER  0xFE331188
112 
113 using namespace ::rtl;
114 using namespace ::com::sun::star;
115 using namespace ::com::sun::star::text;
116 
117 // Konvertierung fuer UNO
118 #define TWIP_TO_MM100(TWIP) 	((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L))
119 #define MM100_TO_TWIP(MM100)	((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L))
120 #define TWIP_TO_MM100_UNSIGNED(TWIP)     ((((TWIP)*127L+36L)/72L))
121 #define MM100_TO_TWIP_UNSIGNED(MM100)    ((((MM100)*72L+63L)/127L))
122 
123 sal_Bool SvxFontItem::bEnableStoreUnicodeNames = sal_False;
124 
125 // STATIC DATA -----------------------------------------------------------
126 
127 // -----------------------------------------------------------------------
128 
129 TYPEINIT1(SvxFontListItem, SfxPoolItem);
130 TYPEINIT1_FACTORY(SvxFontItem, SfxPoolItem, new SvxFontItem(0));
131 TYPEINIT1_FACTORY(SvxPostureItem, SfxEnumItem, new SvxPostureItem(ITALIC_NONE, 0));
132 TYPEINIT1_FACTORY(SvxWeightItem, SfxEnumItem, new SvxWeightItem(WEIGHT_NORMAL, 0));
133 TYPEINIT1_FACTORY(SvxFontHeightItem, SfxPoolItem, new SvxFontHeightItem(240, 100, 0));
134 TYPEINIT1_FACTORY(SvxFontWidthItem, SfxPoolItem, new SvxFontWidthItem(0, 100, 0));
135 TYPEINIT1_FACTORY(SvxTextLineItem, SfxEnumItem, new SvxTextLineItem(UNDERLINE_NONE, 0));
136 TYPEINIT1_FACTORY(SvxUnderlineItem, SfxEnumItem, new SvxUnderlineItem(UNDERLINE_NONE, 0));
137 TYPEINIT1_FACTORY(SvxOverlineItem, SfxEnumItem, new SvxOverlineItem(UNDERLINE_NONE, 0));
138 TYPEINIT1_FACTORY(SvxCrossedOutItem, SfxEnumItem, new SvxCrossedOutItem(STRIKEOUT_NONE, 0));
139 TYPEINIT1_FACTORY(SvxShadowedItem, SfxBoolItem, new SvxShadowedItem(sal_False, 0));
140 TYPEINIT1_FACTORY(SvxAutoKernItem, SfxBoolItem, new SvxAutoKernItem(sal_False, 0));
141 TYPEINIT1_FACTORY(SvxWordLineModeItem, SfxBoolItem, new SvxWordLineModeItem(sal_False, 0));
142 TYPEINIT1_FACTORY(SvxContourItem, SfxBoolItem, new SvxContourItem(sal_False, 0));
143 TYPEINIT1_FACTORY(SvxPropSizeItem, SfxUInt16Item, new SvxPropSizeItem(100, 0));
144 TYPEINIT1_FACTORY(SvxColorItem, SfxPoolItem, new SvxColorItem(0));
145 TYPEINIT1_FACTORY(SvxCharSetColorItem, SvxColorItem, new SvxCharSetColorItem(0));
146 TYPEINIT1_FACTORY(SvxKerningItem, SfxInt16Item, new SvxKerningItem(0, 0));
147 TYPEINIT1_FACTORY(SvxCaseMapItem, SfxEnumItem, new SvxCaseMapItem(SVX_CASEMAP_NOT_MAPPED, 0));
148 TYPEINIT1_FACTORY(SvxEscapementItem, SfxPoolItem, new SvxEscapementItem(0));
149 TYPEINIT1_FACTORY(SvxLanguageItem, SfxEnumItem, new SvxLanguageItem(LANGUAGE_GERMAN, 0));
150 TYPEINIT1_FACTORY(SvxNoLinebreakItem, SfxBoolItem, new SvxNoLinebreakItem(sal_True, 0));
151 TYPEINIT1_FACTORY(SvxNoHyphenItem, SfxBoolItem, new SvxNoHyphenItem(sal_True, 0));
152 TYPEINIT1_FACTORY(SvxLineColorItem, SvxColorItem, new SvxLineColorItem(0));
153 TYPEINIT1_FACTORY(SvxBlinkItem, SfxBoolItem, new SvxBlinkItem(sal_False, 0));
154 TYPEINIT1_FACTORY(SvxEmphasisMarkItem, SfxUInt16Item, new SvxEmphasisMarkItem(EMPHASISMARK_NONE, 0));
155 TYPEINIT1_FACTORY(SvxTwoLinesItem, SfxPoolItem, new SvxTwoLinesItem(sal_True, 0, 0, 0));
156 TYPEINIT1_FACTORY(SvxScriptTypeItem, SfxUInt16Item, new SvxScriptTypeItem);
157 TYPEINIT1_FACTORY(SvxCharRotateItem, SfxUInt16Item, new SvxCharRotateItem(0, sal_False, 0));
158 TYPEINIT1_FACTORY(SvxCharScaleWidthItem, SfxUInt16Item, new SvxCharScaleWidthItem(100, 0));
159 TYPEINIT1_FACTORY(SvxCharReliefItem, SfxEnumItem, new SvxCharReliefItem(RELIEF_NONE, 0));
160 
161 
162 TYPEINIT1(SvxScriptSetItem, SfxSetItem );
163 
164 
165 // class SvxFontListItem -------------------------------------------------
166 
SvxFontListItem(const FontList * pFontLst,const sal_uInt16 nId)167 SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
168 								  const sal_uInt16 nId ) :
169 	SfxPoolItem( nId ),
170 	pFontList( pFontLst )
171 {
172     if ( pFontList )
173     {
174         sal_Int32 nCount = pFontList->GetFontNameCount();
175         aFontNameSeq.realloc( nCount );
176 
177         for ( sal_uInt16 i = 0; i < nCount; i++ )
178             aFontNameSeq[i] = pFontList->GetFontName(i).GetName();
179     }
180 }
181 
182 // -----------------------------------------------------------------------
183 
SvxFontListItem(const SvxFontListItem & rItem)184 SvxFontListItem::SvxFontListItem( const SvxFontListItem& rItem ) :
185 
186 	SfxPoolItem( rItem ),
187 	pFontList( rItem.GetFontList() ),
188 	aFontNameSeq( rItem.aFontNameSeq )
189 {
190 }
191 
192 // -----------------------------------------------------------------------
193 
Clone(SfxItemPool *) const194 SfxPoolItem* SvxFontListItem::Clone( SfxItemPool* ) const
195 {
196 	return new SvxFontListItem( *this );
197 }
198 
199 // -----------------------------------------------------------------------
200 
operator ==(const SfxPoolItem & rAttr) const201 int SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const
202 {
203 	DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
204 
205 	return( pFontList == ((SvxFontListItem&)rAttr).pFontList );
206 }
207 
QueryValue(com::sun::star::uno::Any & rVal,sal_uInt8) const208 sal_Bool SvxFontListItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
209 {
210     rVal <<= aFontNameSeq;
211 	return sal_True;
212 }
213 
214 //------------------------------------------------------------------------
215 
GetPresentation(SfxItemPresentation,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const216 SfxItemPresentation SvxFontListItem::GetPresentation
217 (
218     SfxItemPresentation /*ePres*/,
219     SfxMapUnit          /*eCoreUnit*/,
220     SfxMapUnit          /*ePresUnit*/,
221     XubString&          rText, const IntlWrapper * /*pIntl*/
222 )	const
223 {
224 	rText.Erase();
225 	return SFX_ITEM_PRESENTATION_NONE;
226 }
227 
228 // class SvxFontItem -----------------------------------------------------
229 
SvxFontItem(const sal_uInt16 nId)230 SvxFontItem::SvxFontItem( const sal_uInt16 nId ) :
231 	SfxPoolItem( nId )
232 {
233 	eFamily = FAMILY_SWISS;
234 	ePitch = PITCH_VARIABLE;
235 	eTextEncoding = RTL_TEXTENCODING_DONTKNOW;
236 }
237 
238 // -----------------------------------------------------------------------
239 
SvxFontItem(const FontFamily eFam,const XubString & aName,const XubString & aStName,const FontPitch eFontPitch,const rtl_TextEncoding eFontTextEncoding,const sal_uInt16 nId)240 SvxFontItem::SvxFontItem( const FontFamily eFam, const XubString& aName,
241 				  const XubString& aStName, const FontPitch eFontPitch,
242 				  const rtl_TextEncoding eFontTextEncoding, const sal_uInt16 nId ) :
243 
244 	SfxPoolItem( nId ),
245 
246 	aFamilyName(aName),
247 	aStyleName(aStName)
248 {
249 	eFamily = eFam;
250 	ePitch = eFontPitch;
251 	eTextEncoding = eFontTextEncoding;
252 }
253 
254 // -----------------------------------------------------------------------
operator =(const SvxFontItem & rFont)255 SvxFontItem& SvxFontItem::operator=(const SvxFontItem& rFont)
256 {
257     aFamilyName =  rFont.GetFamilyName();
258     aStyleName =   rFont.GetStyleName();
259     eFamily =      rFont.GetFamily();
260     ePitch =   rFont.GetPitch();
261     eTextEncoding = rFont.GetCharSet();
262     return *this;
263 }
264 // -----------------------------------------------------------------------
265 
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const266 sal_Bool SvxFontItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
267 {
268 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
269     nMemberId &= ~CONVERT_TWIPS;
270 	switch(nMemberId)
271 	{
272         case 0:
273         {
274             com::sun::star::awt::FontDescriptor aFontDescriptor;
275             aFontDescriptor.Name = aFamilyName.GetBuffer();
276             aFontDescriptor.StyleName = aStyleName.GetBuffer();
277             aFontDescriptor.Family = (sal_Int16)(eFamily);
278             aFontDescriptor.CharSet = (sal_Int16)(eTextEncoding);
279             aFontDescriptor.Pitch = (sal_Int16)(ePitch);
280             rVal <<= aFontDescriptor;
281         }
282         break;
283 		case MID_FONT_FAMILY_NAME	:
284 			rVal <<= OUString(aFamilyName.GetBuffer());
285 		break;
286 		case MID_FONT_STYLE_NAME:
287 			rVal <<= OUString(aStyleName.GetBuffer());
288 		break;
289 		case MID_FONT_FAMILY    : rVal <<= (sal_Int16)(eFamily);	break;
290 		case MID_FONT_CHAR_SET  : rVal <<= (sal_Int16)(eTextEncoding);	break;
291 		case MID_FONT_PITCH     : rVal <<= (sal_Int16)(ePitch);	break;
292 	}
293 	return sal_True;
294 }
295 // -----------------------------------------------------------------------
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)296 sal_Bool SvxFontItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
297 {
298 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
299     nMemberId &= ~CONVERT_TWIPS;
300 	switch(nMemberId)
301 	{
302         case 0:
303         {
304             com::sun::star::awt::FontDescriptor aFontDescriptor;
305             if ( !( rVal >>= aFontDescriptor ))
306                 return sal_False;
307 
308             aFamilyName = aFontDescriptor.Name;
309             aStyleName = aFontDescriptor.StyleName;
310             eFamily = (FontFamily)aFontDescriptor.Family;
311             eTextEncoding = (rtl_TextEncoding)aFontDescriptor.CharSet;
312             ePitch = (FontPitch)aFontDescriptor.Pitch;
313         }
314         break;
315 		case MID_FONT_FAMILY_NAME	:
316 		{
317 			OUString aStr;
318 			if(!(rVal >>= aStr))
319 				return sal_False;
320 			aFamilyName = aStr.getStr();
321 		}
322 		break;
323 		case MID_FONT_STYLE_NAME:
324 		{
325 			OUString aStr;
326 			if(!(rVal >>= aStr))
327 				return sal_False;
328 			aStyleName = aStr.getStr();
329 		}
330 		break;
331 		case MID_FONT_FAMILY :
332 		{
333 			sal_Int16 nFamily = sal_Int16();
334 			if(!(rVal >>= nFamily))
335 				return sal_False;
336 			eFamily = (FontFamily)nFamily;
337 		}
338 		break;
339 		case MID_FONT_CHAR_SET  :
340 		{
341 			sal_Int16 nSet = sal_Int16();
342 			if(!(rVal >>= nSet))
343 				return sal_False;
344 			eTextEncoding = (rtl_TextEncoding)nSet;
345 		}
346 		break;
347 		case MID_FONT_PITCH     :
348 		{
349 			sal_Int16 nPitch = sal_Int16();
350 			if(!(rVal >>= nPitch))
351 				return sal_False;
352 			ePitch =  (FontPitch)nPitch;
353 		}
354 		break;
355 	}
356 	return sal_True;
357 }
358 
359 // -----------------------------------------------------------------------
360 
operator ==(const SfxPoolItem & rAttr) const361 int SvxFontItem::operator==( const SfxPoolItem& rAttr ) const
362 {
363 	DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
364 
365 	const SvxFontItem& rItem = (const SvxFontItem&)rAttr;
366 
367 	int bRet = ( eFamily == rItem.eFamily &&
368 				 aFamilyName == rItem.aFamilyName &&
369 				 aStyleName == rItem.aStyleName );
370 
371 	if ( bRet )
372 	{
373 		if ( ePitch != rItem.ePitch || eTextEncoding != rItem.eTextEncoding )
374 		{
375 			bRet = sal_False;
376 			DBG_WARNING( "FontItem::operator==(): nur Pitch oder rtl_TextEncoding unterschiedlich" );
377 		}
378 	}
379 	return bRet;
380 }
381 
382 // -----------------------------------------------------------------------
383 
Clone(SfxItemPool *) const384 SfxPoolItem* SvxFontItem::Clone( SfxItemPool * ) const
385 {
386 	return new SvxFontItem( *this );
387 }
388 
389 // -----------------------------------------------------------------------
390 
Store(SvStream & rStrm,sal_uInt16) const391 SvStream& SvxFontItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
392 {
393 	sal_Bool bToBats =
394 		GetFamilyName().EqualsAscii( "StarSymbol", 0, sizeof("StarSymbol")-1 ) ||
395 		GetFamilyName().EqualsAscii( "OpenSymbol", 0, sizeof("OpenSymbol")-1 );
396 
397 	// #90477# rStrm << (sal_uInt8) GetFamily()
398 	//	  << (sal_uInt8) GetPitch()
399 	//	  << (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() ) );
400 	rStrm << (sal_uInt8) GetFamily() << (sal_uInt8) GetPitch()
401 		  << (sal_uInt8)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()));
402 
403     String aStoreFamilyName( GetFamilyName() );
404     if( bToBats )
405 		aStoreFamilyName = String( "StarBats", sizeof("StarBats")-1, RTL_TEXTENCODING_ASCII_US );
406     rStrm.WriteByteString(aStoreFamilyName);
407 	rStrm.WriteByteString(GetStyleName());
408 
409     // #96441# Kach for EditEngine, only set while creating clipboard stream.
410     if ( bEnableStoreUnicodeNames )
411     {
412         sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER;
413         rStrm << nMagic;
414         rStrm.WriteByteString( aStoreFamilyName, RTL_TEXTENCODING_UNICODE );
415 	    rStrm.WriteByteString( GetStyleName(), RTL_TEXTENCODING_UNICODE );
416     }
417 
418 	return rStrm;
419 }
420 
421 // -----------------------------------------------------------------------
422 
Create(SvStream & rStrm,sal_uInt16) const423 SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, sal_uInt16) const
424 {
425     sal_uInt8 _eFamily, eFontPitch, eFontTextEncoding;
426 	String aName, aStyle;
427     rStrm >> _eFamily;
428 	rStrm >> eFontPitch;
429 	rStrm >> eFontTextEncoding;
430 
431 	// UNICODE: rStrm >> aName;
432 	rStrm.ReadByteString(aName);
433 
434 	// UNICODE: rStrm >> aStyle;
435 	rStrm.ReadByteString(aStyle);
436 
437 	// Task 91008/90471: set the "correct" textencoding
438 	eFontTextEncoding = (sal_uInt8)GetSOLoadTextEncoding( eFontTextEncoding, (sal_uInt16)rStrm.GetVersion() );
439 
440 	// irgendwann wandelte sich der StarBats vom ANSI- zum SYMBOL-Font
441 	if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName.EqualsAscii("StarBats") )
442 		eFontTextEncoding = RTL_TEXTENCODING_SYMBOL;
443 
444     // Check if we have stored unicode
445     sal_Size nStreamPos = rStrm.Tell();
446     sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER;
447     rStrm >> nMagic;
448     if ( nMagic == STORE_UNICODE_MAGIC_MARKER )
449     {
450         rStrm.ReadByteString( aName, RTL_TEXTENCODING_UNICODE );
451 	    rStrm.ReadByteString( aStyle, RTL_TEXTENCODING_UNICODE );
452     }
453     else
454     {
455         rStrm.Seek( nStreamPos );
456     }
457 
458 
459 
460     return new SvxFontItem( (FontFamily)_eFamily, aName, aStyle,
461 							(FontPitch)eFontPitch, (rtl_TextEncoding)eFontTextEncoding,	Which() );
462 }
463 
464 //------------------------------------------------------------------------
465 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const466 SfxItemPresentation SvxFontItem::GetPresentation
467 (
468 	SfxItemPresentation ePres,
469     SfxMapUnit          /*eCoreUnit*/,
470     SfxMapUnit          /*ePresUnit*/,
471     XubString&          rText, const IntlWrapper * /*pIntl*/
472 )	const
473 {
474 	switch ( ePres )
475 	{
476 		case SFX_ITEM_PRESENTATION_NONE:
477 			rText.Erase();
478 			return ePres;
479 		case SFX_ITEM_PRESENTATION_NAMELESS:
480 		case SFX_ITEM_PRESENTATION_COMPLETE:
481 			rText = aFamilyName;
482 			return ePres;
483         default: ; //prevent warning
484 	}
485 	return SFX_ITEM_PRESENTATION_NONE;
486 }
487 
488 //------------------------------------------------------------------------
489 
EnableStoreUnicodeNames(sal_Bool bEnable)490 void SvxFontItem::EnableStoreUnicodeNames( sal_Bool bEnable )
491 {
492     bEnableStoreUnicodeNames = bEnable;
493 }
494 
495 // class SvxPostureItem --------------------------------------------------
496 
SvxPostureItem(const FontItalic ePosture,const sal_uInt16 nId)497 SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const sal_uInt16 nId ) :
498 	SfxEnumItem( nId, (sal_uInt16)ePosture )
499 {
500 }
501 
502 // -----------------------------------------------------------------------
503 
Clone(SfxItemPool *) const504 SfxPoolItem* SvxPostureItem::Clone( SfxItemPool * ) const
505 {
506 	return new SvxPostureItem( *this );
507 }
508 
509 // -----------------------------------------------------------------------
510 
GetValueCount() const511 sal_uInt16 SvxPostureItem::GetValueCount() const
512 {
513 	return ITALIC_NORMAL + 1;	// auch ITALIC_NONE geh"ort dazu
514 }
515 
516 // -----------------------------------------------------------------------
517 
Store(SvStream & rStrm,sal_uInt16) const518 SvStream& SvxPostureItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
519 {
520 	rStrm << (sal_uInt8)GetValue();
521 	return rStrm;
522 }
523 
524 // -----------------------------------------------------------------------
525 
Create(SvStream & rStrm,sal_uInt16) const526 SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, sal_uInt16) const
527 {
528 	sal_uInt8 nPosture;
529 	rStrm >> nPosture;
530 	return new SvxPostureItem( (const FontItalic)nPosture, Which() );
531 }
532 
533 //------------------------------------------------------------------------
534 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const535 SfxItemPresentation SvxPostureItem::GetPresentation
536 (
537 	SfxItemPresentation ePres,
538     SfxMapUnit          /*eCoreUnit*/,
539     SfxMapUnit          /*ePresUnit*/,
540     XubString&          rText, const IntlWrapper * /*pIntl*/
541 )	const
542 {
543 	switch ( ePres )
544 	{
545 		case SFX_ITEM_PRESENTATION_NONE:
546 			rText.Erase();
547 			return ePres;
548 		case SFX_ITEM_PRESENTATION_NAMELESS:
549 		case SFX_ITEM_PRESENTATION_COMPLETE:
550 			rText = GetValueTextByPos( GetValue() );
551 			return ePres;
552         default: ;//prevent warning
553 	}
554 	return SFX_ITEM_PRESENTATION_NONE;
555 }
556 
557 // -----------------------------------------------------------------------
558 
GetValueTextByPos(sal_uInt16 nPos) const559 XubString SvxPostureItem::GetValueTextByPos( sal_uInt16 nPos ) const
560 {
561 	DBG_ASSERT( nPos <= (sal_uInt16)ITALIC_NORMAL, "enum overflow!" );
562 
563 	XubString sTxt;
564 	FontItalic eItalic = (FontItalic)nPos;
565 	sal_uInt16 nId = 0;
566 
567 	switch ( eItalic )
568 	{
569 		case ITALIC_NONE:		nId = RID_SVXITEMS_ITALIC_NONE;		break;
570 		case ITALIC_OBLIQUE:	nId = RID_SVXITEMS_ITALIC_OBLIQUE;	break;
571 		case ITALIC_NORMAL:		nId = RID_SVXITEMS_ITALIC_NORMAL;	break;
572         default: ;//prevent warning
573     }
574 
575 	if ( nId )
576 		sTxt = EditResId( nId );
577 	return sTxt;
578 }
579 
580 
581 /*-----------------13.03.98 14:28-------------------
582 
583 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const584 sal_Bool SvxPostureItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
585 {
586 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
587     nMemberId &= ~CONVERT_TWIPS;
588 	switch( nMemberId )
589 	{
590 		case MID_ITALIC:
591 			rVal = Bool2Any(GetBoolValue());
592 			break;
593 		case MID_POSTURE:
594 			rVal <<= (awt::FontSlant)GetValue();	// Werte von awt::FontSlant und FontItalic sind gleich
595 			break;
596 	}
597 	return sal_True;
598 }
599 /*-----------------13.03.98 14:28-------------------
600 
601 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)602 sal_Bool SvxPostureItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
603 {
604 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
605     nMemberId &= ~CONVERT_TWIPS;
606 	switch( nMemberId )
607 	{
608 		case MID_ITALIC:
609 			SetBoolValue(Any2Bool(rVal));
610 		break;
611 		case MID_POSTURE:
612 		{
613 			awt::FontSlant eSlant;
614 			if(!(rVal >>= eSlant))
615 			{
616 				sal_Int32 nValue = 0;
617 				if(!(rVal >>= nValue))
618 					return sal_False;
619 
620 				eSlant = (awt::FontSlant)nValue;
621 			}
622 			SetValue((sal_uInt16)eSlant);
623 		}
624 	}
625 	return sal_True;
626 }
627 // -----------------------------------------------------------------------
628 
HasBoolValue() const629 int SvxPostureItem::HasBoolValue() const
630 {
631 	return sal_True;
632 }
633 
634 // -----------------------------------------------------------------------
635 
GetBoolValue() const636 sal_Bool SvxPostureItem::GetBoolValue() const
637 {
638 	return ( (FontItalic)GetValue() >= ITALIC_OBLIQUE );
639 }
640 
641 // -----------------------------------------------------------------------
642 
SetBoolValue(sal_Bool bVal)643 void SvxPostureItem::SetBoolValue( sal_Bool bVal )
644 {
645 	SetValue( (sal_uInt16)(bVal ? ITALIC_NORMAL : ITALIC_NONE) );
646 }
647 
648 // class SvxWeightItem ---------------------------------------------------
649 
SvxWeightItem(const FontWeight eWght,const sal_uInt16 nId)650 SvxWeightItem::SvxWeightItem( const FontWeight eWght, const sal_uInt16 nId ) :
651 	SfxEnumItem( nId, (sal_uInt16)eWght )
652 {
653 }
654 
655 
656 
657 // -----------------------------------------------------------------------
658 
HasBoolValue() const659 int SvxWeightItem::HasBoolValue() const
660 {
661 	return sal_True;
662 }
663 
664 // -----------------------------------------------------------------------
665 
GetBoolValue() const666 sal_Bool SvxWeightItem::GetBoolValue() const
667 {
668 	return  (FontWeight)GetValue() >= WEIGHT_BOLD;
669 }
670 
671 // -----------------------------------------------------------------------
672 
SetBoolValue(sal_Bool bVal)673 void SvxWeightItem::SetBoolValue( sal_Bool bVal )
674 {
675 	SetValue( (sal_uInt16)(bVal ? WEIGHT_BOLD : WEIGHT_NORMAL) );
676 }
677 
678 // -----------------------------------------------------------------------
679 
GetValueCount() const680 sal_uInt16 SvxWeightItem::GetValueCount() const
681 {
682 	return WEIGHT_BLACK;	// WEIGHT_DONTKNOW geh"ort nicht dazu
683 }
684 
685 // -----------------------------------------------------------------------
686 
Clone(SfxItemPool *) const687 SfxPoolItem* SvxWeightItem::Clone( SfxItemPool * ) const
688 {
689 	return new SvxWeightItem( *this );
690 }
691 
692 // -----------------------------------------------------------------------
693 
Store(SvStream & rStrm,sal_uInt16) const694 SvStream& SvxWeightItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
695 {
696 	rStrm << (sal_uInt8)GetValue();
697 	return rStrm;
698 }
699 
700 // -----------------------------------------------------------------------
701 
Create(SvStream & rStrm,sal_uInt16) const702 SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, sal_uInt16) const
703 {
704 	sal_uInt8 nWeight;
705 	rStrm >> nWeight;
706 	return new SvxWeightItem( (FontWeight)nWeight, Which() );
707 }
708 
709 //------------------------------------------------------------------------
710 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const711 SfxItemPresentation SvxWeightItem::GetPresentation
712 (
713 	SfxItemPresentation ePres,
714     SfxMapUnit          /*eCoreUnit*/,
715     SfxMapUnit          /*ePresUnit*/,
716     XubString&          rText, const IntlWrapper * /*pIntl*/
717 )	const
718 {
719 	switch ( ePres )
720 	{
721 		case SFX_ITEM_PRESENTATION_NONE:
722 			rText.Erase();
723 			return ePres;
724 		case SFX_ITEM_PRESENTATION_NAMELESS:
725 		case SFX_ITEM_PRESENTATION_COMPLETE:
726 			rText = GetValueTextByPos( GetValue() );
727 			return ePres;
728         default: ;//prevent warning
729     }
730 	return SFX_ITEM_PRESENTATION_NONE;
731 }
732 
733 // -----------------------------------------------------------------------
734 
GetValueTextByPos(sal_uInt16 nPos) const735 XubString SvxWeightItem::GetValueTextByPos( sal_uInt16 nPos ) const
736 {
737 	DBG_ASSERT( nPos <= (sal_uInt16)WEIGHT_BLACK, "enum overflow!" );
738 	return EE_RESSTR( RID_SVXITEMS_WEIGHT_BEGIN + nPos );
739 }
740 
741 /*-----------------13.03.98 14:18-------------------
742 
743 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const744 sal_Bool SvxWeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
745 {
746 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
747     nMemberId &= ~CONVERT_TWIPS;
748 	switch( nMemberId )
749 	{
750 		case MID_BOLD	:
751 			rVal = Bool2Any(GetBoolValue());
752 		break;
753 		case MID_WEIGHT:
754 		{
755 			rVal <<= (float)( VCLUnoHelper::ConvertFontWeight( (FontWeight)GetValue() ) );
756 		}
757 		break;
758 	}
759 	return sal_True;
760 }
761 /*-----------------13.03.98 14:18-------------------
762 
763 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)764 sal_Bool SvxWeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
765 {
766 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
767     nMemberId &= ~CONVERT_TWIPS;
768 	switch( nMemberId )
769 	{
770 		case MID_BOLD	:
771 			SetBoolValue(Any2Bool(rVal));
772 		break;
773 		case MID_WEIGHT:
774 		{
775             double fValue = 0;
776 			if(!(rVal >>= fValue))
777 			{
778 				sal_Int32 nValue = 0;
779 				if(!(rVal >>= nValue))
780 					return sal_False;
781 				fValue = (float)nValue;
782 			}
783 			SetValue( (sal_uInt16)VCLUnoHelper::ConvertFontWeight((float)fValue) );
784 		}
785 		break;
786 	}
787 	return sal_True;
788 }
789 
790 // class SvxFontHeightItem -----------------------------------------------
791 
SvxFontHeightItem(const sal_uLong nSz,const sal_uInt16 nPrp,const sal_uInt16 nId)792 SvxFontHeightItem::SvxFontHeightItem( const sal_uLong nSz,
793 									  const sal_uInt16 nPrp,
794 									  const sal_uInt16 nId ) :
795 	SfxPoolItem( nId )
796 {
797 	SetHeight( nSz,nPrp );	// mit den Prozenten rechnen
798 }
799 
800 // -----------------------------------------------------------------------
801 
Clone(SfxItemPool *) const802 SfxPoolItem* SvxFontHeightItem::Clone( SfxItemPool * ) const
803 {
804 	return new SvxFontHeightItem( *this );
805 }
806 
807 // -----------------------------------------------------------------------
808 
Store(SvStream & rStrm,sal_uInt16 nItemVersion) const809 SvStream& SvxFontHeightItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
810 {
811 	rStrm << (sal_uInt16)GetHeight();
812 
813 	if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
814 		rStrm << GetProp() << (sal_uInt16)GetPropUnit();
815 	else
816 	{
817 		// JP 30.06.98: beim Export in alte Versionen geht die relative
818 		// Angabe verloren, wenn es keine Prozentuale ist
819         sal_uInt16 _nProp = GetProp();
820 		if( SFX_MAPUNIT_RELATIVE != GetPropUnit() )
821             _nProp = 100;
822         rStrm << _nProp;
823 	}
824 	return rStrm;
825 }
826 
827 // -----------------------------------------------------------------------
828 
Create(SvStream & rStrm,sal_uInt16 nVersion) const829 SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm,
830 												 sal_uInt16 nVersion ) const
831 {
832 	sal_uInt16 nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE;
833 
834 	rStrm >> nsize;
835 
836 	if( FONTHEIGHT_16_VERSION <= nVersion )
837 		rStrm >> nprop;
838 	else
839 	{
840 		sal_uInt8 nP;
841 		rStrm  >> nP;
842 		nprop = (sal_uInt16)nP;
843 	}
844 
845 	if( FONTHEIGHT_UNIT_VERSION <= nVersion )
846 		rStrm >> nPropUnit;
847 
848 	SvxFontHeightItem* pItem = new SvxFontHeightItem( nsize, 100, Which() );
849 	pItem->SetProp( nprop, (SfxMapUnit)nPropUnit );
850 	return pItem;
851 }
852 
853 // -----------------------------------------------------------------------
854 
operator ==(const SfxPoolItem & rItem) const855 int SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const
856 {
857 	DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
858 	return GetHeight() == ((SvxFontHeightItem&)rItem).GetHeight() &&
859 			GetProp() == ((SvxFontHeightItem&)rItem).GetProp() &&
860 			GetPropUnit() == ((SvxFontHeightItem&)rItem).GetPropUnit();
861 }
862 
863 /*-----------------13.03.98 14:53-------------------
864 
865 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const866 sal_Bool SvxFontHeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
867 {
868 	//	In StarOne sind im uno::Any immer 1/100mm. Ueber die MemberId wird
869 	//	gesteuert, ob der Wert im Item 1/100mm oder Twips sind.
870 
871 	sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
872 	nMemberId &= ~CONVERT_TWIPS;
873 	switch( nMemberId )
874 	{
875 		case 0:
876 		{
877 		    ::com::sun::star::frame::status::FontHeight aFontHeight;
878 
879 			//	Point (also Twips) sind gefragt,
880 			//	also umrechnen, wenn CONVERT_TWIPS nicht gesetzt ist
881 			if( bConvert )
882 			{
883                 long nTwips = bConvert ? nHeight : MM100_TO_TWIP_UNSIGNED(nHeight);
884 				aFontHeight.Height = (float)( nTwips / 20.0 );
885 			}
886 			else
887 			{
888 				double fPoints = MM100_TO_TWIP_UNSIGNED(nHeight) / 20.0;
889                 float fRoundPoints =
890                     static_cast<float>(::rtl::math::round(fPoints, 1));
891 				aFontHeight.Height = fRoundPoints;
892 			}
893 
894             aFontHeight.Prop = (sal_Int16)(SFX_MAPUNIT_RELATIVE == ePropUnit ? nProp : 100);
895 
896 			float fRet = (float)(short)nProp;
897 			switch( ePropUnit )
898 			{
899 				case SFX_MAPUNIT_RELATIVE:
900 					fRet = 0.;
901 				break;
902 				case SFX_MAPUNIT_100TH_MM:
903 					fRet = MM100_TO_TWIP(fRet);
904 					fRet /= 20.;
905 				break;
906 				case SFX_MAPUNIT_POINT:
907 
908 				break;
909 				case SFX_MAPUNIT_TWIP:
910 					fRet /= 20.;
911 				break;
912                 default: ;//prevent warning
913             }
914 			aFontHeight.Diff = fRet;
915 			rVal <<= aFontHeight;
916 		}
917 		break;
918 		case MID_FONTHEIGHT:
919 		{
920 			//	Point (also Twips) sind gefragt,
921 			//	also umrechnen, wenn CONVERT_TWIPS nicht gesetzt ist
922 			if( bConvert )
923 			{
924                 long nTwips = bConvert ? nHeight : MM100_TO_TWIP_UNSIGNED(nHeight);
925 				rVal <<= (float)( nTwips / 20.0 );
926 			}
927 			else
928 			{
929 				double fPoints = MM100_TO_TWIP_UNSIGNED(nHeight) / 20.0;
930                 float fRoundPoints =
931                     static_cast<float>(::rtl::math::round(fPoints, 1));
932 				rVal <<= fRoundPoints;
933 			}
934 		}
935 		break;
936 		case MID_FONTHEIGHT_PROP:
937 			rVal <<= (sal_Int16)(SFX_MAPUNIT_RELATIVE == ePropUnit ? nProp : 100);
938 		break;
939 		case MID_FONTHEIGHT_DIFF:
940 		{
941 			float fRet = (float)(short)nProp;
942 			switch( ePropUnit )
943 			{
944 				case SFX_MAPUNIT_RELATIVE:
945 					fRet = 0.;
946 				break;
947 				case SFX_MAPUNIT_100TH_MM:
948 					fRet = MM100_TO_TWIP(fRet);
949 					fRet /= 20.;
950 				break;
951 				case SFX_MAPUNIT_POINT:
952 
953 				break;
954 				case SFX_MAPUNIT_TWIP:
955 					fRet /= 20.;
956 				break;
957                 default: ;//prevent warning
958             }
959 			rVal <<= fRet;
960 		}
961 		break;
962 	}
963 	return sal_True;
964 }
965 /* -----------------01.07.98 13:43-------------------
966  * 	Relative Abweichung aus der Hoehe herausrechnen
967  * --------------------------------------------------*/
lcl_GetRealHeight_Impl(sal_uInt32 nHeight,sal_uInt16 nProp,SfxMapUnit eProp,sal_Bool bCoreInTwip)968 sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, SfxMapUnit eProp, sal_Bool bCoreInTwip)
969 {
970 	sal_uInt32 nRet = nHeight;
971 	short nDiff = 0;
972 	switch( eProp )
973 	{
974 		case SFX_MAPUNIT_RELATIVE:
975 			nRet *= 100;
976 			nRet /= nProp;
977 		break;
978 		case SFX_MAPUNIT_POINT:
979 		{
980 			short nTemp = (short)nProp;
981 			nDiff = nTemp * 20;
982 			if(!bCoreInTwip)
983 				nDiff = (short)TWIP_TO_MM100((long)(nDiff));
984 		}
985 		break;
986 		case SFX_MAPUNIT_100TH_MM:
987 			//dann ist die Core doch wohl auch in 1/100 mm
988 			nDiff = (short)nProp;
989 		break;
990 		case SFX_MAPUNIT_TWIP:
991 			// hier doch sicher TWIP
992 			nDiff = ((short)nProp);
993 		break;
994         default: ;//prevent warning
995     }
996 	nRet -= nDiff;
997 
998 	return nRet;
999 }
1000 
1001 /*-----------------13.03.98 14:53-------------------
1002 
1003 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)1004 sal_Bool SvxFontHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1005 {
1006 	sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1007 	nMemberId &= ~CONVERT_TWIPS;
1008 	switch( nMemberId )
1009 	{
1010         case 0:
1011         {
1012 		    ::com::sun::star::frame::status::FontHeight aFontHeight;
1013 		    if ( rVal >>= aFontHeight )
1014 		    {
1015                 // Height
1016 			    ePropUnit = SFX_MAPUNIT_RELATIVE;
1017 			    nProp = 100;
1018                 double fPoint = aFontHeight.Height;
1019                 if( fPoint < 0. || fPoint > 10000. )
1020                     return sal_False;
1021 
1022 			    nHeight = (long)( fPoint * 20.0 + 0.5 );		// Twips
1023 		        if (!bConvert)
1024                     nHeight = TWIP_TO_MM100_UNSIGNED(nHeight);  // umrechnen, wenn das Item 1/100mm enthaelt
1025 
1026                 nProp = aFontHeight.Prop;
1027 		    }
1028 		    else
1029 		        return sal_False;
1030         }
1031         break;
1032 		case MID_FONTHEIGHT:
1033 		{
1034 			ePropUnit = SFX_MAPUNIT_RELATIVE;
1035 			nProp = 100;
1036             double fPoint = 0;
1037 			if(!(rVal >>= fPoint))
1038 			{
1039 				sal_Int32 nValue = 0;
1040                 if(!(rVal >>= nValue))
1041 					return sal_False;
1042 				fPoint = (float)nValue;
1043 			}
1044             if(fPoint < 0. || fPoint > 10000.)
1045 					return sal_False;
1046 
1047 			nHeight = (long)( fPoint * 20.0 + 0.5 );		// Twips
1048 			if (!bConvert)
1049                 nHeight = TWIP_TO_MM100_UNSIGNED(nHeight);  // umrechnen, wenn das Item 1/100mm enthaelt
1050 		}
1051 		break;
1052 		case MID_FONTHEIGHT_PROP:
1053 		{
1054 			sal_Int16 nNew = sal_Int16();
1055 			if(!(rVal >>= nNew))
1056 				return sal_True;
1057 
1058 			nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
1059 
1060 			nHeight *= nNew;
1061 			nHeight /= 100;
1062 			nProp = nNew;
1063 			ePropUnit = SFX_MAPUNIT_RELATIVE;
1064 		}
1065 		break;
1066 		case MID_FONTHEIGHT_DIFF:
1067 		{
1068 			nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
1069 			float fValue = 0;
1070 			if(!(rVal >>= fValue))
1071 			{
1072 				sal_Int32 nValue = 0;
1073 				if(!(rVal >>= nValue))
1074 					return sal_False;
1075 				fValue = (float)nValue;
1076 			}
1077     		sal_Int16 nCoreDiffValue = (sal_Int16)(fValue * 20.);
1078 	    	nHeight += bConvert ? nCoreDiffValue : TWIP_TO_MM100(nCoreDiffValue);
1079 		    nProp = (sal_uInt16)((sal_Int16)fValue);
1080 			ePropUnit = SFX_MAPUNIT_POINT;
1081 		}
1082 		break;
1083 	}
1084 	return sal_True;
1085 }
1086 
1087 //------------------------------------------------------------------------
1088 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit eCoreUnit,SfxMapUnit,XubString & rText,const IntlWrapper * pIntl) const1089 SfxItemPresentation SvxFontHeightItem::GetPresentation
1090 (
1091 	SfxItemPresentation ePres,
1092 	SfxMapUnit			eCoreUnit,
1093     SfxMapUnit          /*ePresUnit*/,
1094     XubString&          rText, const IntlWrapper *pIntl
1095 )	const
1096 {
1097 #ifndef SVX_LIGHT
1098 	switch ( ePres )
1099 	{
1100 		case SFX_ITEM_PRESENTATION_NONE:
1101 			rText.Erase();
1102 			return ePres;
1103 		case SFX_ITEM_PRESENTATION_NAMELESS:
1104 		case SFX_ITEM_PRESENTATION_COMPLETE:
1105 		{
1106 			if( SFX_MAPUNIT_RELATIVE != ePropUnit )
1107 			{
1108 				rText = String::CreateFromInt32( (short)nProp );
1109 				rText += sal_Unicode(' ');
1110 				rText += EE_RESSTR( GetMetricId( ePropUnit ) );
1111 				if( 0 <= (short)nProp )
1112 					rText.Insert( sal_Unicode('+'), 0 );
1113 			}
1114 			else if( 100 == nProp )
1115 			{
1116 				rText = GetMetricText( (long)nHeight,
1117                                         eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
1118 				rText += sal_Unicode(' ');
1119 				rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
1120 			}
1121 			else
1122 				( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%');
1123             return ePres;
1124 		}
1125         default: ; //prevent warning
1126     }
1127 #endif
1128 	return SFX_ITEM_PRESENTATION_NONE;
1129 }
1130 
1131 // -----------------------------------------------------------------------
1132 
GetVersion(sal_uInt16 nFileVersion) const1133 sal_uInt16 SvxFontHeightItem::GetVersion(sal_uInt16 nFileVersion) const
1134 {
1135 	return (nFileVersion <= SOFFICE_FILEFORMAT_40)
1136 			   ? FONTHEIGHT_16_VERSION
1137 			   : FONTHEIGHT_UNIT_VERSION;
1138 }
1139 
1140 // -----------------------------------------------------------------------
1141 
ScaleMetrics(long nMult,long nDiv)1142 int SvxFontHeightItem::ScaleMetrics( long nMult, long nDiv )
1143 {
1144 	nHeight = (sal_uInt32)Scale( nHeight, nMult, nDiv );
1145 	return 1;
1146 }
1147 
1148 // -----------------------------------------------------------------------
1149 
HasMetrics() const1150 int SvxFontHeightItem::HasMetrics() const
1151 {
1152 	return 1;
1153 }
1154 
SetHeight(sal_uInt32 nNewHeight,const sal_uInt16 nNewProp,SfxMapUnit eUnit)1155 void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const sal_uInt16 nNewProp,
1156 									SfxMapUnit eUnit )
1157 {
1158 	DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
1159 
1160 #ifndef SVX_LIGHT
1161 	if( SFX_MAPUNIT_RELATIVE != eUnit )
1162 		nHeight = nNewHeight + ::ItemToControl( (short)nNewProp, eUnit,
1163 												SFX_FUNIT_TWIP );
1164 	else
1165 #endif // !SVX_LIGHT
1166 	if( 100 != nNewProp )
1167 		nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
1168 	else
1169 		nHeight = nNewHeight;
1170 
1171 	nProp = nNewProp;
1172 	ePropUnit = eUnit;
1173 }
1174 
SetHeight(sal_uInt32 nNewHeight,sal_uInt16 nNewProp,SfxMapUnit eMetric,SfxMapUnit eCoreMetric)1175 void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, sal_uInt16 nNewProp,
1176 								 SfxMapUnit eMetric, SfxMapUnit eCoreMetric )
1177 {
1178 	DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
1179 
1180 #ifndef SVX_LIGHT
1181 	if( SFX_MAPUNIT_RELATIVE != eMetric )
1182 		nHeight = nNewHeight +
1183 				::ControlToItem( ::ItemToControl((short)nNewProp, eMetric,
1184 										SFX_FUNIT_TWIP ), SFX_FUNIT_TWIP,
1185 										eCoreMetric );
1186 	else
1187 #endif // !SVX_LIGHT
1188 	if( 100 != nNewProp )
1189 		nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
1190 	else
1191 		nHeight = nNewHeight;
1192 
1193 	nProp = nNewProp;
1194 	ePropUnit = eMetric;
1195 }
1196 
1197 // class SvxFontWidthItem -----------------------------------------------
1198 
SvxFontWidthItem(const sal_uInt16 nSz,const sal_uInt16 nPrp,const sal_uInt16 nId)1199 SvxFontWidthItem::SvxFontWidthItem( const sal_uInt16 nSz, const sal_uInt16 nPrp, const sal_uInt16 nId ) :
1200 	SfxPoolItem( nId )
1201 {
1202 	nWidth = nSz;
1203 	nProp = nPrp;
1204 }
1205 
1206 // -----------------------------------------------------------------------
1207 
Clone(SfxItemPool *) const1208 SfxPoolItem* SvxFontWidthItem::Clone( SfxItemPool * ) const
1209 {
1210 	return new SvxFontWidthItem( *this );
1211 }
1212 
1213 // -----------------------------------------------------------------------
1214 
Store(SvStream & rStrm,sal_uInt16) const1215 SvStream& SvxFontWidthItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1216 {
1217 	rStrm << GetWidth() << GetProp();
1218 	return rStrm;
1219 }
1220 
1221 // -----------------------------------------------------------------------
1222 
ScaleMetrics(long nMult,long nDiv)1223 int SvxFontWidthItem::ScaleMetrics( long nMult, long nDiv )
1224 {
1225 	nWidth = (sal_uInt16)Scale( nWidth, nMult, nDiv );
1226 	return 1;
1227 }
1228 
1229 // -----------------------------------------------------------------------
1230 
HasMetrics() const1231 int SvxFontWidthItem::HasMetrics() const
1232 {
1233 	return 1;
1234 }
1235 
1236 // -----------------------------------------------------------------------
1237 
Create(SvStream & rStrm,sal_uInt16) const1238 SfxPoolItem* SvxFontWidthItem::Create( SvStream& rStrm,
1239                                                  sal_uInt16 /*nVersion*/ ) const
1240 {
1241 	sal_uInt16 nS;
1242 	sal_uInt16 nP;
1243 
1244 	rStrm >> nS;
1245 	rStrm >> nP;
1246 	SvxFontWidthItem* pItem = new SvxFontWidthItem( 0, nP, Which() );
1247 	pItem->SetWidthValue( nS );
1248 	return pItem;
1249 }
1250 
1251 // -----------------------------------------------------------------------
1252 
operator ==(const SfxPoolItem & rItem) const1253 int SvxFontWidthItem::operator==( const SfxPoolItem& rItem ) const
1254 {
1255 	DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
1256 	return GetWidth() == ((SvxFontWidthItem&)rItem).GetWidth() &&
1257 			GetProp() == ((SvxFontWidthItem&)rItem).GetProp();
1258 }
1259 
1260 /*-----------------13.03.98 16:03-------------------
1261 
1262 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const1263 sal_Bool SvxFontWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1264 {
1265 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1266     nMemberId &= ~CONVERT_TWIPS;
1267 	switch(nMemberId)
1268 	{
1269 		case MID_FONTWIDTH:
1270 			rVal <<= (sal_Int16)(nWidth);
1271 		break;
1272 		case MID_FONTWIDTH_PROP:
1273 			rVal <<= (sal_Int16)(nProp);
1274 		break;
1275 	}
1276 	return sal_True;
1277 }
1278 /*-----------------13.03.98 16:03-------------------
1279 
1280 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)1281 sal_Bool SvxFontWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1282 {
1283 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1284     nMemberId &= ~CONVERT_TWIPS;
1285 	sal_Int16 nVal = sal_Int16();
1286 	if(!(rVal >>= nVal))
1287 		return sal_False;
1288 
1289 	switch(nMemberId)
1290 	{
1291 		case MID_FONTWIDTH:
1292 			nProp = nVal;
1293 		break;
1294 		case MID_FONTWIDTH_PROP:
1295 			nWidth = nVal;
1296 		break;
1297 	}
1298 	return sal_True;
1299 }
1300 
1301 //------------------------------------------------------------------------
1302 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit eCoreUnit,SfxMapUnit,XubString & rText,const IntlWrapper * pIntl) const1303 SfxItemPresentation SvxFontWidthItem::GetPresentation
1304 (
1305 	SfxItemPresentation ePres,
1306 	SfxMapUnit			eCoreUnit,
1307     SfxMapUnit          /*ePresUnit*/,
1308     XubString&          rText, const IntlWrapper *pIntl
1309 )	const
1310 {
1311 #ifndef SVX_LIGHT
1312 	switch ( ePres )
1313 	{
1314 		case SFX_ITEM_PRESENTATION_NONE:
1315 			rText.Erase();
1316 			return ePres;
1317 		case SFX_ITEM_PRESENTATION_NAMELESS:
1318 		case SFX_ITEM_PRESENTATION_COMPLETE:
1319 		{
1320 			if ( 100 == nProp )
1321 			{
1322 				rText = GetMetricText( (long)nWidth,
1323                                         eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
1324 				rText += sal_Unicode(' ');
1325 				rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
1326 			}
1327 			else
1328 				( rText = String::CreateFromInt32( nProp )) += sal_Unicode('%');
1329 			return ePres;
1330 		}
1331         default: ; //prevent warning
1332     }
1333 #endif
1334 	return SFX_ITEM_PRESENTATION_NONE;
1335 }
1336 
1337 // class SvxTextLineItem ------------------------------------------------
1338 
SvxTextLineItem(const FontUnderline eSt,const sal_uInt16 nId)1339 SvxTextLineItem::SvxTextLineItem( const FontUnderline eSt, const sal_uInt16 nId )
1340 	: SfxEnumItem( nId, (sal_uInt16)eSt ), mColor( COL_TRANSPARENT )
1341 {
1342 }
1343 
1344 // -----------------------------------------------------------------------
1345 
HasBoolValue() const1346 int SvxTextLineItem::HasBoolValue() const
1347 {
1348 	return sal_True;
1349 }
1350 
1351 // -----------------------------------------------------------------------
1352 
GetBoolValue() const1353 sal_Bool SvxTextLineItem::GetBoolValue() const
1354 {
1355 	return  (FontUnderline)GetValue() != UNDERLINE_NONE;
1356 }
1357 
1358 // -----------------------------------------------------------------------
1359 
SetBoolValue(sal_Bool bVal)1360 void SvxTextLineItem::SetBoolValue( sal_Bool bVal )
1361 {
1362 	SetValue( (sal_uInt16)(bVal ? UNDERLINE_SINGLE : UNDERLINE_NONE) );
1363 }
1364 
1365 // -----------------------------------------------------------------------
1366 
Clone(SfxItemPool *) const1367 SfxPoolItem* SvxTextLineItem::Clone( SfxItemPool * ) const
1368 {
1369 	SvxTextLineItem* pNew = new SvxTextLineItem( *this );
1370 	pNew->SetColor( GetColor() );
1371 	return pNew;
1372 }
1373 
1374 // -----------------------------------------------------------------------
1375 
GetValueCount() const1376 sal_uInt16 SvxTextLineItem::GetValueCount() const
1377 {
1378 	return UNDERLINE_DOTTED + 1;	// auch UNDERLINE_NONE geh"ort dazu
1379 }
1380 
1381 // -----------------------------------------------------------------------
1382 
Store(SvStream & rStrm,sal_uInt16) const1383 SvStream& SvxTextLineItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1384 {
1385 	rStrm << (sal_uInt8)GetValue();
1386 	return rStrm;
1387 }
1388 
1389 // -----------------------------------------------------------------------
1390 
Create(SvStream & rStrm,sal_uInt16) const1391 SfxPoolItem* SvxTextLineItem::Create(SvStream& rStrm, sal_uInt16) const
1392 {
1393 	sal_uInt8 nState;
1394 	rStrm >> nState;
1395 	return new SvxTextLineItem(  (FontUnderline)nState, Which() );
1396 }
1397 
1398 //------------------------------------------------------------------------
1399 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1400 SfxItemPresentation SvxTextLineItem::GetPresentation
1401 (
1402 	SfxItemPresentation ePres,
1403     SfxMapUnit          /*eCoreUnit*/,
1404     SfxMapUnit          /*ePresUnit*/,
1405     XubString&          rText, const IntlWrapper * /*pIntl*/
1406 )	const
1407 {
1408 #ifndef SVX_LIGHT
1409 	switch ( ePres )
1410 	{
1411 		case SFX_ITEM_PRESENTATION_NONE:
1412 			rText.Erase();
1413 			return ePres;
1414 		case SFX_ITEM_PRESENTATION_NAMELESS:
1415 		case SFX_ITEM_PRESENTATION_COMPLETE:
1416 			rText = GetValueTextByPos( GetValue() );
1417 			if( !mColor.GetTransparency() )
1418 				( rText += cpDelim ) += ::GetColorString( mColor );
1419 			return ePres;
1420         default: ; //prevent warning
1421     }
1422 #endif
1423 	return SFX_ITEM_PRESENTATION_NONE;
1424 }
1425 
1426 // -----------------------------------------------------------------------
1427 
GetValueTextByPos(sal_uInt16) const1428 XubString SvxTextLineItem::GetValueTextByPos( sal_uInt16 /*nPos*/ ) const
1429 {
1430 	DBG_ERROR("SvxTextLineItem::GetValueTextByPos: Pure virtual method");
1431 	return XubString();
1432 }
1433 
1434 /*-----------------13.03.98 16:25-------------------
1435 
1436 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const1437 sal_Bool SvxTextLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1438 {
1439 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1440     nMemberId &= ~CONVERT_TWIPS;
1441 	switch(nMemberId)
1442 	{
1443 	case MID_TEXTLINED:
1444 		rVal = Bool2Any(GetBoolValue());
1445 		break;
1446 	case MID_TL_STYLE:
1447 		rVal <<= (sal_Int16)(GetValue());
1448 		break;
1449 	case MID_TL_COLOR:
1450 		rVal <<= (sal_Int32)( mColor.GetColor() );
1451 		break;
1452 	case MID_TL_HASCOLOR:
1453 		rVal = Bool2Any( !mColor.GetTransparency() );
1454 		break;
1455 	}
1456 	return sal_True;
1457 
1458 }
1459 /*-----------------13.03.98 16:28-------------------
1460 
1461 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)1462 sal_Bool SvxTextLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1463 {
1464 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1465     nMemberId &= ~CONVERT_TWIPS;
1466 	sal_Bool bRet = sal_True;
1467 	switch(nMemberId)
1468 	{
1469 	case MID_TEXTLINED:
1470 		SetBoolValue(Any2Bool(rVal));
1471 	break;
1472 	case MID_TL_STYLE:
1473 	{
1474 		sal_Int32 nValue = 0;
1475 		if(!(rVal >>= nValue))
1476 			bRet = sal_False;
1477 		else
1478 			SetValue((sal_Int16)nValue);
1479 	}
1480 	break;
1481 	case MID_TL_COLOR:
1482 	{
1483 		sal_Int32 nCol = 0;
1484 		if( !( rVal >>= nCol ) )
1485 			bRet = sal_False;
1486 		else
1487 		{
1488 			// Keep transparence, because it contains the information
1489 			// whether the font color or the stored color should be used
1490 			sal_uInt8 nTrans = mColor.GetTransparency();
1491 			mColor = Color( nCol );
1492 			mColor.SetTransparency( nTrans );
1493 		}
1494 	}
1495 	break;
1496 	case MID_TL_HASCOLOR:
1497 		mColor.SetTransparency( Any2Bool( rVal ) ? 0 : 0xff );
1498 	break;
1499 	}
1500 	return bRet;
1501 }
1502 
operator ==(const SfxPoolItem & rItem) const1503 int SvxTextLineItem::operator==( const SfxPoolItem& rItem ) const
1504 {
1505 	DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
1506 	return SfxEnumItem::operator==( rItem ) &&
1507 		   GetColor() == ((SvxTextLineItem&)rItem).GetColor();
1508 }
1509 
1510 // class SvxUnderlineItem ------------------------------------------------
1511 
SvxUnderlineItem(const FontUnderline eSt,const sal_uInt16 nId)1512 SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const sal_uInt16 nId )
1513 	: SvxTextLineItem( eSt, nId )
1514 {
1515 }
1516 
1517 //------------------------------------------------------------------------
1518 
Clone(SfxItemPool *) const1519 SfxPoolItem* SvxUnderlineItem::Clone( SfxItemPool * ) const
1520 {
1521 	SvxUnderlineItem* pNew = new SvxUnderlineItem( *this );
1522 	pNew->SetColor( GetColor() );
1523 	return pNew;
1524 }
1525 
1526 // -----------------------------------------------------------------------
1527 
Create(SvStream & rStrm,sal_uInt16) const1528 SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, sal_uInt16) const
1529 {
1530 	sal_uInt8 nState;
1531 	rStrm >> nState;
1532 	return new SvxUnderlineItem(  (FontUnderline)nState, Which() );
1533 }
1534 
1535 // -----------------------------------------------------------------------
1536 
GetValueTextByPos(sal_uInt16 nPos) const1537 XubString SvxUnderlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
1538 {
1539 	DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
1540 	return EE_RESSTR( RID_SVXITEMS_UL_BEGIN + nPos );
1541 }
1542 
1543 // class SvxOverlineItem ------------------------------------------------
1544 
SvxOverlineItem(const FontUnderline eSt,const sal_uInt16 nId)1545 SvxOverlineItem::SvxOverlineItem( const FontUnderline eSt, const sal_uInt16 nId )
1546 	: SvxTextLineItem( eSt, nId )
1547 {
1548 }
1549 
1550 //------------------------------------------------------------------------
1551 
Clone(SfxItemPool *) const1552 SfxPoolItem* SvxOverlineItem::Clone( SfxItemPool * ) const
1553 {
1554 	SvxOverlineItem* pNew = new SvxOverlineItem( *this );
1555 	pNew->SetColor( GetColor() );
1556 	return pNew;
1557 }
1558 
1559 // -----------------------------------------------------------------------
1560 
Create(SvStream & rStrm,sal_uInt16) const1561 SfxPoolItem* SvxOverlineItem::Create(SvStream& rStrm, sal_uInt16) const
1562 {
1563 	sal_uInt8 nState;
1564 	rStrm >> nState;
1565 	return new SvxOverlineItem(  (FontUnderline)nState, Which() );
1566 }
1567 
1568 // -----------------------------------------------------------------------
1569 
GetValueTextByPos(sal_uInt16 nPos) const1570 XubString SvxOverlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
1571 {
1572 	DBG_ASSERT( nPos <= (sal_uInt16)UNDERLINE_BOLDWAVE, "enum overflow!" );
1573 	return EE_RESSTR( RID_SVXITEMS_OL_BEGIN + nPos );
1574 }
1575 
1576 // class SvxCrossedOutItem -----------------------------------------------
1577 
SvxCrossedOutItem(const FontStrikeout eSt,const sal_uInt16 nId)1578 SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const sal_uInt16 nId )
1579 	: SfxEnumItem( nId, (sal_uInt16)eSt )
1580 {
1581 }
1582 
1583 // -----------------------------------------------------------------------
1584 
HasBoolValue() const1585 int SvxCrossedOutItem::HasBoolValue() const
1586 {
1587 	return sal_True;
1588 }
1589 
1590 // -----------------------------------------------------------------------
1591 
GetBoolValue() const1592 sal_Bool SvxCrossedOutItem::GetBoolValue() const
1593 {
1594 	return (FontStrikeout)GetValue() != STRIKEOUT_NONE;
1595 }
1596 
1597 // -----------------------------------------------------------------------
1598 
SetBoolValue(sal_Bool bVal)1599 void SvxCrossedOutItem::SetBoolValue( sal_Bool bVal )
1600 {
1601 	SetValue( (sal_uInt16)(bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE) );
1602 }
1603 
1604 // -----------------------------------------------------------------------
1605 
GetValueCount() const1606 sal_uInt16 SvxCrossedOutItem::GetValueCount() const
1607 {
1608 	return STRIKEOUT_DOUBLE + 1;	// auch STRIKEOUT_NONE geh"ort dazu
1609 }
1610 
1611 // -----------------------------------------------------------------------
1612 
Clone(SfxItemPool *) const1613 SfxPoolItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const
1614 {
1615 	return new SvxCrossedOutItem( *this );
1616 }
1617 
1618 // -----------------------------------------------------------------------
1619 
Store(SvStream & rStrm,sal_uInt16) const1620 SvStream& SvxCrossedOutItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1621 {
1622 	rStrm << (sal_uInt8)GetValue();
1623 	return rStrm;
1624 }
1625 
1626 // -----------------------------------------------------------------------
1627 
Create(SvStream & rStrm,sal_uInt16) const1628 SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, sal_uInt16) const
1629 {
1630 	sal_uInt8 eCross;
1631 	rStrm >> eCross;
1632 	return new SvxCrossedOutItem(  (FontStrikeout)eCross, Which() );
1633 }
1634 
1635 //------------------------------------------------------------------------
1636 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1637 SfxItemPresentation SvxCrossedOutItem::GetPresentation
1638 (
1639 	SfxItemPresentation ePres,
1640     SfxMapUnit          /*eCoreUnit*/,
1641     SfxMapUnit          /*ePresUnit*/,
1642     XubString&          rText, const IntlWrapper * /*pIntl*/
1643 )	const
1644 {
1645 	switch ( ePres )
1646 	{
1647 		case SFX_ITEM_PRESENTATION_NONE:
1648 			rText.Erase();
1649 			return ePres;
1650 		case SFX_ITEM_PRESENTATION_NAMELESS:
1651 		case SFX_ITEM_PRESENTATION_COMPLETE:
1652 			rText = GetValueTextByPos( GetValue() );
1653 			return ePres;
1654         default: ;//prevent warning
1655     }
1656 	return SFX_ITEM_PRESENTATION_NONE;
1657 }
1658 
1659 // -----------------------------------------------------------------------
1660 
GetValueTextByPos(sal_uInt16 nPos) const1661 XubString SvxCrossedOutItem::GetValueTextByPos( sal_uInt16 nPos ) const
1662 {
1663 	DBG_ASSERT( nPos <= (sal_uInt16)STRIKEOUT_X, "enum overflow!" );
1664 	return EE_RESSTR( RID_SVXITEMS_STRIKEOUT_BEGIN + nPos );
1665 }
1666 
1667 /*-----------------13.03.98 16:28-------------------
1668 
1669 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const1670 sal_Bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1671 {
1672 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1673     nMemberId &= ~CONVERT_TWIPS;
1674 	switch(nMemberId)
1675 	{
1676 		case MID_CROSSED_OUT:
1677 			rVal = Bool2Any(GetBoolValue());
1678 		break;
1679 		case MID_CROSS_OUT:
1680 			rVal <<= (sal_Int16)(GetValue());
1681 		break;
1682 	}
1683 	return sal_True;
1684 }
1685 /*-----------------13.03.98 16:29-------------------
1686 
1687 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)1688 sal_Bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1689 {
1690 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1691     nMemberId &= ~CONVERT_TWIPS;
1692 	switch(nMemberId)
1693 	{
1694 		case MID_CROSSED_OUT:
1695 			SetBoolValue(Any2Bool(rVal));
1696 		break;
1697 		case MID_CROSS_OUT:
1698 		{
1699 			sal_Int32 nValue = 0;
1700 			if(!(rVal >>= nValue))
1701 				return sal_False;
1702 			SetValue((sal_Int16)nValue);
1703 		}
1704 		break;
1705 	}
1706 	return sal_True;
1707 }
1708 // class SvxShadowedItem -------------------------------------------------
1709 
SvxShadowedItem(const sal_Bool bShadowed,const sal_uInt16 nId)1710 SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const sal_uInt16 nId ) :
1711 	SfxBoolItem( nId, bShadowed )
1712 {
1713 }
1714 
1715 // -----------------------------------------------------------------------
1716 
Clone(SfxItemPool *) const1717 SfxPoolItem* SvxShadowedItem::Clone( SfxItemPool * ) const
1718 {
1719 	return new SvxShadowedItem( *this );
1720 }
1721 
1722 // -----------------------------------------------------------------------
1723 
Store(SvStream & rStrm,sal_uInt16) const1724 SvStream& SvxShadowedItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1725 {
1726 	rStrm << (sal_uInt8) GetValue();
1727 	return rStrm;
1728 }
1729 
1730 // -----------------------------------------------------------------------
1731 
Create(SvStream & rStrm,sal_uInt16) const1732 SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, sal_uInt16) const
1733 {
1734 	sal_uInt8 nState;
1735 	rStrm >> nState;
1736 	return new SvxShadowedItem( nState, Which() );
1737 }
1738 
1739 //------------------------------------------------------------------------
1740 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1741 SfxItemPresentation SvxShadowedItem::GetPresentation
1742 (
1743 	SfxItemPresentation ePres,
1744     SfxMapUnit          /*eCoreUnit*/,
1745     SfxMapUnit          /*ePresUnit*/,
1746     XubString&          rText, const IntlWrapper * /*pIntl*/
1747 )	const
1748 {
1749 	switch ( ePres )
1750 	{
1751 		case SFX_ITEM_PRESENTATION_NONE:
1752 			rText.Erase();
1753 			return ePres;
1754 		case SFX_ITEM_PRESENTATION_NAMELESS:
1755 		case SFX_ITEM_PRESENTATION_COMPLETE:
1756 		{
1757 			sal_uInt16 nId = RID_SVXITEMS_SHADOWED_FALSE;
1758 
1759 			if ( GetValue() )
1760 				nId = RID_SVXITEMS_SHADOWED_TRUE;
1761 			rText = EE_RESSTR(nId);
1762 			return ePres;
1763 		}
1764         default: ; //prevent warning
1765     }
1766 	return SFX_ITEM_PRESENTATION_NONE;
1767 }
1768 
1769 // class SvxAutoKernItem -------------------------------------------------
1770 
SvxAutoKernItem(const sal_Bool bAutoKern,const sal_uInt16 nId)1771 SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const sal_uInt16 nId ) :
1772 	SfxBoolItem( nId, bAutoKern )
1773 {
1774 }
1775 
1776 // -----------------------------------------------------------------------
1777 
Clone(SfxItemPool *) const1778 SfxPoolItem* SvxAutoKernItem::Clone( SfxItemPool * ) const
1779 {
1780 	return new SvxAutoKernItem( *this );
1781 }
1782 
1783 // -----------------------------------------------------------------------
1784 
Store(SvStream & rStrm,sal_uInt16) const1785 SvStream& SvxAutoKernItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1786 {
1787 	rStrm << (sal_uInt8) GetValue();
1788 	return rStrm;
1789 }
1790 
1791 // -----------------------------------------------------------------------
1792 
Create(SvStream & rStrm,sal_uInt16) const1793 SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, sal_uInt16) const
1794 {
1795 	sal_uInt8 nState;
1796 	rStrm >> nState;
1797 	return new SvxAutoKernItem( nState, Which() );
1798 }
1799 
1800 //------------------------------------------------------------------------
1801 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1802 SfxItemPresentation SvxAutoKernItem::GetPresentation
1803 (
1804 	SfxItemPresentation ePres,
1805     SfxMapUnit          /*eCoreUnit*/,
1806     SfxMapUnit          /*ePresUnit*/,
1807     XubString&          rText, const IntlWrapper * /*pIntl*/
1808 )	const
1809 {
1810 	switch ( ePres )
1811 	{
1812 		case SFX_ITEM_PRESENTATION_NONE:
1813 			rText.Erase();
1814 			return ePres;
1815 		case SFX_ITEM_PRESENTATION_NAMELESS:
1816 		case SFX_ITEM_PRESENTATION_COMPLETE:
1817 		{
1818 			sal_uInt16 nId = RID_SVXITEMS_AUTOKERN_FALSE;
1819 
1820 			if ( GetValue() )
1821 				nId = RID_SVXITEMS_AUTOKERN_TRUE;
1822 			rText = EE_RESSTR(nId);
1823 			return ePres;
1824 		}
1825         default: ; //prevent warning
1826     }
1827 	return SFX_ITEM_PRESENTATION_NONE;
1828 }
1829 
1830 // class SvxWordLineModeItem ---------------------------------------------
1831 
SvxWordLineModeItem(const sal_Bool bWordLineMode,const sal_uInt16 nId)1832 SvxWordLineModeItem::SvxWordLineModeItem( const sal_Bool bWordLineMode,
1833 										  const sal_uInt16 nId ) :
1834 	SfxBoolItem( nId, bWordLineMode )
1835 {
1836 }
1837 
1838 // -----------------------------------------------------------------------
1839 
Clone(SfxItemPool *) const1840 SfxPoolItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const
1841 {
1842 	return new SvxWordLineModeItem( *this );
1843 }
1844 
1845 // -----------------------------------------------------------------------
1846 
Store(SvStream & rStrm,sal_uInt16) const1847 SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1848 {
1849 	rStrm << (sal_Bool) GetValue();
1850 	return rStrm;
1851 }
1852 
1853 // -----------------------------------------------------------------------
1854 
Create(SvStream & rStrm,sal_uInt16) const1855 SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, sal_uInt16) const
1856 {
1857 	sal_Bool bValue;
1858 	rStrm >> bValue;
1859 	return new SvxWordLineModeItem( bValue, Which() );
1860 }
1861 
1862 //------------------------------------------------------------------------
1863 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1864 SfxItemPresentation SvxWordLineModeItem::GetPresentation
1865 (
1866 	SfxItemPresentation ePres,
1867     SfxMapUnit          /*eCoreUnit*/,
1868     SfxMapUnit          /*ePresUnit*/,
1869     XubString&          rText, const IntlWrapper * /*pIntl*/
1870 )	const
1871 {
1872 	switch ( ePres )
1873 	{
1874 		case SFX_ITEM_PRESENTATION_NONE:
1875 			rText.Erase();
1876 			return ePres;
1877 		case SFX_ITEM_PRESENTATION_NAMELESS:
1878 		case SFX_ITEM_PRESENTATION_COMPLETE:
1879 		{
1880 			sal_uInt16 nId = RID_SVXITEMS_WORDLINE_FALSE;
1881 
1882 			if ( GetValue() )
1883 				nId = RID_SVXITEMS_WORDLINE_TRUE;
1884 			rText = EE_RESSTR(nId);
1885 			return ePres;
1886 		}
1887         default: ; //prevent warning
1888     }
1889 	return SFX_ITEM_PRESENTATION_NONE;
1890 }
1891 
1892 // class SvxContourItem --------------------------------------------------
1893 
SvxContourItem(const sal_Bool bContoured,const sal_uInt16 nId)1894 SvxContourItem::SvxContourItem( const sal_Bool bContoured, const sal_uInt16 nId ) :
1895 	SfxBoolItem( nId, bContoured )
1896 {
1897 }
1898 
1899 // -----------------------------------------------------------------------
1900 
Clone(SfxItemPool *) const1901 SfxPoolItem* SvxContourItem::Clone( SfxItemPool * ) const
1902 {
1903 	return new SvxContourItem( *this );
1904 }
1905 
1906 // -----------------------------------------------------------------------
1907 
Store(SvStream & rStrm,sal_uInt16) const1908 SvStream& SvxContourItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1909 {
1910 	rStrm << (sal_Bool) GetValue();
1911 	return rStrm;
1912 }
1913 
1914 // -----------------------------------------------------------------------
1915 
Create(SvStream & rStrm,sal_uInt16) const1916 SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, sal_uInt16) const
1917 {
1918 	sal_Bool bValue;
1919 	rStrm >> bValue;
1920 	return new SvxContourItem( bValue, Which() );
1921 }
1922 
1923 //------------------------------------------------------------------------
1924 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1925 SfxItemPresentation SvxContourItem::GetPresentation
1926 (
1927 	SfxItemPresentation ePres,
1928     SfxMapUnit          /*eCoreUnit*/,
1929     SfxMapUnit          /*ePresUnit*/,
1930     XubString&          rText, const IntlWrapper * /*pIntl*/
1931 )	const
1932 {
1933 	switch ( ePres )
1934 	{
1935 		case SFX_ITEM_PRESENTATION_NONE:
1936 			rText.Erase();
1937 			return ePres;
1938 		case SFX_ITEM_PRESENTATION_NAMELESS:
1939 		case SFX_ITEM_PRESENTATION_COMPLETE:
1940 		{
1941 			sal_uInt16 nId = RID_SVXITEMS_CONTOUR_FALSE;
1942 
1943 			if ( GetValue() )
1944 				nId = RID_SVXITEMS_CONTOUR_TRUE;
1945 			rText = EE_RESSTR(nId);
1946 			return ePres;
1947 		}
1948         default: ; //prevent warning
1949     }
1950 	return SFX_ITEM_PRESENTATION_NONE;
1951 }
1952 
1953 // class SvxPropSizeItem -------------------------------------------------
1954 
SvxPropSizeItem(const sal_uInt16 nPercent,const sal_uInt16 nId)1955 SvxPropSizeItem::SvxPropSizeItem( const sal_uInt16 nPercent, const sal_uInt16 nId ) :
1956 	SfxUInt16Item( nId, nPercent )
1957 {
1958 }
1959 
1960 // -----------------------------------------------------------------------
1961 
Clone(SfxItemPool *) const1962 SfxPoolItem* SvxPropSizeItem::Clone( SfxItemPool * ) const
1963 {
1964 	return new SvxPropSizeItem( *this );
1965 }
1966 
1967 // -----------------------------------------------------------------------
1968 
Store(SvStream & rStrm,sal_uInt16) const1969 SvStream& SvxPropSizeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
1970 {
1971 	rStrm << (sal_uInt16) GetValue();
1972 	return rStrm;
1973 }
1974 
1975 // -----------------------------------------------------------------------
1976 
Create(SvStream & rStrm,sal_uInt16) const1977 SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, sal_uInt16) const
1978 {
1979 	sal_uInt16 nSize;
1980 	rStrm >> nSize;
1981 	return new SvxPropSizeItem( nSize, Which() );
1982 }
1983 
1984 //------------------------------------------------------------------------
1985 
GetPresentation(SfxItemPresentation,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const1986 SfxItemPresentation SvxPropSizeItem::GetPresentation
1987 (
1988     SfxItemPresentation /*ePres*/,
1989     SfxMapUnit          /*eCoreUnit*/,
1990     SfxMapUnit          /*ePresUnit*/,
1991     XubString&          rText, const IntlWrapper * /*pIntl*/
1992 )	const
1993 {
1994 	rText.Erase();
1995 	return SFX_ITEM_PRESENTATION_NONE;
1996 }
1997 
1998 // class SvxColorItem ----------------------------------------------------
1999 
SvxColorItem(const sal_uInt16 nId)2000 SvxColorItem::SvxColorItem( const sal_uInt16 nId ) :
2001 	SfxPoolItem( nId ),
2002 	mColor( COL_BLACK )
2003 {
2004 }
2005 
2006 // -----------------------------------------------------------------------
2007 
SvxColorItem(const Color & rCol,const sal_uInt16 nId)2008 SvxColorItem::SvxColorItem( const Color& rCol, const sal_uInt16 nId ) :
2009 	SfxPoolItem( nId ),
2010 	mColor( rCol )
2011 {
2012 }
2013 
2014 // -----------------------------------------------------------------------
2015 
SvxColorItem(SvStream & rStrm,const sal_uInt16 nId)2016 SvxColorItem::SvxColorItem( SvStream &rStrm, const sal_uInt16 nId ) :
2017 	SfxPoolItem( nId )
2018 {
2019 	Color aColor;
2020 	rStrm >> aColor;
2021 	mColor = aColor;
2022 }
2023 
2024 // -----------------------------------------------------------------------
2025 
SvxColorItem(const SvxColorItem & rCopy)2026 SvxColorItem::SvxColorItem( const SvxColorItem &rCopy ) :
2027 	SfxPoolItem( rCopy ),
2028 	mColor( rCopy.mColor )
2029 {
2030 }
2031 
2032 // -----------------------------------------------------------------------
2033 
~SvxColorItem()2034 SvxColorItem::~SvxColorItem()
2035 {
2036 }
2037 
2038 // -----------------------------------------------------------------------
GetVersion(sal_uInt16 nFFVer) const2039 sal_uInt16 SvxColorItem::GetVersion( sal_uInt16 nFFVer ) const
2040 {
2041 	DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
2042 			SOFFICE_FILEFORMAT_40==nFFVer ||
2043 			SOFFICE_FILEFORMAT_50==nFFVer,
2044 			"SvxColorItem: Gibt es ein neues Fileformat?" );
2045 	return  SOFFICE_FILEFORMAT_50 >= nFFVer ? VERSION_USEAUTOCOLOR : 0;
2046 }
2047 
2048 // -----------------------------------------------------------------------
2049 
operator ==(const SfxPoolItem & rAttr) const2050 int SvxColorItem::operator==( const SfxPoolItem& rAttr ) const
2051 {
2052 	DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
2053 
2054 	return	mColor == ( (const SvxColorItem&)rAttr ).mColor;
2055 }
2056 
2057 // -----------------------------------------------------------------------
2058 
QueryValue(uno::Any & rVal,sal_uInt8) const2059 sal_Bool SvxColorItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
2060 {
2061 	rVal <<= (sal_Int32)(mColor.GetColor());
2062 	return sal_True;
2063 }
2064 
2065 // -----------------------------------------------------------------------
2066 
PutValue(const uno::Any & rVal,sal_uInt8)2067 sal_Bool SvxColorItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
2068 {
2069 	sal_Int32 nColor = 0;
2070 	if(!(rVal >>= nColor))
2071 		return sal_False;
2072 
2073 	mColor.SetColor( nColor );
2074 	return sal_True;
2075 }
2076 
2077 // -----------------------------------------------------------------------
2078 
Clone(SfxItemPool *) const2079 SfxPoolItem* SvxColorItem::Clone( SfxItemPool * ) const
2080 {
2081 	return new SvxColorItem( *this );
2082 }
2083 
2084 // -----------------------------------------------------------------------
2085 
Store(SvStream & rStrm,sal_uInt16 nItemVersion) const2086 SvStream& SvxColorItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const
2087 {
2088 	if( VERSION_USEAUTOCOLOR == nItemVersion &&
2089 		COL_AUTO == mColor.GetColor() )
2090 		rStrm << Color( COL_BLACK );
2091 	else
2092 		rStrm << mColor;
2093 	return rStrm;
2094 }
2095 
2096 // -----------------------------------------------------------------------
2097 
Create(SvStream & rStrm,sal_uInt16) const2098 SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, sal_uInt16 /*nVer*/ ) const
2099 {
2100 	return new SvxColorItem( rStrm, Which() );
2101 }
2102 
2103 //------------------------------------------------------------------------
2104 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2105 SfxItemPresentation SvxColorItem::GetPresentation
2106 (
2107 	SfxItemPresentation ePres,
2108     SfxMapUnit          /*eCoreUnit*/,
2109     SfxMapUnit          /*ePresUnit*/,
2110     XubString&          rText, const IntlWrapper * /*pIntl*/
2111 )	const
2112 {
2113 #ifndef SVX_LIGHT
2114 	switch ( ePres )
2115 	{
2116 		case SFX_ITEM_PRESENTATION_NONE:
2117 			rText.Erase();
2118 			return ePres;
2119 		case SFX_ITEM_PRESENTATION_NAMELESS:
2120 		case SFX_ITEM_PRESENTATION_COMPLETE:
2121 			rText = ::GetColorString( mColor );
2122 			return ePres;
2123         default: ; //prevent warning
2124     }
2125 #endif
2126 	return SFX_ITEM_PRESENTATION_NONE;
2127 }
2128 
2129 // -----------------------------------------------------------------------
2130 
SetValue(const Color & rNewCol)2131 void SvxColorItem::SetValue( const Color& rNewCol )
2132 {
2133 	mColor = rNewCol;
2134 }
2135 
2136 // class SvxCharSetColorItem ---------------------------------------------
2137 
SvxCharSetColorItem(const sal_uInt16 nId)2138 SvxCharSetColorItem::SvxCharSetColorItem( const sal_uInt16 nId ) :
2139 	SvxColorItem( nId ),
2140 
2141 	eFrom( RTL_TEXTENCODING_DONTKNOW )
2142 {
2143 }
2144 
2145 // -----------------------------------------------------------------------
2146 
SvxCharSetColorItem(const Color & rCol,const rtl_TextEncoding _eFrom,const sal_uInt16 nId)2147 SvxCharSetColorItem::SvxCharSetColorItem( const Color& rCol,
2148                                           const rtl_TextEncoding _eFrom,
2149 										  const sal_uInt16 nId ) :
2150 	SvxColorItem( rCol, nId ),
2151 
2152     eFrom( _eFrom )
2153 {
2154 }
2155 
2156 
2157 // -----------------------------------------------------------------------
2158 
Clone(SfxItemPool *) const2159 SfxPoolItem* SvxCharSetColorItem::Clone( SfxItemPool * ) const
2160 {
2161 	return new SvxCharSetColorItem( *this );
2162 }
2163 
2164 // -----------------------------------------------------------------------
2165 
Store(SvStream & rStrm,sal_uInt16) const2166 SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2167 {
2168 	// #90477# rStrm << (sal_uInt8) GetStoreCharSet( GetCharSet(), (sal_uInt16)rStrm.GetVersion() )
2169 	//	  << GetValue();
2170 	rStrm << (sal_uInt8)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())
2171 		  << GetValue();
2172 	return rStrm;
2173 }
2174 
2175 // -----------------------------------------------------------------------
2176 
Create(SvStream & rStrm,sal_uInt16) const2177 SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, sal_uInt16) const
2178 {
2179 	sal_uInt8 cSet;
2180 	Color aColor;
2181 	rStrm >> cSet >> aColor;
2182 	return new SvxCharSetColorItem( aColor,  (rtl_TextEncoding)cSet, Which() );
2183 }
2184 
2185 //------------------------------------------------------------------------
2186 
GetPresentation(SfxItemPresentation,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2187 SfxItemPresentation SvxCharSetColorItem::GetPresentation
2188 (
2189     SfxItemPresentation /*ePres*/,
2190     SfxMapUnit          /*eCoreUnit*/,
2191     SfxMapUnit          /*ePresUnit*/,
2192     XubString&          rText, const IntlWrapper * /*pIntl*/
2193 )	const
2194 {
2195 	rText.Erase();
2196 	return SFX_ITEM_PRESENTATION_NONE;
2197 }
2198 
2199 // class SvxKerningItem --------------------------------------------------
2200 
SvxKerningItem(const short nKern,const sal_uInt16 nId)2201 SvxKerningItem::SvxKerningItem( const short nKern, const sal_uInt16 nId ) :
2202 	SfxInt16Item( nId, nKern )
2203 {
2204 }
2205 
2206 // -----------------------------------------------------------------------
2207 
Clone(SfxItemPool *) const2208 SfxPoolItem* SvxKerningItem::Clone( SfxItemPool * ) const
2209 {
2210 	return new SvxKerningItem( *this );
2211 }
2212 
2213 // -----------------------------------------------------------------------
2214 
Store(SvStream & rStrm,sal_uInt16) const2215 SvStream& SvxKerningItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2216 {
2217 	rStrm << (short) GetValue();
2218 	return rStrm;
2219 }
2220 
2221 // -----------------------------------------------------------------------
2222 
ScaleMetrics(long nMult,long nDiv)2223 int SvxKerningItem::ScaleMetrics( long nMult, long nDiv )
2224 {
2225 	SetValue( (sal_Int16)Scale( GetValue(), nMult, nDiv ) );
2226 	return 1;
2227 }
2228 
2229 // -----------------------------------------------------------------------
2230 
HasMetrics() const2231 int SvxKerningItem::HasMetrics() const
2232 {
2233 	return 1;
2234 }
2235 
2236 // -----------------------------------------------------------------------
2237 
Create(SvStream & rStrm,sal_uInt16) const2238 SfxPoolItem* SvxKerningItem::Create(SvStream& rStrm, sal_uInt16) const
2239 {
2240 	short nValue;
2241 	rStrm >> nValue;
2242 	return new SvxKerningItem( nValue, Which() );
2243 }
2244 
2245 //------------------------------------------------------------------------
2246 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit eCoreUnit,SfxMapUnit,XubString & rText,const IntlWrapper * pIntl) const2247 SfxItemPresentation SvxKerningItem::GetPresentation
2248 (
2249 	SfxItemPresentation ePres,
2250 	SfxMapUnit			eCoreUnit,
2251     SfxMapUnit          /*ePresUnit*/,
2252     XubString&          rText, const IntlWrapper *pIntl
2253 )	const
2254 {
2255 #ifndef SVX_LIGHT
2256 	switch ( ePres )
2257 	{
2258 		case SFX_ITEM_PRESENTATION_NONE:
2259 			rText.Erase();
2260 			return ePres;
2261 		case SFX_ITEM_PRESENTATION_NAMELESS:
2262             rText = GetMetricText( (long)GetValue(), eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
2263             rText += sal_Unicode(' ');
2264             rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
2265 			return ePres;
2266 		case SFX_ITEM_PRESENTATION_COMPLETE:
2267 		{
2268 			rText = EE_RESSTR(RID_SVXITEMS_KERNING_COMPLETE);
2269 			sal_uInt16 nId = 0;
2270 
2271 			if ( GetValue() > 0 )
2272 				nId = RID_SVXITEMS_KERNING_EXPANDED;
2273 			else if ( GetValue() < 0 )
2274 				nId = RID_SVXITEMS_KERNING_CONDENSED;
2275 
2276 			if ( nId )
2277 				rText += EE_RESSTR(nId);
2278             rText += GetMetricText( (long)GetValue(), eCoreUnit, SFX_MAPUNIT_POINT, pIntl );
2279             rText += sal_Unicode(' ');
2280             rText += EE_RESSTR(GetMetricId(SFX_MAPUNIT_POINT));
2281 			return ePres;
2282 		}
2283         default: ; //prevent warning
2284     }
2285 #endif
2286 	return SFX_ITEM_PRESENTATION_NONE;
2287 }
2288 /* -----------------------------19.02.01 12:21--------------------------------
2289 
2290  ---------------------------------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const2291 sal_Bool SvxKerningItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2292 {
2293 	sal_Int16 nVal = GetValue();
2294 	if(nMemberId & CONVERT_TWIPS)
2295 		nVal = (sal_Int16)TWIP_TO_MM100(nVal);
2296 	rVal <<= nVal;
2297 	return sal_True;
2298 }
2299 // -----------------------------------------------------------------------
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)2300 sal_Bool SvxKerningItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
2301 {
2302 	sal_Int16 nVal = sal_Int16();
2303 	if(!(rVal >>= nVal))
2304 		return sal_False;
2305 	if(nMemberId & CONVERT_TWIPS)
2306 		nVal = (sal_Int16)MM100_TO_TWIP(nVal);
2307 	SetValue(nVal);
2308 	return sal_True;
2309 }
2310 
2311 // class SvxCaseMapItem --------------------------------------------------
2312 
SvxCaseMapItem(const SvxCaseMap eMap,const sal_uInt16 nId)2313 SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const sal_uInt16 nId ) :
2314 	SfxEnumItem( nId, (sal_uInt16)eMap )
2315 {
2316 }
2317 
2318 // -----------------------------------------------------------------------
2319 
GetValueCount() const2320 sal_uInt16 SvxCaseMapItem::GetValueCount() const
2321 {
2322 	return SVX_CASEMAP_END;	// SVX_CASEMAP_KAPITAELCHEN	+ 1
2323 }
2324 
2325 // -----------------------------------------------------------------------
2326 
Clone(SfxItemPool *) const2327 SfxPoolItem* SvxCaseMapItem::Clone( SfxItemPool * ) const
2328 {
2329 	return new SvxCaseMapItem( *this );
2330 }
2331 
2332 // -----------------------------------------------------------------------
2333 
Store(SvStream & rStrm,sal_uInt16) const2334 SvStream& SvxCaseMapItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2335 {
2336 	rStrm << (sal_uInt8) GetValue();
2337 	return rStrm;
2338 }
2339 
2340 // -----------------------------------------------------------------------
2341 
Create(SvStream & rStrm,sal_uInt16) const2342 SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, sal_uInt16) const
2343 {
2344 	sal_uInt8 cMap;
2345 	rStrm >> cMap;
2346 	return new SvxCaseMapItem( (const SvxCaseMap)cMap, Which() );
2347 }
2348 
2349 //------------------------------------------------------------------------
2350 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2351 SfxItemPresentation SvxCaseMapItem::GetPresentation
2352 (
2353 	SfxItemPresentation ePres,
2354     SfxMapUnit          /*eCoreUnit*/,
2355     SfxMapUnit          /*ePresUnit*/,
2356     XubString&          rText, const IntlWrapper * /*pIntl*/
2357 )	const
2358 {
2359 	switch ( ePres )
2360 	{
2361 		case SFX_ITEM_PRESENTATION_NONE:
2362 			rText.Erase();
2363 			return ePres;
2364 		case SFX_ITEM_PRESENTATION_NAMELESS:
2365 		case SFX_ITEM_PRESENTATION_COMPLETE:
2366 			rText = GetValueTextByPos( GetValue() );
2367 			return ePres;
2368         default: ; //prevent warning
2369     }
2370 	return SFX_ITEM_PRESENTATION_NONE;
2371 }
2372 
2373 // -----------------------------------------------------------------------
2374 
GetValueTextByPos(sal_uInt16 nPos) const2375 XubString SvxCaseMapItem::GetValueTextByPos( sal_uInt16 nPos ) const
2376 {
2377 	DBG_ASSERT( nPos < (sal_uInt16)SVX_CASEMAP_END, "enum overflow!" );
2378 	return EE_RESSTR( RID_SVXITEMS_CASEMAP_BEGIN + nPos );
2379 }
2380 
2381 /*-----------------13.03.98 16:29-------------------
2382 
2383 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8) const2384 sal_Bool SvxCaseMapItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
2385 {
2386 	sal_Int16 nRet = style::CaseMap::NONE;
2387 	switch( GetValue() )
2388 	{
2389 //		case SVX_CASEMAP_NOT_MAPPED  :		nRet = style::CaseMap::NONE 	; break;
2390 		case SVX_CASEMAP_VERSALIEN   :      nRet = style::CaseMap::UPPERCASE; break;
2391 		case SVX_CASEMAP_GEMEINE     :      nRet = style::CaseMap::LOWERCASE; break;
2392 		case SVX_CASEMAP_TITEL       :      nRet = style::CaseMap::TITLE    ; break;
2393 		case SVX_CASEMAP_KAPITAELCHEN:      nRet = style::CaseMap::SMALLCAPS; break;
2394 	}
2395 	rVal <<= (sal_Int16)(nRet);
2396 	return sal_True;
2397 }
2398 /*-----------------13.03.98 16:29-------------------
2399 
2400 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8)2401 sal_Bool SvxCaseMapItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
2402 {
2403 	sal_uInt16 nVal = sal_uInt16();
2404 	if(!(rVal >>= nVal))
2405 		return sal_False;
2406 
2407 	switch( nVal )
2408 	{
2409 	case style::CaseMap::NONE 	 :  nVal = SVX_CASEMAP_NOT_MAPPED  ; break;
2410 	case style::CaseMap::UPPERCASE:  nVal = SVX_CASEMAP_VERSALIEN   ; break;
2411 	case style::CaseMap::LOWERCASE:  nVal = SVX_CASEMAP_GEMEINE     ; break;
2412 	case style::CaseMap::TITLE    :  nVal = SVX_CASEMAP_TITEL       ; break;
2413 	case style::CaseMap::SMALLCAPS:  nVal = SVX_CASEMAP_KAPITAELCHEN; break;
2414 	}
2415 	SetValue(nVal);
2416 	return sal_True;
2417 }
2418 
2419 // class SvxEscapementItem -----------------------------------------------
2420 
SvxEscapementItem(const sal_uInt16 nId)2421 SvxEscapementItem::SvxEscapementItem( const sal_uInt16 nId ) :
2422 	SfxEnumItemInterface( nId ),
2423 
2424 	nEsc	( 0 ),
2425 	nProp	( 100 )
2426 {
2427 }
2428 
2429 // -----------------------------------------------------------------------
2430 
SvxEscapementItem(const SvxEscapement eEscape,const sal_uInt16 nId)2431 SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
2432 									  const sal_uInt16 nId ) :
2433 	SfxEnumItemInterface( nId ),
2434 	nProp( 100 )
2435 {
2436 	SetEscapement( eEscape );
2437 	if( nEsc )
2438 		nProp = 58;
2439 }
2440 
2441 // -----------------------------------------------------------------------
2442 
SvxEscapementItem(const short _nEsc,const sal_uInt8 _nProp,const sal_uInt16 nId)2443 SvxEscapementItem::SvxEscapementItem( const short _nEsc,
2444                                       const sal_uInt8 _nProp,
2445 									  const sal_uInt16 nId ) :
2446 	SfxEnumItemInterface( nId ),
2447     nEsc    ( _nEsc ),
2448     nProp   ( _nProp )
2449 {
2450 }
2451 
2452 // -----------------------------------------------------------------------
2453 
operator ==(const SfxPoolItem & rAttr) const2454 int SvxEscapementItem::operator==( const SfxPoolItem& rAttr ) const
2455 {
2456 	DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
2457 
2458 	return( nEsc  == ((SvxEscapementItem&)rAttr).nEsc &&
2459 			nProp == ((SvxEscapementItem&)rAttr).nProp );
2460 }
2461 
2462 // -----------------------------------------------------------------------
2463 
Clone(SfxItemPool *) const2464 SfxPoolItem* SvxEscapementItem::Clone( SfxItemPool * ) const
2465 {
2466 	return new SvxEscapementItem( *this );
2467 }
2468 
2469 // -----------------------------------------------------------------------
2470 
Store(SvStream & rStrm,sal_uInt16) const2471 SvStream& SvxEscapementItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2472 {
2473     short _nEsc = GetEsc();
2474 	if( SOFFICE_FILEFORMAT_31 == rStrm.GetVersion() )
2475 	{
2476         if( DFLT_ESC_AUTO_SUPER == _nEsc )
2477             _nEsc = DFLT_ESC_SUPER;
2478         else if( DFLT_ESC_AUTO_SUB == _nEsc )
2479             _nEsc = DFLT_ESC_SUB;
2480 	}
2481 	rStrm << (sal_uInt8) GetProp()
2482           << (short) _nEsc;
2483 	return rStrm;
2484 }
2485 
2486 // -----------------------------------------------------------------------
2487 
Create(SvStream & rStrm,sal_uInt16) const2488 SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, sal_uInt16) const
2489 {
2490     sal_uInt8 _nProp;
2491     short _nEsc;
2492     rStrm >> _nProp >> _nEsc;
2493     return new SvxEscapementItem( _nEsc, _nProp, Which() );
2494 }
2495 
2496 // -----------------------------------------------------------------------
2497 
GetValueCount() const2498 sal_uInt16 SvxEscapementItem::GetValueCount() const
2499 {
2500 	return SVX_ESCAPEMENT_END;	// SVX_ESCAPEMENT_SUBSCRIPT + 1
2501 }
2502 
2503 //------------------------------------------------------------------------
2504 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2505 SfxItemPresentation SvxEscapementItem::GetPresentation
2506 (
2507 	SfxItemPresentation ePres,
2508     SfxMapUnit          /*eCoreUnit*/,
2509     SfxMapUnit          /*ePresUnit*/,
2510     XubString&          rText, const IntlWrapper * /*pIntl*/
2511 )	const
2512 {
2513 	switch ( ePres )
2514 	{
2515 		case SFX_ITEM_PRESENTATION_NONE:
2516 			rText.Erase();
2517 			return ePres;
2518 		case SFX_ITEM_PRESENTATION_NAMELESS:
2519 		case SFX_ITEM_PRESENTATION_COMPLETE:
2520 		{
2521 			rText = GetValueTextByPos( GetEnumValue() );
2522 
2523 			if ( nEsc != 0 )
2524 			{
2525 				if( DFLT_ESC_AUTO_SUPER == nEsc || DFLT_ESC_AUTO_SUB == nEsc )
2526 					rText += String( EE_RESSTR(RID_SVXITEMS_ESCAPEMENT_AUTO) );
2527 				else
2528 					( rText += String::CreateFromInt32( nEsc )) += sal_Unicode('%');
2529 			}
2530 			return ePres;
2531 		}
2532         default: ; //prevent warning
2533     }
2534 	return SFX_ITEM_PRESENTATION_NONE;
2535 }
2536 
2537 // -----------------------------------------------------------------------
2538 
GetValueTextByPos(sal_uInt16 nPos) const2539 XubString SvxEscapementItem::GetValueTextByPos( sal_uInt16 nPos ) const
2540 {
2541 	DBG_ASSERT( nPos < (sal_uInt16)SVX_ESCAPEMENT_END, "enum overflow!" );
2542 	return EE_RESSTR(RID_SVXITEMS_ESCAPEMENT_BEGIN + nPos);
2543 }
2544 
2545 // -----------------------------------------------------------------------
2546 
GetEnumValue() const2547 sal_uInt16 SvxEscapementItem::GetEnumValue() const
2548 {
2549 	if ( nEsc < 0 )
2550 		return SVX_ESCAPEMENT_SUBSCRIPT;
2551 	else if ( nEsc > 0 )
2552 		return SVX_ESCAPEMENT_SUPERSCRIPT;
2553 	return SVX_ESCAPEMENT_OFF;
2554 }
2555 
2556 // -----------------------------------------------------------------------
2557 
SetEnumValue(sal_uInt16 nVal)2558 void SvxEscapementItem::SetEnumValue( sal_uInt16 nVal )
2559 {
2560 	SetEscapement( (const SvxEscapement)nVal );
2561 }
2562 
2563 /*-----------------13.03.98 17:05-------------------
2564 
2565 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const2566 sal_Bool SvxEscapementItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2567 {
2568 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2569     nMemberId &= ~CONVERT_TWIPS;
2570 	switch(nMemberId)
2571 	{
2572 		case MID_ESC:
2573 			rVal <<= (sal_Int16)(nEsc);
2574 		break;
2575 		case MID_ESC_HEIGHT:
2576 			rVal <<= (sal_Int8)(nProp);
2577 		break;
2578 		case MID_AUTO_ESC:
2579 			rVal = Bool2Any(DFLT_ESC_AUTO_SUB == nEsc || DFLT_ESC_AUTO_SUPER == nEsc);
2580 		break;
2581 	}
2582 	return sal_True;
2583 }
2584 /*-----------------13.03.98 17:05-------------------
2585 
2586 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)2587 sal_Bool SvxEscapementItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2588 {
2589 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2590     nMemberId &= ~CONVERT_TWIPS;
2591 	switch(nMemberId)
2592 	{
2593 		case MID_ESC:
2594 		{
2595 			sal_Int16 nVal = sal_Int16();
2596 			if( (rVal >>= nVal) && (Abs(nVal) <= 101))
2597 				nEsc = nVal;
2598 			else
2599 				return sal_False;
2600 		}
2601 		break;
2602 		case MID_ESC_HEIGHT:
2603 		{
2604 			sal_Int8 nVal = sal_Int8();
2605 			if( (rVal >>= nVal) && (nVal <= 100))
2606 				nProp = nVal;
2607 			else
2608 				return sal_False;
2609 		}
2610 		break;
2611 		case MID_AUTO_ESC:
2612 		{
2613 			sal_Bool bVal = Any2Bool(rVal);
2614 			if(bVal)
2615 			{
2616 				if(nEsc < 0)
2617 					nEsc = DFLT_ESC_AUTO_SUB;
2618 				else
2619 					nEsc = DFLT_ESC_AUTO_SUPER;
2620 			}
2621 			else
2622 				if(DFLT_ESC_AUTO_SUPER == nEsc )
2623 					--nEsc;
2624 				else if(DFLT_ESC_AUTO_SUB == nEsc)
2625 					++nEsc;
2626 		}
2627 		break;
2628 	}
2629 	return sal_True;
2630 }
2631 
2632 // class SvxLanguageItem -------------------------------------------------
2633 
SvxLanguageItem(const LanguageType eLang,const sal_uInt16 nId)2634 SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const sal_uInt16 nId )
2635 	: SfxEnumItem( nId , eLang )
2636 {
2637 }
2638 
2639 // -----------------------------------------------------------------------
2640 
GetValueCount() const2641 sal_uInt16 SvxLanguageItem::GetValueCount() const
2642 {
2643     // #i50205# got rid of class International
2644     DBG_ERRORFILE("SvxLanguageItem::GetValueCount: supposed to return a count of what?");
2645     // FIXME: previously returned LANGUAGE_COUNT from tools/intn.hxx which was wrong anyway.
2646     // Could be SvtLanguageTable::GetEntryCount() (all locales with resource string)?
2647     // Could be LocaleDataWrapper::getInstalledLanguageTypes() (all locales with locale data)?
2648 	return 0;
2649 }
2650 
2651 // -----------------------------------------------------------------------
2652 
Clone(SfxItemPool *) const2653 SfxPoolItem* SvxLanguageItem::Clone( SfxItemPool * ) const
2654 {
2655 	return new SvxLanguageItem( *this );
2656 }
2657 
2658 // -----------------------------------------------------------------------
2659 
Store(SvStream & rStrm,sal_uInt16) const2660 SvStream& SvxLanguageItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2661 {
2662 	rStrm << (sal_uInt16) GetValue();
2663 	return rStrm;
2664 }
2665 
2666 // -----------------------------------------------------------------------
2667 
Create(SvStream & rStrm,sal_uInt16) const2668 SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, sal_uInt16) const
2669 {
2670 	sal_uInt16 nValue;
2671 	rStrm >> nValue;
2672 	return new SvxLanguageItem( (LanguageType)nValue, Which() );
2673 }
2674 
2675 //------------------------------------------------------------------------
2676 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2677 SfxItemPresentation SvxLanguageItem::GetPresentation
2678 (
2679 	SfxItemPresentation ePres,
2680     SfxMapUnit          /*eCoreUnit*/,
2681     SfxMapUnit          /*ePresUnit*/,
2682     XubString&          rText, const IntlWrapper * /*pIntl*/
2683 )	const
2684 {
2685 #ifndef SVX_LIGHT
2686 	switch ( ePres )
2687 	{
2688 		case SFX_ITEM_PRESENTATION_NONE:
2689 			rText.Erase();
2690 			return ePres;
2691 		case SFX_ITEM_PRESENTATION_NAMELESS:
2692 		case SFX_ITEM_PRESENTATION_COMPLETE:
2693 		{
2694             SvtLanguageTable aLangTable;
2695 			rText = aLangTable.GetString( (LanguageType)GetValue() );
2696 			return ePres;
2697 		}
2698         default: ; //prevent warning
2699     }
2700 #endif // !SVX_LIGHT
2701 	return SFX_ITEM_PRESENTATION_NONE;
2702 }
2703 
2704 /*-----------------14.03.98 14:13-------------------
2705 
2706 --------------------------------------------------*/
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const2707 sal_Bool SvxLanguageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2708 {
2709 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2710     nMemberId &= ~CONVERT_TWIPS;
2711 	switch(nMemberId)
2712 	{
2713         case MID_LANG_INT:  // for basic conversions!
2714 			rVal <<= (sal_Int16)(GetValue());
2715 		break;
2716 		case MID_LANG_LOCALE:
2717 			lang::Locale aRet( MsLangId::convertLanguageToLocale( GetValue(), false));
2718 			rVal <<= aRet;
2719 		break;
2720 	}
2721 	return sal_True;
2722 }
2723 /*-----------------14.03.98 14:13-------------------
2724 
2725 --------------------------------------------------*/
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)2726 sal_Bool SvxLanguageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2727 {
2728 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2729     nMemberId &= ~CONVERT_TWIPS;
2730 	switch(nMemberId)
2731 	{
2732         case MID_LANG_INT:  // for basic conversions!
2733 		{
2734 			sal_Int32 nValue = 0;
2735 			if(!(rVal >>= nValue))
2736 				return sal_False;
2737 
2738 			SetValue((sal_Int16)nValue);
2739 		}
2740 		break;
2741 		case MID_LANG_LOCALE:
2742 		{
2743 			lang::Locale aLocale;
2744 			if(!(rVal >>= aLocale))
2745 				return sal_False;
2746 
2747             if (aLocale.Language.getLength() || aLocale.Country.getLength())
2748                 SetValue(MsLangId::convertLocaleToLanguage( aLocale ));
2749             else
2750                 SetValue(LANGUAGE_NONE);
2751 		}
2752 		break;
2753 	}
2754 	return sal_True;
2755 }
2756 
2757 // class SvxNoLinebreakItem ----------------------------------------------
SvxNoLinebreakItem(const sal_Bool bBreak,const sal_uInt16 nId)2758 SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const sal_uInt16 nId ) :
2759       SfxBoolItem( nId, bBreak )
2760 {
2761 }
2762 
2763 // -----------------------------------------------------------------------
2764 
Clone(SfxItemPool *) const2765 SfxPoolItem* SvxNoLinebreakItem::Clone( SfxItemPool* ) const
2766 {
2767 	return new SvxNoLinebreakItem( *this );
2768 }
2769 
2770 // -----------------------------------------------------------------------
2771 
Store(SvStream & rStrm,sal_uInt16) const2772 SvStream& SvxNoLinebreakItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2773 {
2774 	rStrm << (sal_Bool)GetValue();
2775 	return rStrm;
2776 }
2777 
2778 // -----------------------------------------------------------------------
2779 
Create(SvStream & rStrm,sal_uInt16) const2780 SfxPoolItem* SvxNoLinebreakItem::Create(SvStream& rStrm, sal_uInt16) const
2781 {
2782 	sal_Bool bValue;
2783 	rStrm >> bValue;
2784 	return new SvxNoLinebreakItem( bValue, Which() );
2785 }
2786 
2787 //------------------------------------------------------------------------
2788 
GetPresentation(SfxItemPresentation,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2789 SfxItemPresentation SvxNoLinebreakItem::GetPresentation
2790 (
2791     SfxItemPresentation /*ePres*/,
2792     SfxMapUnit          /*eCoreUnit*/,
2793     SfxMapUnit          /*ePresUnit*/,
2794     XubString&          rText, const IntlWrapper * /*pIntl*/
2795 )	const
2796 {
2797 	rText.Erase();
2798 	return SFX_ITEM_PRESENTATION_NONE;
2799 }
2800 
2801 // class SvxNoHyphenItem -------------------------------------------------
2802 
SvxNoHyphenItem(const sal_Bool bHyphen,const sal_uInt16 nId)2803 SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const sal_uInt16 nId ) :
2804 	SfxBoolItem( nId , bHyphen )
2805 {
2806 }
2807 
2808 // -----------------------------------------------------------------------
2809 
Clone(SfxItemPool *) const2810 SfxPoolItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const
2811 {
2812 	return new SvxNoHyphenItem( *this );
2813 }
2814 
2815 // -----------------------------------------------------------------------
2816 
Store(SvStream & rStrm,sal_uInt16) const2817 SvStream& SvxNoHyphenItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2818 {
2819 	rStrm << (sal_Bool) GetValue();
2820 	return rStrm;
2821 }
2822 
2823 // -----------------------------------------------------------------------
2824 
Create(SvStream & rStrm,sal_uInt16) const2825 SfxPoolItem* SvxNoHyphenItem::Create( SvStream& rStrm, sal_uInt16 ) const
2826 {
2827 	sal_Bool bValue;
2828 	rStrm >> bValue;
2829 	return new SvxNoHyphenItem( bValue, Which() );
2830 }
2831 
2832 //------------------------------------------------------------------------
2833 
GetPresentation(SfxItemPresentation,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2834 SfxItemPresentation SvxNoHyphenItem::GetPresentation
2835 (
2836     SfxItemPresentation /*ePres*/,
2837     SfxMapUnit          /*eCoreUnit*/,
2838     SfxMapUnit          /*ePresUnit*/,
2839     XubString&          rText, const IntlWrapper * /*pIntl*/
2840 )	const
2841 {
2842 	rText.Erase();
2843 	return SFX_ITEM_PRESENTATION_NONE;
2844 }
2845 
2846 /*
2847  * Dummy-Item fuer ToolBox-Controls:
2848  *
2849  */
2850 
2851 // -----------------------------------------------------------------------
2852 // class SvxLineColorItem (== SvxColorItem)
2853 // -----------------------------------------------------------------------
2854 
SvxLineColorItem(const sal_uInt16 nId)2855 SvxLineColorItem::SvxLineColorItem( const sal_uInt16 nId ) :
2856 	SvxColorItem( nId )
2857 {
2858 }
2859 
2860 // -----------------------------------------------------------------------
2861 
SvxLineColorItem(const Color & rCol,const sal_uInt16 nId)2862 SvxLineColorItem::SvxLineColorItem( const Color& rCol, const sal_uInt16 nId ) :
2863 	SvxColorItem( rCol, nId )
2864 {
2865 }
2866 
2867 // -----------------------------------------------------------------------
2868 
SvxLineColorItem(SvStream & rStrm,const sal_uInt16 nId)2869 SvxLineColorItem::SvxLineColorItem( SvStream &rStrm, const sal_uInt16 nId ) :
2870 	SvxColorItem( rStrm, nId )
2871 {
2872 }
2873 
2874 // -----------------------------------------------------------------------
2875 
SvxLineColorItem(const SvxLineColorItem & rCopy)2876 SvxLineColorItem::SvxLineColorItem( const SvxLineColorItem &rCopy ) :
2877 	SvxColorItem( rCopy )
2878 {
2879 }
2880 
2881 // -----------------------------------------------------------------------
2882 
~SvxLineColorItem()2883 SvxLineColorItem::~SvxLineColorItem()
2884 {
2885 }
2886 
2887 //------------------------------------------------------------------------
2888 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit eCoreUnit,SfxMapUnit ePresUnit,XubString & rText,const IntlWrapper * pIntlWrapper) const2889 SfxItemPresentation SvxLineColorItem::GetPresentation
2890 (
2891 	SfxItemPresentation ePres,
2892     SfxMapUnit          eCoreUnit,
2893     SfxMapUnit          ePresUnit,
2894 	XubString& 			rText,
2895     const IntlWrapper * pIntlWrapper
2896 )	const
2897 {
2898 	return SvxColorItem::GetPresentation( ePres, eCoreUnit, ePresUnit,
2899                                           rText, pIntlWrapper );
2900 }
2901 
2902 // class SvxBlinkItem -------------------------------------------------
2903 
2904 
SvxBlinkItem(const sal_Bool bBlink,const sal_uInt16 nId)2905 SvxBlinkItem::SvxBlinkItem( const sal_Bool bBlink, const sal_uInt16 nId ) :
2906 	SfxBoolItem( nId, bBlink )
2907 {
2908 }
2909 
2910 // -----------------------------------------------------------------------
2911 
Clone(SfxItemPool *) const2912 SfxPoolItem* SvxBlinkItem::Clone( SfxItemPool * ) const
2913 {
2914 	return new SvxBlinkItem( *this );
2915 }
2916 
2917 // -----------------------------------------------------------------------
2918 
Store(SvStream & rStrm,sal_uInt16) const2919 SvStream& SvxBlinkItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const
2920 {
2921 	rStrm << (sal_uInt8) GetValue();
2922 	return rStrm;
2923 }
2924 
2925 // -----------------------------------------------------------------------
2926 
Create(SvStream & rStrm,sal_uInt16) const2927 SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, sal_uInt16) const
2928 {
2929 	sal_uInt8 nState;
2930 	rStrm >> nState;
2931 	return new SvxBlinkItem( nState, Which() );
2932 }
2933 
2934 // -----------------------------------------------------------------------
2935 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2936 SfxItemPresentation SvxBlinkItem::GetPresentation
2937 (
2938 	SfxItemPresentation ePres,
2939     SfxMapUnit          /*eCoreUnit*/,
2940     SfxMapUnit          /*ePresUnit*/,
2941     XubString&          rText, const IntlWrapper * /*pIntl*/
2942 )	const
2943 {
2944 	switch ( ePres )
2945 	{
2946 		case SFX_ITEM_PRESENTATION_NONE:
2947 			rText.Erase();
2948 			return ePres;
2949 		case SFX_ITEM_PRESENTATION_NAMELESS:
2950 		case SFX_ITEM_PRESENTATION_COMPLETE:
2951 		{
2952 			sal_uInt16 nId = RID_SVXITEMS_BLINK_FALSE;
2953 
2954 			if ( GetValue() )
2955 				nId = RID_SVXITEMS_BLINK_TRUE;
2956 			rText = EE_RESSTR(nId);
2957 			return ePres;
2958 		}
2959         default: ; //prevent warning
2960     }
2961 	return SFX_ITEM_PRESENTATION_NONE;
2962 }
2963 
2964 // class SvxEmphaisMarkItem ---------------------------------------------------
2965 
SvxEmphasisMarkItem(const FontEmphasisMark nValue,const sal_uInt16 nId)2966 SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue,
2967 										const sal_uInt16 nId )
2968 	: SfxUInt16Item( nId, nValue )
2969 {
2970 }
2971 
2972 // -----------------------------------------------------------------------
2973 
Clone(SfxItemPool *) const2974 SfxPoolItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const
2975 {
2976 	return new SvxEmphasisMarkItem( *this );
2977 }
2978 
2979 // -----------------------------------------------------------------------
2980 
Store(SvStream & rStrm,sal_uInt16) const2981 SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm,
2982                                      sal_uInt16 /*nItemVersion*/ ) const
2983 {
2984 	rStrm << (sal_uInt16)GetValue();
2985 	return rStrm;
2986 }
2987 
2988 // -----------------------------------------------------------------------
2989 
Create(SvStream & rStrm,sal_uInt16) const2990 SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, sal_uInt16 ) const
2991 {
2992 	sal_uInt16 nValue;
2993 	rStrm >> nValue;
2994 	return new SvxEmphasisMarkItem( (FontEmphasisMark)nValue, Which() );
2995 }
2996 
2997 //------------------------------------------------------------------------
2998 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const2999 SfxItemPresentation SvxEmphasisMarkItem::GetPresentation
3000 (
3001 	SfxItemPresentation ePres,
3002     SfxMapUnit          /*eCoreUnit*/,
3003     SfxMapUnit          /*ePresUnit*/,
3004 	XubString& 			rText,
3005     const IntlWrapper * /*pIntl*/
3006 )	const
3007 {
3008 	switch ( ePres )
3009 	{
3010 		case SFX_ITEM_PRESENTATION_NONE:
3011 			rText.Erase();
3012 			return ePres;
3013 		case SFX_ITEM_PRESENTATION_NAMELESS:
3014 		case SFX_ITEM_PRESENTATION_COMPLETE:
3015 			{
3016 				sal_uInt16 nVal = GetValue();
3017 		    	rText = EE_RESSTR( RID_SVXITEMS_EMPHASIS_BEGIN_STYLE +
3018 										( EMPHASISMARK_STYLE & nVal ));
3019 				sal_uInt16 nId = ( EMPHASISMARK_POS_ABOVE & nVal )
3020 								? RID_SVXITEMS_EMPHASIS_ABOVE_POS
3021 								: ( EMPHASISMARK_POS_BELOW & nVal )
3022 									? RID_SVXITEMS_EMPHASIS_BELOW_POS
3023 									: 0;
3024 				if( nId )
3025 					rText += EE_RESSTR( nId );
3026 				return ePres;
3027 			}
3028         default: ; //prevent warning
3029     }
3030 	return SFX_ITEM_PRESENTATION_NONE;
3031 }
3032 
3033 // -----------------------------------------------------------------------
3034 
QueryValue(uno::Any & rVal,sal_uInt8 nMemberId) const3035 sal_Bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
3036 {
3037 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3038     nMemberId &= ~CONVERT_TWIPS;
3039 	switch( nMemberId )
3040 	{
3041 	case MID_EMPHASIS:
3042 	{
3043 		sal_Int16 nValue = GetValue();
3044 		sal_Int16 nRet = 0;
3045 		switch(nValue & EMPHASISMARK_STYLE)
3046 		{
3047 			case EMPHASISMARK_NONE   : nRet = FontEmphasis::NONE;			break;
3048 			case EMPHASISMARK_DOT	 : nRet = FontEmphasis::DOT_ABOVE;		break;
3049 			case EMPHASISMARK_CIRCLE : nRet = FontEmphasis::CIRCLE_ABOVE;	break;
3050 			case EMPHASISMARK_DISC	 : nRet = FontEmphasis::DISK_ABOVE;		break;
3051 			case EMPHASISMARK_ACCENT : nRet = FontEmphasis::ACCENT_ABOVE;	break;
3052 		}
3053 		if(nRet && nValue & EMPHASISMARK_POS_BELOW)
3054 			nRet += 10;
3055 		rVal <<= nRet;
3056 	}
3057 	break;
3058 	}
3059 	return sal_True;
3060 }
3061 
PutValue(const uno::Any & rVal,sal_uInt8 nMemberId)3062 sal_Bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
3063 {
3064 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3065     nMemberId &= ~CONVERT_TWIPS;
3066 	sal_Bool bRet = sal_True;
3067 	switch( nMemberId )
3068 	{
3069 	case MID_EMPHASIS:
3070 	{
3071 		sal_Int32 nValue = -1;
3072 		rVal >>= nValue;
3073 		switch(nValue)
3074 		{
3075 			case FontEmphasis::NONE 	   : nValue = EMPHASISMARK_NONE;   break;
3076 			case FontEmphasis::DOT_ABOVE   : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_ABOVE;    break;
3077 			case FontEmphasis::CIRCLE_ABOVE: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_ABOVE; break;
3078 			case FontEmphasis::DISK_ABOVE  : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_ABOVE;   break;
3079 			case FontEmphasis::ACCENT_ABOVE: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_ABOVE; break;
3080 			case FontEmphasis::DOT_BELOW   : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_BELOW;    break;
3081 			case FontEmphasis::CIRCLE_BELOW: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_BELOW; break;
3082 			case FontEmphasis::DISK_BELOW  : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_BELOW;   break;
3083 			case FontEmphasis::ACCENT_BELOW: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_BELOW; break;
3084 			default: return sal_False;
3085 		}
3086 		SetValue( (sal_Int16)nValue );
3087 	}
3088 	break;
3089 	}
3090 	return bRet;
3091 }
3092 
GetVersion(sal_uInt16 nFFVer) const3093 sal_uInt16 SvxEmphasisMarkItem::GetVersion( sal_uInt16 nFFVer ) const
3094 {
3095 	DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
3096 			SOFFICE_FILEFORMAT_40==nFFVer ||
3097 			SOFFICE_FILEFORMAT_50==nFFVer,
3098 			"SvxEmphasisMarkItem: Gibt es ein neues Fileformat?" );
3099 
3100 	return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
3101 }
3102 
3103 
3104 /*************************************************************************
3105 |*    class SvxTwoLinesItem
3106 *************************************************************************/
3107 
SvxTwoLinesItem(sal_Bool bFlag,sal_Unicode nStartBracket,sal_Unicode nEndBracket,sal_uInt16 nW)3108 SvxTwoLinesItem::SvxTwoLinesItem( sal_Bool bFlag, sal_Unicode nStartBracket,
3109 									sal_Unicode nEndBracket, sal_uInt16 nW )
3110 	: SfxPoolItem( nW ),
3111     cStartBracket( nStartBracket ), cEndBracket( nEndBracket ), bOn( bFlag )
3112 {
3113 }
3114 
SvxTwoLinesItem(const SvxTwoLinesItem & rAttr)3115 SvxTwoLinesItem::SvxTwoLinesItem( const SvxTwoLinesItem& rAttr )
3116 	: SfxPoolItem( rAttr.Which() ),
3117     cStartBracket( rAttr.cStartBracket ),
3118     cEndBracket( rAttr.cEndBracket ),
3119     bOn( rAttr.bOn )
3120 {
3121 }
3122 
~SvxTwoLinesItem()3123 SvxTwoLinesItem::~SvxTwoLinesItem()
3124 {
3125 }
3126 
operator ==(const SfxPoolItem & rAttr) const3127 int SvxTwoLinesItem::operator==( const SfxPoolItem& rAttr ) const
3128 {
3129 	DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "not equal attribute types" );
3130 	return bOn == ((SvxTwoLinesItem&)rAttr).bOn &&
3131 		   cStartBracket == ((SvxTwoLinesItem&)rAttr).cStartBracket &&
3132 		   cEndBracket == ((SvxTwoLinesItem&)rAttr).cEndBracket;
3133 }
3134 
Clone(SfxItemPool *) const3135 SfxPoolItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const
3136 {
3137 	return new SvxTwoLinesItem( *this );
3138 }
3139 
QueryValue(com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId) const3140 sal_Bool SvxTwoLinesItem::QueryValue( com::sun::star::uno::Any& rVal,
3141 								sal_uInt8 nMemberId ) const
3142 {
3143 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3144     nMemberId &= ~CONVERT_TWIPS;
3145 	sal_Bool bRet = sal_True;
3146 	switch( nMemberId )
3147 	{
3148 	case MID_TWOLINES:
3149 		rVal = Bool2Any( bOn );
3150 		break;
3151 	case MID_START_BRACKET:
3152 		{
3153 			OUString s;
3154 			if( cStartBracket )
3155 				s = OUString( cStartBracket );
3156 			rVal <<= s;
3157 		}
3158 		break;
3159 	case MID_END_BRACKET:
3160 		{
3161 			OUString s;
3162 			if( cEndBracket )
3163 				s = OUString( cEndBracket );
3164 			rVal <<= s;
3165 		}
3166 		break;
3167 	default:
3168 		bRet = sal_False;
3169 		break;
3170 	}
3171 	return bRet;
3172 }
3173 
PutValue(const com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId)3174 sal_Bool SvxTwoLinesItem::PutValue( const com::sun::star::uno::Any& rVal,
3175 									sal_uInt8 nMemberId )
3176 {
3177 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3178     nMemberId &= ~CONVERT_TWIPS;
3179 	sal_Bool bRet = sal_False;
3180 	OUString s;
3181 	switch( nMemberId )
3182 	{
3183 	case MID_TWOLINES:
3184 		bOn = Any2Bool( rVal );
3185 		bRet = sal_True;
3186 		break;
3187 	case MID_START_BRACKET:
3188 		if( rVal >>= s )
3189 		{
3190 			cStartBracket = s.getLength() ? s[ 0 ] : 0;
3191 			bRet = sal_True;
3192 		}
3193 		break;
3194 	case MID_END_BRACKET:
3195 		if( rVal >>= s )
3196 		{
3197 			cEndBracket = s.getLength() ? s[ 0 ] : 0;
3198 			bRet = sal_True;
3199 		}
3200 		break;
3201 	}
3202 	return bRet;
3203 }
3204 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,String & rText,const IntlWrapper *) const3205 SfxItemPresentation SvxTwoLinesItem::GetPresentation( SfxItemPresentation ePres,
3206                             SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
3207                             String &rText, const IntlWrapper* /*pIntl*/ ) const
3208 {
3209 	switch( ePres )
3210 	{
3211 	case SFX_ITEM_PRESENTATION_NONE:
3212 		rText.Erase();
3213 		break;
3214 	case SFX_ITEM_PRESENTATION_NAMELESS:
3215 	case SFX_ITEM_PRESENTATION_COMPLETE:
3216 		{
3217 			if( !GetValue() )
3218 				rText = EE_RESSTR( RID_SVXITEMS_TWOLINES_OFF );
3219 			else
3220 			{
3221 				rText = EE_RESSTR( RID_SVXITEMS_TWOLINES );
3222 				if( GetStartBracket() )
3223 					rText.Insert( GetStartBracket(), 0 );
3224 				if( GetEndBracket() )
3225 					rText += GetEndBracket();
3226 			}
3227 			return ePres;
3228 		}
3229         default: ; //prevent warning
3230     }
3231 	return SFX_ITEM_PRESENTATION_NONE;
3232 }
3233 
3234 
Create(SvStream & rStrm,sal_uInt16) const3235 SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, sal_uInt16 /*nVer*/) const
3236 {
3237     sal_Bool _bOn;
3238 	sal_Unicode cStart, cEnd;
3239     rStrm >> _bOn >> cStart >> cEnd;
3240     return new SvxTwoLinesItem( _bOn, cStart, cEnd, Which() );
3241 }
3242 
Store(SvStream & rStrm,sal_uInt16) const3243 SvStream& SvxTwoLinesItem::Store(SvStream & rStrm, sal_uInt16 /*nIVer*/) const
3244 {
3245 	rStrm << GetValue() << GetStartBracket() << GetEndBracket();
3246 	return rStrm;
3247 }
3248 
GetVersion(sal_uInt16 nFFVer) const3249 sal_uInt16 SvxTwoLinesItem::GetVersion( sal_uInt16 nFFVer ) const
3250 {
3251 	DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer ||
3252 			SOFFICE_FILEFORMAT_40==nFFVer ||
3253 			SOFFICE_FILEFORMAT_50==nFFVer,
3254 			"SvxTwoLinesItem: Gibt es ein neues Fileformat?" );
3255 
3256 	return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
3257 }
3258 
3259 
3260 /*************************************************************************
3261 |*    class SvxCharRotateItem
3262 *************************************************************************/
3263 
SvxCharRotateItem(sal_uInt16 nValue,sal_Bool bFitIntoLine,const sal_uInt16 nW)3264 SvxCharRotateItem::SvxCharRotateItem( sal_uInt16 nValue,
3265 					   				sal_Bool bFitIntoLine,
3266 					   				const sal_uInt16 nW )
3267 	: SfxUInt16Item( nW, nValue ), bFitToLine( bFitIntoLine )
3268 {
3269 }
3270 
Clone(SfxItemPool *) const3271 SfxPoolItem* SvxCharRotateItem::Clone( SfxItemPool* ) const
3272 {
3273 	return new SvxCharRotateItem( GetValue(), IsFitToLine(), Which() );
3274 }
3275 
Create(SvStream & rStrm,sal_uInt16) const3276 SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, sal_uInt16 ) const
3277 {
3278 	sal_uInt16 nVal;
3279 	sal_Bool b;
3280 	rStrm >> nVal >> b;
3281 	return new SvxCharRotateItem( nVal, b, Which() );
3282 }
3283 
Store(SvStream & rStrm,sal_uInt16) const3284 SvStream& SvxCharRotateItem::Store( SvStream & rStrm, sal_uInt16 ) const
3285 {
3286 	sal_Bool bFlag = IsFitToLine();
3287 	rStrm << GetValue() << bFlag;
3288 	return rStrm;
3289 }
3290 
GetVersion(sal_uInt16 nFFVer) const3291 sal_uInt16 SvxCharRotateItem::GetVersion( sal_uInt16 nFFVer ) const
3292 {
3293 	return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
3294 }
3295 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,String & rText,const IntlWrapper *) const3296 SfxItemPresentation SvxCharRotateItem::GetPresentation(
3297 		SfxItemPresentation ePres,
3298         SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
3299         String &rText, const IntlWrapper*  ) const
3300 {
3301 	switch( ePres )
3302 	{
3303 	case SFX_ITEM_PRESENTATION_NONE:
3304 		rText.Erase();
3305 		break;
3306 	case SFX_ITEM_PRESENTATION_NAMELESS:
3307 	case SFX_ITEM_PRESENTATION_COMPLETE:
3308 		{
3309 			if( !GetValue() )
3310 				rText = EE_RESSTR( RID_SVXITEMS_CHARROTATE_OFF );
3311 			else
3312 			{
3313 				rText = EE_RESSTR( RID_SVXITEMS_CHARROTATE );
3314 				rText.SearchAndReplaceAscii( "$(ARG1)",
3315 							String::CreateFromInt32( GetValue() / 10 ));
3316 				if( IsFitToLine() )
3317 					rText += EE_RESSTR( RID_SVXITEMS_CHARROTATE_FITLINE );
3318 			}
3319 			return ePres;
3320 		}
3321         default: ; //prevent warning
3322     }
3323 	return SFX_ITEM_PRESENTATION_NONE;
3324 }
3325 
QueryValue(com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId) const3326 sal_Bool SvxCharRotateItem::QueryValue( com::sun::star::uno::Any& rVal,
3327 								sal_uInt8 nMemberId ) const
3328 {
3329 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3330     nMemberId &= ~CONVERT_TWIPS;
3331 	sal_Bool bRet = sal_True;
3332 	switch( nMemberId )
3333 	{
3334 	case MID_ROTATE:
3335 		rVal <<= (sal_Int16)GetValue();
3336 		break;
3337 	case MID_FITTOLINE:
3338 		rVal = Bool2Any( IsFitToLine() );
3339 		break;
3340 	default:
3341 		bRet = sal_False;
3342 		break;
3343 	}
3344 	return bRet;
3345 }
3346 
PutValue(const com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId)3347 sal_Bool SvxCharRotateItem::PutValue( const com::sun::star::uno::Any& rVal,
3348 									sal_uInt8 nMemberId )
3349 {
3350 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3351     nMemberId &= ~CONVERT_TWIPS;
3352 	sal_Bool bRet = sal_True;
3353 	switch( nMemberId )
3354 	{
3355 	case MID_ROTATE:
3356         {
3357             sal_Int16 nVal = 0;
3358             if((rVal >>= nVal) && (0 == nVal || 900 == nVal || 2700 == nVal))
3359                 SetValue( (sal_uInt16)nVal );
3360             else
3361                 bRet = sal_False;
3362             break;
3363         }
3364 
3365 	case MID_FITTOLINE:
3366 		SetFitToLine( Any2Bool( rVal ) );
3367 		break;
3368 	default:
3369 		bRet = sal_False;
3370 	}
3371 	return bRet;
3372 }
3373 
operator ==(const SfxPoolItem & rItem) const3374 int SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const
3375 {
3376 	DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
3377 	return SfxUInt16Item::operator==( rItem ) &&
3378 		   IsFitToLine() == ((const SvxCharRotateItem&)rItem).IsFitToLine();
3379 }
3380 
3381 
3382 /*************************************************************************
3383 |*    class SvxCharScaleItem
3384 *************************************************************************/
3385 
SvxCharScaleWidthItem(sal_uInt16 nValue,const sal_uInt16 nW)3386 SvxCharScaleWidthItem::SvxCharScaleWidthItem( sal_uInt16 nValue,
3387 					   						const sal_uInt16 nW )
3388 	: SfxUInt16Item( nW, nValue )
3389 {
3390 }
3391 
Clone(SfxItemPool *) const3392 SfxPoolItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const
3393 {
3394 	return new SvxCharScaleWidthItem( GetValue(), Which() );
3395 }
3396 
Create(SvStream & rStrm,sal_uInt16) const3397 SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, sal_uInt16 ) const
3398 {
3399 	sal_uInt16 nVal;
3400 	rStrm >> nVal;
3401 	SvxCharScaleWidthItem* pItem = new SvxCharScaleWidthItem( nVal, Which() );
3402 
3403     if ( Which() == EE_CHAR_FONTWIDTH )
3404     {
3405         // #87271#: Was a SvxFontWidthItem in 5.2
3406         // sal_uInt16 nFixWidth, sal_uInt16 nPropWidth.
3407         // nFixWidth has never been used...
3408 	    rStrm >> nVal;
3409         sal_uInt16 nTest;
3410 	    rStrm >> nTest;
3411         if ( nTest == 0x1234 )
3412 	        pItem->SetValue( nVal );
3413         else
3414             rStrm.SeekRel( -2*(long)sizeof(sal_uInt16) );
3415     }
3416 
3417     return pItem;
3418 }
3419 
Store(SvStream & rStream,sal_uInt16 nVer) const3420 SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, sal_uInt16 nVer ) const
3421 {
3422     SvStream& rRet = SfxUInt16Item::Store( rStream, nVer );
3423     if ( Which() == EE_CHAR_FONTWIDTH )
3424     {
3425         // see comment in Create()....
3426         rRet.SeekRel( -1*(long)sizeof(sal_uInt16) );
3427         rRet << (sal_uInt16)0;
3428         rRet << GetValue();
3429         // Really ugly, but not a problem for reading the doc in 5.2
3430         rRet << (sal_uInt16)0x1234;
3431     }
3432     return rRet;
3433 }
3434 
3435 
GetVersion(sal_uInt16 nFFVer) const3436 sal_uInt16 SvxCharScaleWidthItem::GetVersion( sal_uInt16 nFFVer ) const
3437 {
3438 	return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
3439 }
3440 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,String & rText,const IntlWrapper *) const3441 SfxItemPresentation SvxCharScaleWidthItem::GetPresentation(
3442 		SfxItemPresentation ePres,
3443         SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/,
3444         String &rText, const IntlWrapper*  ) const
3445 {
3446 	switch( ePres )
3447 	{
3448 	case SFX_ITEM_PRESENTATION_NONE:
3449 		rText.Erase();
3450 		break;
3451 	case SFX_ITEM_PRESENTATION_NAMELESS:
3452 	case SFX_ITEM_PRESENTATION_COMPLETE:
3453 		{
3454 			if( !GetValue() )
3455 				rText = EE_RESSTR( RID_SVXITEMS_CHARSCALE_OFF );
3456 			else
3457 			{
3458 				rText = EE_RESSTR( RID_SVXITEMS_CHARSCALE );
3459 				rText.SearchAndReplaceAscii( "$(ARG1)",
3460 							String::CreateFromInt32( GetValue() ));
3461 			}
3462 			return ePres;
3463 		}
3464         default: ; //prevent warning
3465     }
3466 	return SFX_ITEM_PRESENTATION_NONE;
3467 }
3468 
PutValue(const uno::Any & rVal,sal_uInt8)3469 sal_Bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
3470 {
3471     // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
3472     // where we still want this to be a sal_Int16
3473     sal_Int16 nValue = sal_Int16();
3474 	if (rVal >>= nValue)
3475 	{
3476         SetValue( (sal_uInt16) nValue );
3477 		return sal_True;
3478 	}
3479 
3480     DBG_ERROR( "SvxCharScaleWidthItem::PutValue - Wrong type!" );
3481 	return sal_False;
3482 }
3483 
QueryValue(uno::Any & rVal,sal_uInt8) const3484 sal_Bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
3485 {
3486     // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
3487     // where we still want this to be a sal_Int16
3488     rVal <<= (sal_Int16)GetValue();
3489     return sal_True;
3490 }
3491 
3492 /*************************************************************************
3493 |*    class SvxCharReliefItem
3494 *************************************************************************/
3495 
SvxCharReliefItem(FontRelief eValue,const sal_uInt16 nId)3496 SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue,
3497 					   				  const sal_uInt16 nId )
3498 	: SfxEnumItem( nId, (sal_uInt16)eValue )
3499 {
3500 }
3501 
Clone(SfxItemPool *) const3502 SfxPoolItem* SvxCharReliefItem::Clone( SfxItemPool * ) const
3503 {
3504 	return new SvxCharReliefItem( *this );
3505 }
3506 
Create(SvStream & rStrm,sal_uInt16) const3507 SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, sal_uInt16) const
3508 {
3509 	sal_uInt16 nVal;
3510 	rStrm >> nVal;
3511 	return new SvxCharReliefItem( (FontRelief)nVal, Which() );
3512 }
3513 
Store(SvStream & rStrm,sal_uInt16) const3514 SvStream& SvxCharReliefItem::Store(SvStream & rStrm, sal_uInt16 /*nIVer*/) const
3515 {
3516 	sal_uInt16 nVal = GetValue();
3517 	rStrm << nVal;
3518 	return rStrm;
3519 }
3520 
GetVersion(sal_uInt16 nFFVer) const3521 sal_uInt16 SvxCharReliefItem::GetVersion( sal_uInt16 nFFVer ) const
3522 {
3523 	return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0;
3524 }
3525 
GetValueTextByPos(sal_uInt16 nPos) const3526 String SvxCharReliefItem::GetValueTextByPos( sal_uInt16 nPos ) const
3527 {
3528 	DBG_ASSERT( RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE,
3529 					"enum overflow" );
3530 	return String( EditResId( RID_SVXITEMS_RELIEF_BEGIN + nPos ));
3531 }
3532 
GetValueCount() const3533 sal_uInt16 SvxCharReliefItem::GetValueCount() const
3534 {
3535 	return RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE;
3536 }
3537 
GetPresentation(SfxItemPresentation ePres,SfxMapUnit,SfxMapUnit,XubString & rText,const IntlWrapper *) const3538 SfxItemPresentation SvxCharReliefItem::GetPresentation
3539 (
3540     SfxItemPresentation ePres,
3541     SfxMapUnit          /*eCoreUnit*/,
3542     SfxMapUnit          /*ePresUnit*/,
3543     XubString&          rText, const IntlWrapper * /*pIntl*/
3544 )   const
3545 {
3546 	SfxItemPresentation eRet = ePres;
3547     switch( ePres )
3548     {
3549     case SFX_ITEM_PRESENTATION_NONE:
3550         rText.Erase();
3551 		break;
3552 
3553     case SFX_ITEM_PRESENTATION_NAMELESS:
3554     case SFX_ITEM_PRESENTATION_COMPLETE:
3555         rText = GetValueTextByPos( GetValue() );
3556 		break;
3557 
3558 	default:
3559 		eRet = SFX_ITEM_PRESENTATION_NONE;
3560     }
3561     return eRet;
3562 }
3563 
PutValue(const com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId)3564 sal_Bool SvxCharReliefItem::PutValue( const com::sun::star::uno::Any& rVal,
3565 										sal_uInt8 nMemberId )
3566 {
3567 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3568     nMemberId &= ~CONVERT_TWIPS;
3569 	sal_Bool bRet = sal_True;
3570 	switch( nMemberId )
3571 	{
3572 	case MID_RELIEF:
3573 		{
3574             sal_Int16 nVal = -1;
3575 			rVal >>= nVal;
3576             if(nVal >= 0 && nVal <= RELIEF_ENGRAVED)
3577                 SetValue( (sal_uInt16)nVal );
3578             else
3579                 bRet = sal_False;
3580 		}
3581 		break;
3582 	default:
3583 		bRet = sal_False;
3584 		break;
3585 	}
3586 	return bRet;
3587 }
3588 
QueryValue(com::sun::star::uno::Any & rVal,sal_uInt8 nMemberId) const3589 sal_Bool SvxCharReliefItem::QueryValue( com::sun::star::uno::Any& rVal,
3590 										sal_uInt8 nMemberId ) const
3591 {
3592 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3593     nMemberId &= ~CONVERT_TWIPS;
3594 	sal_Bool bRet = sal_True;
3595 	switch( nMemberId )
3596 	{
3597 	case MID_RELIEF:
3598 		rVal <<= (sal_Int16)GetValue();
3599 		break;
3600 	default:
3601 		bRet = sal_False;
3602 		break;
3603 	}
3604 	return bRet;
3605 }
3606 
3607 /*************************************************************************
3608 |*    class SvxScriptTypeItemItem
3609 *************************************************************************/
3610 
SvxScriptTypeItem(sal_uInt16 nType)3611 SvxScriptTypeItem::SvxScriptTypeItem( sal_uInt16 nType )
3612 	: SfxUInt16Item( SID_ATTR_CHAR_SCRIPTTYPE, nType )
3613 {
3614 }
Clone(SfxItemPool *) const3615 SfxPoolItem* SvxScriptTypeItem::Clone( SfxItemPool * ) const
3616 {
3617 	return new SvxScriptTypeItem( GetValue() );
3618 }
3619 
3620 /*************************************************************************
3621 |*    class SvxScriptSetItem
3622 *************************************************************************/
3623 
SvxScriptSetItem(sal_uInt16 nSlotId,SfxItemPool & rPool)3624 SvxScriptSetItem::SvxScriptSetItem( sal_uInt16 nSlotId, SfxItemPool& rPool )
3625 	: SfxSetItem( nSlotId, new SfxItemSet( rPool,
3626 						SID_ATTR_CHAR_FONT,	SID_ATTR_CHAR_FONT ))
3627 {
3628 	sal_uInt16 nLatin, nAsian, nComplex;
3629 	GetWhichIds( nLatin, nAsian, nComplex );
3630 
3631 	sal_uInt16 aIds[ 9 ] = { 0 };
3632 	aIds[ 0 ] = aIds[ 1 ] = nLatin;
3633 	aIds[ 2 ] = aIds[ 3 ] = nAsian;
3634 	aIds[ 4 ] = aIds[ 5 ] = nComplex;
3635 	aIds[ 6 ] = aIds[ 7 ] = SID_ATTR_CHAR_SCRIPTTYPE;
3636 	aIds[ 8 ] = 0;
3637 
3638 	GetItemSet().SetRanges( aIds );
3639 }
3640 
Clone(SfxItemPool *) const3641 SfxPoolItem* SvxScriptSetItem::Clone( SfxItemPool * ) const
3642 {
3643 	SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() );
3644 	p->GetItemSet().Put( GetItemSet(), sal_False );
3645 	return p;
3646 }
3647 
Create(SvStream &,sal_uInt16) const3648 SfxPoolItem* SvxScriptSetItem::Create( SvStream &, sal_uInt16 ) const
3649 {
3650 	return 0;
3651 }
3652 
GetItemOfScriptSet(const SfxItemSet & rSet,sal_uInt16 nId)3653 const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet(
3654 							const SfxItemSet& rSet, sal_uInt16 nId )
3655 {
3656 	const SfxPoolItem* pI;
3657 	SfxItemState eSt = rSet.GetItemState( nId, sal_False, &pI );
3658 	if( SFX_ITEM_SET != eSt )
3659 		pI = SFX_ITEM_DEFAULT == eSt ? &rSet.Get( nId ) : 0;
3660 	return pI;
3661 }
3662 
GetItemOfScript(sal_uInt16 nSlotId,const SfxItemSet & rSet,sal_uInt16 nScript)3663 const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16 nScript )
3664 {
3665 	sal_uInt16 nLatin, nAsian, nComplex;
3666 	GetWhichIds( nSlotId, rSet, nLatin, nAsian, nComplex );
3667 
3668 	const SfxPoolItem *pRet, *pAsn, *pCmplx;
3669 	switch( nScript )
3670 	{
3671 	default:				//no one valid -> match to latin
3672 	//  case SCRIPTTYPE_LATIN:
3673 		pRet = GetItemOfScriptSet( rSet, nLatin );
3674 		break;
3675 	case SCRIPTTYPE_ASIAN:
3676 		pRet = GetItemOfScriptSet( rSet, nAsian );
3677 		break;
3678 	case SCRIPTTYPE_COMPLEX:
3679 		pRet = GetItemOfScriptSet( rSet, nComplex );
3680 		break;
3681 
3682 	case SCRIPTTYPE_LATIN|SCRIPTTYPE_ASIAN:
3683 		if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
3684 			0 == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
3685 			*pRet != *pAsn )
3686 			pRet = 0;
3687 		break;
3688 
3689 	case SCRIPTTYPE_LATIN|SCRIPTTYPE_COMPLEX:
3690 		if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
3691 			0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
3692 			*pRet != *pCmplx )
3693 			pRet = 0;
3694 		break;
3695 
3696 	case SCRIPTTYPE_ASIAN|SCRIPTTYPE_COMPLEX:
3697 		if( 0 == (pRet = GetItemOfScriptSet( rSet, nAsian )) ||
3698 			0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
3699 			*pRet != *pCmplx )
3700 			pRet = 0;
3701 		break;
3702 
3703 	case SCRIPTTYPE_LATIN|SCRIPTTYPE_ASIAN|SCRIPTTYPE_COMPLEX:
3704 		if( 0 == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
3705 			0 == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
3706 			0 == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
3707 			*pRet != *pAsn || *pRet != *pCmplx )
3708 			pRet = 0;
3709 		break;
3710 	}
3711 	return pRet;
3712 }
3713 
GetItemOfScript(sal_uInt16 nScript) const3714 const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nScript ) const
3715 {
3716     return GetItemOfScript( Which(), GetItemSet(), nScript );
3717 }
3718 
PutItemForScriptType(sal_uInt16 nScriptType,const SfxPoolItem & rItem)3719 void SvxScriptSetItem::PutItemForScriptType( sal_uInt16 nScriptType,
3720 											 const SfxPoolItem& rItem )
3721 {
3722 	sal_uInt16 nLatin, nAsian, nComplex;
3723 	GetWhichIds( nLatin, nAsian, nComplex );
3724 
3725 	SfxPoolItem* pCpy = rItem.Clone();
3726 	if( SCRIPTTYPE_LATIN & nScriptType )
3727 	{
3728 		pCpy->SetWhich( nLatin );
3729 		GetItemSet().Put( *pCpy );
3730 	}
3731 	if( SCRIPTTYPE_ASIAN & nScriptType )
3732 	{
3733 		pCpy->SetWhich( nAsian );
3734 		GetItemSet().Put( *pCpy );
3735 	}
3736 	if( SCRIPTTYPE_COMPLEX & nScriptType )
3737 	{
3738 		pCpy->SetWhich( nComplex );
3739 		GetItemSet().Put( *pCpy );
3740 	}
3741 	delete pCpy;
3742 }
3743 
GetWhichIds(sal_uInt16 nSlotId,const SfxItemSet & rSet,sal_uInt16 & rLatin,sal_uInt16 & rAsian,sal_uInt16 & rComplex)3744 void SvxScriptSetItem::GetWhichIds( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16& rLatin, sal_uInt16& rAsian, sal_uInt16& rComplex )
3745 {
3746 	const SfxItemPool& rPool = *rSet.GetPool();
3747 	GetSlotIds( nSlotId, rLatin, rAsian, rComplex );
3748 	rLatin = rPool.GetWhich( rLatin );
3749 	rAsian = rPool.GetWhich( rAsian );
3750 	rComplex = rPool.GetWhich( rComplex );
3751 }
3752 
GetWhichIds(sal_uInt16 & rLatin,sal_uInt16 & rAsian,sal_uInt16 & rComplex) const3753 void SvxScriptSetItem::GetWhichIds( sal_uInt16& rLatin, sal_uInt16& rAsian,
3754 									sal_uInt16& rComplex ) const
3755 {
3756     GetWhichIds( Which(), GetItemSet(), rLatin, rAsian, rComplex );
3757 }
3758 
GetSlotIds(sal_uInt16 nSlotId,sal_uInt16 & rLatin,sal_uInt16 & rAsian,sal_uInt16 & rComplex)3759 void SvxScriptSetItem::GetSlotIds( sal_uInt16 nSlotId, sal_uInt16& rLatin,
3760 									sal_uInt16& rAsian, sal_uInt16& rComplex )
3761 {
3762 	switch( nSlotId )
3763 	{
3764 	default:
3765 		DBG_ASSERT( sal_False, "wrong SlotId for class SvxScriptSetItem" );
3766 		// no break - default to font - Id Range !!
3767 
3768 	case SID_ATTR_CHAR_FONT:
3769 		rLatin = SID_ATTR_CHAR_FONT;
3770 		rAsian = SID_ATTR_CHAR_CJK_FONT;
3771 		rComplex = SID_ATTR_CHAR_CTL_FONT;
3772 		break;
3773 	case SID_ATTR_CHAR_FONTHEIGHT:
3774 		rLatin = SID_ATTR_CHAR_FONTHEIGHT;
3775 		rAsian = SID_ATTR_CHAR_CJK_FONTHEIGHT;
3776 		rComplex = SID_ATTR_CHAR_CTL_FONTHEIGHT;
3777 		break;
3778 	case SID_ATTR_CHAR_WEIGHT:
3779 		rLatin = SID_ATTR_CHAR_WEIGHT;
3780 		rAsian = SID_ATTR_CHAR_CJK_WEIGHT;
3781 		rComplex = SID_ATTR_CHAR_CTL_WEIGHT;
3782 		break;
3783 	case SID_ATTR_CHAR_POSTURE:
3784 		rLatin = SID_ATTR_CHAR_POSTURE;
3785 		rAsian = SID_ATTR_CHAR_CJK_POSTURE;
3786 		rComplex = SID_ATTR_CHAR_CTL_POSTURE;
3787 		break;
3788 	case SID_ATTR_CHAR_LANGUAGE:
3789 		rLatin = SID_ATTR_CHAR_LANGUAGE;
3790 		rAsian = SID_ATTR_CHAR_CJK_LANGUAGE;
3791 		rComplex = SID_ATTR_CHAR_CTL_LANGUAGE;
3792 		break;
3793     case SID_ATTR_CHAR_SHADOWED:
3794 		rLatin = SID_ATTR_CHAR_SHADOWED;
3795 		rAsian = SID_ATTR_CHAR_SHADOWED;
3796 		rComplex = SID_ATTR_CHAR_SHADOWED;
3797 		break;
3798 	case SID_ATTR_CHAR_STRIKEOUT:
3799 		rLatin = SID_ATTR_CHAR_STRIKEOUT;
3800 		rAsian = SID_ATTR_CHAR_STRIKEOUT;
3801 		rComplex = SID_ATTR_CHAR_STRIKEOUT;
3802 		break;
3803 	}
3804 }
3805 
GetDefaultFonts(SvxFontItem & rLatin,SvxFontItem & rAsian,SvxFontItem & rComplex)3806 void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex )
3807 {
3808 	const sal_uInt16 nItemCnt = 3;
3809 
3810 	static struct
3811 	{
3812 		sal_uInt16 nFontType;
3813 		sal_uInt16 nLanguage;
3814 	}
3815 	aOutTypeArr[ nItemCnt ] =
3816 	{
3817 		{  DEFAULTFONT_LATIN_TEXT, LANGUAGE_ENGLISH_US },
3818 		{  DEFAULTFONT_CJK_TEXT, LANGUAGE_ENGLISH_US },
3819 		{  DEFAULTFONT_CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA }
3820 	};
3821 
3822 	SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };
3823 
3824 	for ( sal_uInt16 n = 0; n < nItemCnt; ++n )
3825 	{
3826 		Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType,
3827 												  aOutTypeArr[ n ].nLanguage,
3828 												  DEFAULTFONT_FLAGS_ONLYONE, 0 ) );
3829 		SvxFontItem* pItem = aItemArr[ n ];
3830         pItem->SetFamily( aFont.GetFamily() );
3831         pItem->SetFamilyName( aFont.GetName() );
3832         pItem->SetStyleName( String() );
3833         pItem->SetPitch( aFont.GetPitch());
3834         pItem->SetCharSet(aFont.GetCharSet());
3835 	}
3836 }
3837 
3838 
GetI18NScriptTypeOfLanguage(sal_uInt16 nLang)3839 sal_uInt16 GetI18NScriptTypeOfLanguage( sal_uInt16 nLang )
3840 {
3841     return GetI18NScriptType( SvtLanguageOptions::GetScriptTypeOfLanguage( nLang ) );
3842 }
3843 
GetItemScriptType(short nI18NType)3844 sal_uInt16 GetItemScriptType( short nI18NType )
3845 {
3846     switch ( nI18NType )
3847     {
3848 	    case i18n::ScriptType::LATIN:   return SCRIPTTYPE_LATIN;
3849 	    case i18n::ScriptType::ASIAN:   return SCRIPTTYPE_ASIAN;
3850 	    case i18n::ScriptType::COMPLEX: return SCRIPTTYPE_COMPLEX;
3851     }
3852     return 0;
3853 }
3854 
GetI18NScriptType(sal_uInt16 nItemType)3855 short GetI18NScriptType( sal_uInt16 nItemType )
3856 {
3857     switch ( nItemType )
3858     {
3859         case SCRIPTTYPE_LATIN:      return i18n::ScriptType::LATIN;
3860         case SCRIPTTYPE_ASIAN:      return i18n::ScriptType::ASIAN;
3861         case SCRIPTTYPE_COMPLEX:    return i18n::ScriptType::COMPLEX;
3862     }
3863     return 0;
3864 }
3865