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