?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 7.6.3.2-android
[LibreOffice.git] / editeng / source / items / textitem.cxx
blob546918197a34576d18d5381fde90d66b7c29b62d
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 <math.h>
24 #include <sal/log.hxx>
25 #include <o3tl/safeint.hxx>
26 #include <osl/diagnose.h>
27 #include <unotools/fontdefs.hxx>
28 #include <unotools/intlwrapper.hxx>
29 #include <unotools/syslocale.hxx>
30 #include <utility>
31 #include <vcl/outdev.hxx>
32 #include <vcl/unohelp.hxx>
33 #include <svtools/unitconv.hxx>
34
35 #include <editeng/editids.hrc>
36 #include <editeng/editrids.hrc>
37 #include <tools/bigint.hxx>
38 #include <tools/mapunit.hxx>
39 #include <tools/UnitConversion.hxx>
40
41 #include <rtl/math.hxx>
42 #include <rtl/ustring.hxx>
43 #include <i18nlangtag/languagetag.hxx>
44 #include <svl/itemset.hxx>
45
46 #include <svtools/langtab.hxx>
47 #include <svl/itempool.hxx>
48 #include <svtools/ctrltool.hxx>
49 #include <com/sun/star/awt/FontSlant.hpp>
50 #include <com/sun/star/lang/Locale.hpp>
51 #include <com/sun/star/text/FontEmphasis.hpp>
52 #include <editeng/rsiditem.hxx>
53 #include <editeng/memberids.h>
54 #include <editeng/flstitem.hxx>
55 #include <editeng/fontitem.hxx>
56 #include <editeng/postitem.hxx>
57 #include <editeng/wghtitem.hxx>
58 #include <editeng/fhgtitem.hxx>
59 #include <editeng/udlnitem.hxx>
60 #include <editeng/crossedoutitem.hxx>
61 #include <editeng/shdditem.hxx>
62 #include <editeng/autokernitem.hxx>
63 #include <editeng/wrlmitem.hxx>
64 #include <editeng/contouritem.hxx>
65 #include <editeng/colritem.hxx>
66 #include <editeng/kernitem.hxx>
67 #include <editeng/cmapitem.hxx>
68 #include <editeng/escapementitem.hxx>
69 #include <editeng/langitem.hxx>
70 #include <editeng/nhypitem.hxx>
71 #include <editeng/blinkitem.hxx>
72 #include <editeng/emphasismarkitem.hxx>
73 #include <editeng/twolinesitem.hxx>
74 #include <editeng/scripttypeitem.hxx>
75 #include <editeng/charrotateitem.hxx>
76 #include <editeng/charscaleitem.hxx>
77 #include <editeng/charreliefitem.hxx>
78 #include <editeng/itemtype.hxx>
79 #include <editeng/eerdll.hxx>
80 #include <docmodel/color/ComplexColorJSON.hxx>
81 #include <docmodel/uno/UnoComplexColor.hxx>
82 #include <docmodel/color/ComplexColor.hxx>
83 #include <libxml/xmlwriter.h>
84
85 using namespace ::com::sun::star;
86 using namespace ::com::sun::star::text;
87
88 SfxPoolItem* SvxFontItem::CreateDefault() {return new SvxFontItem(0);}
89 SfxPoolItem* SvxPostureItem::CreateDefault() { return new SvxPostureItem(ITALIC_NONE, 0);}
90 SfxPoolItem* SvxWeightItem::CreateDefault() {return new SvxWeightItem(WEIGHT_NORMAL, 0);}
91 SfxPoolItem* SvxFontHeightItem::CreateDefault() {return new SvxFontHeightItem(240, 100, 0);}
92 SfxPoolItem* SvxUnderlineItem::CreateDefault() {return new SvxUnderlineItem(LINESTYLE_NONE, 0);}
93 SfxPoolItem* SvxOverlineItem::CreateDefault() {return new SvxOverlineItem(LINESTYLE_NONE, 0);}
94 SfxPoolItem* SvxCrossedOutItem::CreateDefault() {return new SvxCrossedOutItem(STRIKEOUT_NONE, 0);}
95 SfxPoolItem* SvxShadowedItem::CreateDefault() {return new SvxShadowedItem(false, 0);}
96 SfxPoolItem* SvxAutoKernItem::CreateDefault() {return new SvxAutoKernItem(false, 0);}
97 SfxPoolItem* SvxWordLineModeItem::CreateDefault() {return new SvxWordLineModeItem(false, 0);}
98 SfxPoolItem* SvxContourItem::CreateDefault() {return new SvxContourItem(false, 0);}
99 SfxPoolItem* SvxColorItem::CreateDefault() {return new SvxColorItem(0);}
100 SfxPoolItem* SvxKerningItem::CreateDefault() {return new SvxKerningItem(0, 0);}
101 SfxPoolItem* SvxCaseMapItem::CreateDefault() {return new SvxCaseMapItem(SvxCaseMap::NotMapped, 0);}
102 SfxPoolItem* SvxEscapementItem::CreateDefault() {return new SvxEscapementItem(0);}
103 SfxPoolItem* SvxLanguageItem::CreateDefault() {return new SvxLanguageItem(LANGUAGE_GERMAN, 0);}
104 SfxPoolItem* SvxEmphasisMarkItem::CreateDefault() {return new SvxEmphasisMarkItem(FontEmphasisMark::NONE, TypedWhichId<SvxEmphasisMarkItem>(0));}
105 SfxPoolItem* SvxCharRotateItem::CreateDefault() {return new SvxCharRotateItem(0_deg10, false, TypedWhichId<SvxCharRotateItem>(0));}
106 SfxPoolItem* SvxCharScaleWidthItem::CreateDefault() {return new SvxCharScaleWidthItem(100, TypedWhichId<SvxCharScaleWidthItem>(0));}
107 SfxPoolItem* SvxCharReliefItem::CreateDefault() {return new SvxCharReliefItem(FontRelief::NONE, 0);}
108
109
110 // class SvxFontListItem -------------------------------------------------
111
112 SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
113 const sal_uInt16 nId ) :
114 SfxPoolItem( nId ),
115 pFontList( pFontLst )
116 {
117 if ( pFontList )
118 {
119 sal_Int32 nCount = pFontList->GetFontNameCount();
120 aFontNameSeq.realloc( nCount );
121 auto pFontNameSeq = aFontNameSeq.getArray();
122
123 for ( sal_Int32 i = 0; i < nCount; i++ )
124 pFontNameSeq[i] = pFontList->GetFontName(i).GetFamilyName();
125 }
126 }
127
128 SvxFontListItem* SvxFontListItem::Clone( SfxItemPool* ) const
129 {
130 return new SvxFontListItem( *this );
131 }
132
133 bool SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const
134 {
135 assert(SfxPoolItem::operator==(rAttr));
136
137 return( pFontList == static_cast<const SvxFontListItem&>(rAttr).pFontList );
138 }
139
140 bool SvxFontListItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
141 {
142 rVal <<= aFontNameSeq;
143 return true;
144 }
145
146
147 bool SvxFontListItem::GetPresentation
148 (
149 SfxItemPresentation /*ePres*/,
150 MapUnit /*eCoreUnit*/,
151 MapUnit /*ePresUnit*/,
152 OUString& rText, const IntlWrapper& /*rIntl*/
153 ) const
154 {
155 rText.clear();
156 return false;
157 }
158
159 // class SvxFontItem -----------------------------------------------------
160
161 namespace
162 {
163 sal_Int32 CompareTo(sal_Int32 nA, sal_Int32 nB)
164 {
165 if (nA < nB)
166 {
167 return -1;
168 }
169
170 if (nA > nB)
171 {
172 return 1;
173 }
174
175 return 0;
176 }
177 }
178
179 SvxFontItem::SvxFontItem( const sal_uInt16 nId ) :
180 SfxPoolItem( nId )
181 {
182 eFamily = FAMILY_SWISS;
183 ePitch = PITCH_VARIABLE;
184 eTextEncoding = RTL_TEXTENCODING_DONTKNOW;
185 }
186
187
188 SvxFontItem::SvxFontItem( const FontFamily eFam, OUString aName,
189 OUString aStName, const FontPitch eFontPitch,
190 const rtl_TextEncoding eFontTextEncoding, const sal_uInt16 nId ) :
191
192 SfxPoolItem( nId ),
193
194 aFamilyName(std::move(aName)),
195 aStyleName(std::move(aStName))
196 {
197 eFamily = eFam;
198 ePitch = eFontPitch;
199 eTextEncoding = eFontTextEncoding;
200 }
201
202
203 bool SvxFontItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
204 {
205 nMemberId &= ~CONVERT_TWIPS;
206 switch(nMemberId)
207 {
208 case 0:
209 {
210 css::awt::FontDescriptor aFontDescriptor;
211 aFontDescriptor.Name = aFamilyName;
212 aFontDescriptor.StyleName = aStyleName;
213 aFontDescriptor.Family = static_cast<sal_Int16>(eFamily);
214 aFontDescriptor.CharSet = static_cast<sal_Int16>(eTextEncoding);
215 aFontDescriptor.Pitch = static_cast<sal_Int16>(ePitch);
216 rVal <<= aFontDescriptor;
217 }
218 break;
219 case MID_FONT_FAMILY_NAME:
220 rVal <<= aFamilyName;
221 break;
222 case MID_FONT_STYLE_NAME:
223 rVal <<= aStyleName;
224 break;
225 case MID_FONT_FAMILY : rVal <<= static_cast<sal_Int16>(eFamily); break;
226 case MID_FONT_CHAR_SET : rVal <<= static_cast<sal_Int16>(eTextEncoding); break;
227 case MID_FONT_PITCH : rVal <<= static_cast<sal_Int16>(ePitch); break;
228 }
229 return true;
230 }
231
232 bool SvxFontItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
233 {
234 nMemberId &= ~CONVERT_TWIPS;
235 switch(nMemberId)
236 {
237 case 0:
238 {
239 css::awt::FontDescriptor aFontDescriptor;
240 if ( !( rVal >>= aFontDescriptor ))
241 return false;
242
243 aFamilyName = aFontDescriptor.Name;
244 aStyleName = aFontDescriptor.StyleName;
245 eFamily = static_cast<FontFamily>(aFontDescriptor.Family);
246 eTextEncoding = static_cast<rtl_TextEncoding>(aFontDescriptor.CharSet);
247 ePitch = static_cast<FontPitch>(aFontDescriptor.Pitch);
248 }
249 break;
250 case MID_FONT_FAMILY_NAME :
251 {
252 OUString aStr;
253 if(!(rVal >>= aStr))
254 return false;
255 aFamilyName = aStr;
256 }
257 break;
258 case MID_FONT_STYLE_NAME:
259 {
260 OUString aStr;
261 if(!(rVal >>= aStr))
262 return false;
263 aStyleName = aStr;
264 }
265 break;
266 case MID_FONT_FAMILY :
267 {
268 sal_Int16 nFamily = sal_Int16();
269 if(!(rVal >>= nFamily))
270 return false;
271 eFamily = static_cast<FontFamily>(nFamily);
272 }
273 break;
274 case MID_FONT_CHAR_SET :
275 {
276 sal_Int16 nSet = sal_Int16();
277 if(!(rVal >>= nSet))
278 return false;
279 eTextEncoding = static_cast<rtl_TextEncoding>(nSet);
280 }
281 break;
282 case MID_FONT_PITCH :
283 {
284 sal_Int16 nPitch = sal_Int16();
285 if(!(rVal >>= nPitch))
286 return false;
287 ePitch = static_cast<FontPitch>(nPitch);
288 }
289 break;
290 }
291 return true;
292 }
293
294
295 bool SvxFontItem::operator==( const SfxPoolItem& rAttr ) const
296 {
297 assert(SfxPoolItem::operator==(rAttr));
298
299 const SvxFontItem& rItem = static_cast<const SvxFontItem&>(rAttr);
300
301 bool bRet = ( eFamily == rItem.eFamily &&
302 aFamilyName == rItem.aFamilyName &&
303 aStyleName == rItem.aStyleName );
304
305 if ( bRet )
306 {
307 if ( ePitch != rItem.ePitch || eTextEncoding != rItem.eTextEncoding )
308 {
309 bRet = false;
310 SAL_INFO( "editeng.items", "FontItem::operator==(): only pitch or rtl_TextEncoding different ");
311 }
312 }
313 return bRet;
314 }
315
316 bool SvxFontItem::operator<(const SfxPoolItem& rCmp) const
317 {
318 const auto& rOther = static_cast<const SvxFontItem&>(rCmp);
319 sal_Int32 nRet = GetFamilyName().compareTo(rOther.GetFamilyName());
320 if (nRet != 0)
321 {
322 return nRet < 0;
323 }
324
325 nRet = GetStyleName().compareTo(rOther.GetStyleName());
326 if (nRet != 0)
327 {
328 return nRet < 0;
329 }
330
331 nRet = CompareTo(GetFamily(), rOther.GetFamily());
332 if (nRet != 0)
333 {
334 return nRet < 0;
335 }
336
337 nRet = CompareTo(GetPitch(), rOther.GetPitch());
338 if (nRet != 0)
339 {
340 return nRet < 0;
341 }
342
343 return GetCharSet() < rOther.GetCharSet();
344 }
345
346 SvxFontItem* SvxFontItem::Clone( SfxItemPool * ) const
347 {
348 return new SvxFontItem( *this );
349 }
350
351 bool SvxFontItem::GetPresentation
352 (
353 SfxItemPresentation /*ePres*/,
354 MapUnit /*eCoreUnit*/,
355 MapUnit /*ePresUnit*/,
356 OUString& rText, const IntlWrapper& /*rIntl*/
357 ) const
358 {
359 rText = aFamilyName;
360 return true;
361 }
362
363
364 void SvxFontItem::dumpAsXml(xmlTextWriterPtr pWriter) const
365 {
366 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontItem"));
367 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
368 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("familyName"), BAD_CAST(aFamilyName.toUtf8().getStr()));
369 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("styleName"), BAD_CAST(aStyleName.toUtf8().getStr()));
370 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("family"), BAD_CAST(OString::number(eFamily).getStr()));
371 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pitch"), BAD_CAST(OString::number(ePitch).getStr()));
372 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("textEncoding"), BAD_CAST(OString::number(eTextEncoding).getStr()));
373 (void)xmlTextWriterEndElement(pWriter);
374 }
375
376 // class SvxPostureItem --------------------------------------------------
377
378 SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const sal_uInt16 nId ) :
379 SfxEnumItem( nId, ePosture )
380 {
381 }
382
383 SvxPostureItem* SvxPostureItem::Clone( SfxItemPool * ) const
384 {
385 return new SvxPostureItem( *this );
386 }
387
388 sal_uInt16 SvxPostureItem::GetValueCount() const
389 {
390 return ITALIC_NORMAL + 1; // ITALIC_NONE also belongs here
391 }
392
393
394 bool SvxPostureItem::GetPresentation
395 (
396 SfxItemPresentation /*ePres*/,
397 MapUnit /*eCoreUnit*/,
398 MapUnit /*ePresUnit*/,
399 OUString& rText, const IntlWrapper& /*rIntl*/
400 ) const
401 {
402 rText = GetValueTextByPos( GetValue() );
403 return true;
404 }
405
406
407 OUString SvxPostureItem::GetValueTextByPos( sal_uInt16 nPos )
408 {
409 DBG_ASSERT( nPos <= sal_uInt16(ITALIC_NORMAL), "enum overflow!" );
410
411 FontItalic eItalic = static_cast<FontItalic>(nPos);
412 TranslateId pId;
413
414 switch ( eItalic )
415 {
416 case ITALIC_NONE: pId = RID_SVXITEMS_ITALIC_NONE; break;
417 case ITALIC_OBLIQUE: pId = RID_SVXITEMS_ITALIC_OBLIQUE; break;
418 case ITALIC_NORMAL: pId = RID_SVXITEMS_ITALIC_NORMAL; break;
419 default: ;//prevent warning
420 }
421
422 return pId ? EditResId(pId) : OUString();
423 }
424
425 bool SvxPostureItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
426 {
427 nMemberId &= ~CONVERT_TWIPS;
428 switch( nMemberId )
429 {
430 case MID_ITALIC:
431 rVal <<= GetBoolValue();
432 break;
433 case MID_POSTURE:
434 rVal <<= vcl::unohelper::ConvertFontSlant(GetValue());
435 break;
436 }
437 return true;
438 }
439
440 bool SvxPostureItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
441 {
442 nMemberId &= ~CONVERT_TWIPS;
443 switch( nMemberId )
444 {
445 case MID_ITALIC:
446 SetBoolValue(Any2Bool(rVal));
447 break;
448 case MID_POSTURE:
449 {
450 awt::FontSlant eSlant;
451 if(!(rVal >>= eSlant))
452 {
453 sal_Int32 nValue = 0;
454 if(!(rVal >>= nValue))
455 return false;
456
457 eSlant = static_cast<awt::FontSlant>(nValue);
458 }
459 SetValue(vcl::unohelper::ConvertFontSlant(eSlant));
460 }
461 }
462 return true;
463 }
464
465 bool SvxPostureItem::HasBoolValue() const
466 {
467 return true;
468 }
469
470 bool SvxPostureItem::GetBoolValue() const
471 {
472 return ( GetValue() >= ITALIC_OBLIQUE );
473 }
474
475 void SvxPostureItem::SetBoolValue( bool bVal )
476 {
477 SetValue( bVal ? ITALIC_NORMAL : ITALIC_NONE );
478 }
479
480 void SvxPostureItem::dumpAsXml(xmlTextWriterPtr pWriter) const
481 {
482 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxPostureItem"));
483 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
484 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
485 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
486 (void)xmlTextWriterEndElement(pWriter);
487 }
488
489 // class SvxWeightItem ---------------------------------------------------
490
491 SvxWeightItem::SvxWeightItem( const FontWeight eWght, const sal_uInt16 nId ) :
492 SfxEnumItem( nId, eWght )
493 {
494 }
495
496
497 bool SvxWeightItem::HasBoolValue() const
498 {
499 return true;
500 }
501
502
503 bool SvxWeightItem::GetBoolValue() const
504 {
505 return GetValue() >= WEIGHT_BOLD;
506 }
507
508
509 void SvxWeightItem::SetBoolValue( bool bVal )
510 {
511 SetValue( bVal ? WEIGHT_BOLD : WEIGHT_NORMAL );
512 }
513
514
515 sal_uInt16 SvxWeightItem::GetValueCount() const
516 {
517 return WEIGHT_BLACK; // WEIGHT_DONTKNOW does not belong
518 }
519
520 SvxWeightItem* SvxWeightItem::Clone( SfxItemPool * ) const
521 {
522 return new SvxWeightItem( *this );
523 }
524
525 bool SvxWeightItem::GetPresentation
526 (
527 SfxItemPresentation /*ePres*/,
528 MapUnit /*eCoreUnit*/,
529 MapUnit /*ePresUnit*/,
530 OUString& rText, const IntlWrapper& /*rIntl*/
531 ) const
532 {
533 rText = GetValueTextByPos( GetValue() );
534 return true;
535 }
536
537 OUString SvxWeightItem::GetValueTextByPos( sal_uInt16 nPos )
538 {
539 static TranslateId RID_SVXITEMS_WEIGHTS[] =
540 {
541 RID_SVXITEMS_WEIGHT_DONTKNOW,
542 RID_SVXITEMS_WEIGHT_THIN,
543 RID_SVXITEMS_WEIGHT_ULTRALIGHT,
544 RID_SVXITEMS_WEIGHT_LIGHT,
545 RID_SVXITEMS_WEIGHT_SEMILIGHT,
546 RID_SVXITEMS_WEIGHT_NORMAL,
547 RID_SVXITEMS_WEIGHT_MEDIUM,
548 RID_SVXITEMS_WEIGHT_SEMIBOLD,
549 RID_SVXITEMS_WEIGHT_BOLD,
550 RID_SVXITEMS_WEIGHT_ULTRABOLD,
551 RID_SVXITEMS_WEIGHT_BLACK
552 };
553
554 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_WEIGHTS) - 1 == WEIGHT_BLACK, "must match");
555 assert(nPos <= sal_uInt16(WEIGHT_BLACK) && "enum overflow!" );
556 return EditResId(RID_SVXITEMS_WEIGHTS[nPos]);
557 }
558
559 bool SvxWeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
560 {
561 nMemberId &= ~CONVERT_TWIPS;
562 switch( nMemberId )
563 {
564 case MID_BOLD :
565 rVal <<= GetBoolValue();
566 break;
567 case MID_WEIGHT:
568 {
569 rVal <<= vcl::unohelper::ConvertFontWeight( GetValue() );
570 }
571 break;
572 }
573 return true;
574 }
575
576 bool SvxWeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
577 {
578 nMemberId &= ~CONVERT_TWIPS;
579 switch( nMemberId )
580 {
581 case MID_BOLD :
582 SetBoolValue(Any2Bool(rVal));
583 break;
584 case MID_WEIGHT:
585 {
586 double fValue = 0;
587 if(!(rVal >>= fValue))
588 {
589 sal_Int32 nValue = 0;
590 if(!(rVal >>= nValue))
591 return false;
592 fValue = static_cast<float>(nValue);
593 }
594 SetValue( vcl::unohelper::ConvertFontWeight(static_cast<float>(fValue)) );
595 }
596 break;
597 }
598 return true;
599 }
600
601 void SvxWeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
602 {
603 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxWeightItem"));
604 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
605 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
606 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
607 (void)xmlTextWriterEndElement(pWriter);
608 }
609
610 // class SvxFontHeightItem -----------------------------------------------
611
612 SvxFontHeightItem::SvxFontHeightItem( const sal_uInt32 nSz,
613 const sal_uInt16 nPrp,
614 const sal_uInt16 nId ) :
615 SfxPoolItem( nId )
616 {
617 SetHeight( nSz,nPrp ); // calculate in percentage
618 }
619
620 SvxFontHeightItem* SvxFontHeightItem::Clone( SfxItemPool * ) const
621 {
622 return new SvxFontHeightItem( *this );
623 }
624
625 bool SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const
626 {
627 assert(SfxPoolItem::operator==(rItem));
628 return GetHeight() == static_cast<const SvxFontHeightItem&>(rItem).GetHeight() &&
629 GetProp() == static_cast<const SvxFontHeightItem&>(rItem).GetProp() &&
630 GetPropUnit() == static_cast<const SvxFontHeightItem&>(rItem).GetPropUnit();
631 }
632
633 bool SvxFontHeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
634 {
635 // In StarOne is the uno::Any always 1/100mm. Through the MemberId it is
636 // controlled if the value in the Item should be 1/100mm or Twips.
637
638 bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
639 nMemberId &= ~CONVERT_TWIPS;
640 switch( nMemberId )
641 {
642 case 0:
643 {
644 css::frame::status::FontHeight aFontHeight;
645
646 // Point (i.e. Twips) is asked for, thus re-calculate if
647 // CONVERT_TWIPS is not set.
648 if( bConvert )
649 {
650 aFontHeight.Height = o3tl::convert<double>(nHeight, o3tl::Length::twip, o3tl::Length::pt);
651 }
652 else
653 {
654 double fPoints = o3tl::convert<double>(nHeight, o3tl::Length::mm100, o3tl::Length::pt);
655 aFontHeight.Height = rtl::math::round(fPoints, 1);
656 }
657
658 aFontHeight.Prop = MapUnit::MapRelative == ePropUnit ? nProp : 100;
659
660 float fRet = nProp;
661 switch( ePropUnit )
662 {
663 case MapUnit::MapRelative:
664 fRet = 0.;
665 break;
666 case MapUnit::Map100thMM:
667 fRet = o3tl::convert(fRet, o3tl::Length::mm100, o3tl::Length::pt);
668 break;
669 case MapUnit::MapPoint:
670
671 break;
672 case MapUnit::MapTwip:
673 fRet = o3tl::convert(fRet, o3tl::Length::twip, o3tl::Length::pt);
674 break;
675 default: ;//prevent warning
676 }
677 aFontHeight.Diff = fRet;
678 rVal <<= aFontHeight;
679 }
680 break;
681 case MID_FONTHEIGHT:
682 {
683 // Point (i.e. Twips) is asked for, thus re-calculate if
684 // CONVERT_TWIPS is not set.
685 if( bConvert )
686 {
687 rVal <<= static_cast<float>(o3tl::convert<double>(nHeight, o3tl::Length::twip, o3tl::Length::pt));
688 }
689 else
690 {
691 double fPoints = o3tl::convert<double>(nHeight, o3tl::Length::mm100, o3tl::Length::pt);
692 rVal <<= static_cast<float>(::rtl::math::round(fPoints, 1));
693 }
694 }
695 break;
696 case MID_FONTHEIGHT_PROP:
697 rVal <<= static_cast<sal_Int16>(MapUnit::MapRelative == ePropUnit ? nProp : 100);
698 break;
699 case MID_FONTHEIGHT_DIFF:
700 {
701 float fRet = nProp;
702 switch( ePropUnit )
703 {
704 case MapUnit::MapRelative:
705 fRet = 0.;
706 break;
707 case MapUnit::Map100thMM:
708 fRet = o3tl::convert(fRet, o3tl::Length::mm100, o3tl::Length::pt);
709 break;
710 case MapUnit::MapPoint:
711
712 break;
713 case MapUnit::MapTwip:
714 fRet = o3tl::convert(fRet, o3tl::Length::twip, o3tl::Length::pt);
715 break;
716 default: ;//prevent warning
717 }
718 rVal <<= fRet;
719 }
720 break;
721 }
722 return true;
723 }
724
725 // Try to reconstruct the original height input value from the modified height
726 // and the prop data; this seems somewhat futile given the various ways how the
727 // modified height is calculated (with and without conversion between twips and
728 // 100th mm; with an additional eCoreMetric input in one of the SetHeight
729 // overloads), and indeed known to occasionally produce nRet values that would
730 // be negative, so just guard against negative results here and throw the hands
731 // up in despair:
732 static sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, MapUnit eProp, bool bCoreInTwip)
733 {
734 sal_uInt32 nRet = nHeight;
735 short nDiff = 0;
736 switch( eProp )
737 {
738 case MapUnit::MapRelative:
739 if (nProp)
740 {
741 nRet *= 100;
742 nRet /= nProp;
743 }
744 break;
745 case MapUnit::MapPoint:
746 {
747 short nTemp = static_cast<short>(nProp);
748 nDiff = nTemp * 20;
749 if(!bCoreInTwip)
750 nDiff = static_cast<short>(convertTwipToMm100(static_cast<tools::Long>(nDiff)));
751 break;
752 }
753 case MapUnit::Map100thMM:
754 //then the core is surely also in 1/100 mm
755 nDiff = static_cast<short>(nProp);
756 break;
757 case MapUnit::MapTwip:
758 // Here surely TWIP
759 nDiff = static_cast<short>(nProp);
760 break;
761 default:
762 break;
763 }
764 nRet = (nDiff < 0 || nRet >= o3tl::make_unsigned(nDiff))
765 ? nRet - nDiff : 0;
766 //TODO: overflow in case nDiff < 0 and nRet - nDiff > SAL_MAX_UINT32
767
768 return nRet;
769 }
770
771 bool SvxFontHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
772 {
773 bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
774 nMemberId &= ~CONVERT_TWIPS;
775 switch( nMemberId )
776 {
777 case 0:
778 {
779 css::frame::status::FontHeight aFontHeight;
780 if ( rVal >>= aFontHeight )
781 {
782 // Height
783 ePropUnit = MapUnit::MapRelative;
784 nProp = 100;
785 double fPoint = aFontHeight.Height;
786 if( fPoint < 0. || fPoint > 10000. )
787 return false;
788
789 nHeight = static_cast<tools::Long>( fPoint * 20.0 + 0.5 ); // Twips
790 if (!bConvert)
791 nHeight = convertTwipToMm100(nHeight); // Convert, if the item contains 1/100mm
792
793 nProp = aFontHeight.Prop;
794 }
795 else
796 return false;
797 }
798 break;
799 case MID_FONTHEIGHT:
800 {
801 ePropUnit = MapUnit::MapRelative;
802 nProp = 100;
803 double fPoint = 0;
804 if(!(rVal >>= fPoint))
805 {
806 sal_Int32 nValue = 0;
807 if(!(rVal >>= nValue))
808 return false;
809 fPoint = static_cast<float>(nValue);
810 }
811 if(fPoint < 0. || fPoint > 10000.)
812 return false;
813
814 nHeight = static_cast<tools::Long>( fPoint * 20.0 + 0.5 ); // Twips
815 if (!bConvert)
816 nHeight = convertTwipToMm100(nHeight); // Convert, if the item contains 1/100mm
817 }
818 break;
819 case MID_FONTHEIGHT_PROP:
820 {
821 sal_Int16 nNew = sal_Int16();
822 if(!(rVal >>= nNew))
823 return true;
824
825 nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
826
827 nHeight *= nNew;
828 nHeight /= 100;
829 nProp = nNew;
830 ePropUnit = MapUnit::MapRelative;
831 }
832 break;
833 case MID_FONTHEIGHT_DIFF:
834 {
835 nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
836 float fValue = 0;
837 if(!(rVal >>= fValue))
838 {
839 sal_Int32 nValue = 0;
840 if(!(rVal >>= nValue))
841 return false;
842 fValue = static_cast<float>(nValue);
843 }
844 sal_Int16 nCoreDiffValue = static_cast<sal_Int16>(fValue * 20.);
845 nHeight += bConvert ? nCoreDiffValue : convertTwipToMm100(nCoreDiffValue);
846 nProp = static_cast<sal_uInt16>(static_cast<sal_Int16>(fValue));
847 ePropUnit = MapUnit::MapPoint;
848 }
849 break;
850 }
851 return true;
852 }
853
854
855 bool SvxFontHeightItem::GetPresentation
856 (
857 SfxItemPresentation /*ePres*/,
858 MapUnit eCoreUnit,
859 MapUnit /*ePresUnit*/,
860 OUString& rText, const IntlWrapper& rIntl
861 ) const
862 {
863 if( MapUnit::MapRelative != ePropUnit )
864 {
865 rText = OUString::number( static_cast<short>(nProp) ) +
866 " " + EditResId( GetMetricId( ePropUnit ) );
867 if( 0 <= static_cast<short>(nProp) )
868 rText = "+" + rText;
869 }
870 else if( 100 == nProp )
871 {
872 rText = GetMetricText( static_cast<tools::Long>(nHeight),
873 eCoreUnit, MapUnit::MapPoint, &rIntl ) +
874 " " + EditResId(GetMetricId(MapUnit::MapPoint));
875 }
876 else
877 rText = OUString::number( nProp ) + "%";
878 return true;
879 }
880
881
882 void SvxFontHeightItem::ScaleMetrics( tools::Long nMult, tools::Long nDiv )
883 {
884 nHeight = static_cast<sal_uInt32>(BigInt::Scale( nHeight, nMult, nDiv ));
885 }
886
887
888 bool SvxFontHeightItem::HasMetrics() const
889 {
890 return true;
891 }
892
893 void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const sal_uInt16 nNewProp,
894 MapUnit eUnit )
895 {
896 DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
897
898 if( MapUnit::MapRelative != eUnit )
899 nHeight = nNewHeight + ::ItemToControl( short(nNewProp), eUnit,
900 FieldUnit::TWIP );
901 else if( 100 != nNewProp )
902 nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
903 else
904 nHeight = nNewHeight;
905
906 nProp = nNewProp;
907 ePropUnit = eUnit;
908 }
909
910 void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, sal_uInt16 nNewProp,
911 MapUnit eMetric, MapUnit eCoreMetric )
912 {
913 DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
914
915 if( MapUnit::MapRelative != eMetric )
916 nHeight = nNewHeight +
917 ::ControlToItem( ::ItemToControl(static_cast<short>(nNewProp), eMetric,
918 FieldUnit::TWIP ), FieldUnit::TWIP,
919 eCoreMetric );
920 else if( 100 != nNewProp )
921 nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
922 else
923 nHeight = nNewHeight;
924
925 nProp = nNewProp;
926 ePropUnit = eMetric;
927 }
928
929 void SvxFontHeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
930 {
931 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontHeightItem"));
932 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
933 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("height"), BAD_CAST(OString::number(nHeight).getStr()));
934 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("prop"), BAD_CAST(OString::number(nProp).getStr()));
935 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("propUnit"), BAD_CAST(OString::number(static_cast<int>(ePropUnit)).getStr()));
936 (void)xmlTextWriterEndElement(pWriter);
937 }
938
939 // class SvxTextLineItem ------------------------------------------------
940
941 SvxTextLineItem::SvxTextLineItem( const FontLineStyle eSt, const sal_uInt16 nId )
942 : SfxEnumItem(nId, eSt)
943 , maColor(COL_TRANSPARENT)
944 {
945 }
946
947
948 bool SvxTextLineItem::HasBoolValue() const
949 {
950 return true;
951 }
952
953
954 bool SvxTextLineItem::GetBoolValue() const
955 {
956 return GetValue() != LINESTYLE_NONE;
957 }
958
959
960 void SvxTextLineItem::SetBoolValue( bool bVal )
961 {
962 SetValue( bVal ? LINESTYLE_SINGLE : LINESTYLE_NONE );
963 }
964
965 SvxTextLineItem* SvxTextLineItem::Clone( SfxItemPool * ) const
966 {
967 return new SvxTextLineItem( *this );
968 }
969
970 sal_uInt16 SvxTextLineItem::GetValueCount() const
971 {
972 return LINESTYLE_DOTTED + 1; // LINESTYLE_NONE also belongs here
973 }
974
975
976 bool SvxTextLineItem::GetPresentation
977 (
978 SfxItemPresentation /*ePres*/,
979 MapUnit /*eCoreUnit*/,
980 MapUnit /*ePresUnit*/,
981 OUString& rText, const IntlWrapper& /*rIntl*/
982 ) const
983 {
984 rText = GetValueTextByPos( GetValue() );
985 if( !maColor.IsTransparent() )
986 rText += cpDelim + ::GetColorString(maColor);
987 return true;
988 }
989
990
991 OUString SvxTextLineItem::GetValueTextByPos( sal_uInt16 /*nPos*/ ) const
992 {
993 OSL_FAIL("SvxTextLineItem::GetValueTextByPos: Pure virtual method");
994 return OUString();
995 }
996
997 bool SvxTextLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
998 {
999 nMemberId &= ~CONVERT_TWIPS;
1000 switch(nMemberId)
1001 {
1002 case MID_TEXTLINED:
1003 rVal <<= GetBoolValue();
1004 break;
1005 case MID_TL_STYLE:
1006 rVal <<= static_cast<sal_Int16>(GetValue());
1007 break;
1008 case MID_TL_COLOR:
1009 rVal <<= maColor;
1010 break;
1011 case MID_TL_COMPLEX_COLOR:
1012 {
1013 auto xComplexColor = model::color::createXComplexColor(maComplexColor);
1014 rVal <<= xComplexColor;
1015 break;
1016 }
1017 case MID_TL_HASCOLOR:
1018 rVal <<= maColor.GetAlpha() == 255;
1019 break;
1020 }
1021 return true;
1022 }
1023
1024 bool SvxTextLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1025 {
1026 nMemberId &= ~CONVERT_TWIPS;
1027 bool bRet = true;
1028 switch(nMemberId)
1029 {
1030 case MID_TEXTLINED:
1031 SetBoolValue(Any2Bool(rVal));
1032 break;
1033 case MID_TL_STYLE:
1034 {
1035 sal_Int32 nValue = 0;
1036 if(!(rVal >>= nValue))
1037 bRet = false;
1038 else
1039 SetValue(static_cast<FontLineStyle>(nValue));
1040 }
1041 break;
1042 case MID_TL_COLOR:
1043 {
1044 Color nCol;
1045 if( !( rVal >>= nCol ) )
1046 bRet = false;
1047 else
1048 {
1049 // Keep transparence, because it contains the information
1050 // whether the font color or the stored color should be used
1051 sal_uInt8 nAlpha = maColor.GetAlpha();
1052 maColor = nCol;
1053 maColor.SetAlpha( nAlpha );
1054 }
1055 }
1056 break;
1057 case MID_TL_COMPLEX_COLOR:
1058 {
1059 css::uno::Reference<css::util::XComplexColor> xComplexColor;
1060 if (!(rVal >>= xComplexColor))
1061 return false;
1062
1063 if (xComplexColor.is())
1064 maComplexColor = model::color::getFromXComplexColor(xComplexColor);
1065 }
1066 break;
1067 case MID_TL_HASCOLOR:
1068 maColor.SetAlpha( Any2Bool( rVal ) ? 255 : 0 );
1069 break;
1070 }
1071 return bRet;
1072 }
1073
1074 bool SvxTextLineItem::operator==( const SfxPoolItem& rItem ) const
1075 {
1076 return SfxEnumItem::operator==( rItem ) &&
1077 maColor == static_cast<const SvxTextLineItem&>(rItem).maColor &&
1078 maComplexColor == static_cast<const SvxTextLineItem&>(rItem).maComplexColor;
1079 }
1080
1081 // class SvxUnderlineItem ------------------------------------------------
1082
1083
1084 SvxUnderlineItem::SvxUnderlineItem( const FontLineStyle eSt, const sal_uInt16 nId )
1085 : SvxTextLineItem( eSt, nId )
1086 {
1087 }
1088
1089 SvxUnderlineItem* SvxUnderlineItem::Clone( SfxItemPool * ) const
1090 {
1091 return new SvxUnderlineItem( *this );
1092 }
1093
1094 OUString SvxUnderlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
1095 {
1096 static TranslateId RID_SVXITEMS_UL[] =
1097 {
1098 RID_SVXITEMS_UL_NONE,
1099 RID_SVXITEMS_UL_SINGLE,
1100 RID_SVXITEMS_UL_DOUBLE,
1101 RID_SVXITEMS_UL_DOTTED,
1102 RID_SVXITEMS_UL_DONTKNOW,
1103 RID_SVXITEMS_UL_DASH,
1104 RID_SVXITEMS_UL_LONGDASH,
1105 RID_SVXITEMS_UL_DASHDOT,
1106 RID_SVXITEMS_UL_DASHDOTDOT,
1107 RID_SVXITEMS_UL_SMALLWAVE,
1108 RID_SVXITEMS_UL_WAVE,
1109 RID_SVXITEMS_UL_DOUBLEWAVE,
1110 RID_SVXITEMS_UL_BOLD,
1111 RID_SVXITEMS_UL_BOLDDOTTED,
1112 RID_SVXITEMS_UL_BOLDDASH,
1113 RID_SVXITEMS_UL_BOLDLONGDASH,
1114 RID_SVXITEMS_UL_BOLDDASHDOT,
1115 RID_SVXITEMS_UL_BOLDDASHDOTDOT,
1116 RID_SVXITEMS_UL_BOLDWAVE
1117 };
1118 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_UL) - 1 == LINESTYLE_BOLDWAVE, "must match");
1119 assert(nPos <= sal_uInt16(LINESTYLE_BOLDWAVE) && "enum overflow!");
1120 return EditResId(RID_SVXITEMS_UL[nPos]);
1121 }
1122
1123 // class SvxOverlineItem ------------------------------------------------
1124
1125 SvxOverlineItem::SvxOverlineItem( const FontLineStyle eSt, const sal_uInt16 nId )
1126 : SvxTextLineItem( eSt, nId )
1127 {
1128 }
1129
1130 SvxOverlineItem* SvxOverlineItem::Clone( SfxItemPool * ) const
1131 {
1132 return new SvxOverlineItem( *this );
1133 }
1134
1135 OUString SvxOverlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
1136 {
1137 static TranslateId RID_SVXITEMS_OL[] =
1138 {
1139 RID_SVXITEMS_OL_NONE,
1140 RID_SVXITEMS_OL_SINGLE,
1141 RID_SVXITEMS_OL_DOUBLE,
1142 RID_SVXITEMS_OL_DOTTED,
1143 RID_SVXITEMS_OL_DONTKNOW,
1144 RID_SVXITEMS_OL_DASH,
1145 RID_SVXITEMS_OL_LONGDASH,
1146 RID_SVXITEMS_OL_DASHDOT,
1147 RID_SVXITEMS_OL_DASHDOTDOT,
1148 RID_SVXITEMS_OL_SMALLWAVE,
1149 RID_SVXITEMS_OL_WAVE,
1150 RID_SVXITEMS_OL_DOUBLEWAVE,
1151 RID_SVXITEMS_OL_BOLD,
1152 RID_SVXITEMS_OL_BOLDDOTTED,
1153 RID_SVXITEMS_OL_BOLDDASH,
1154 RID_SVXITEMS_OL_BOLDLONGDASH,
1155 RID_SVXITEMS_OL_BOLDDASHDOT,
1156 RID_SVXITEMS_OL_BOLDDASHDOTDOT,
1157 RID_SVXITEMS_OL_BOLDWAVE
1158 };
1159 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_OL) - 1 == LINESTYLE_BOLDWAVE, "must match");
1160 assert(nPos <= sal_uInt16(LINESTYLE_BOLDWAVE) && "enum overflow!");
1161 return EditResId(RID_SVXITEMS_OL[nPos]);
1162 }
1163
1164 // class SvxCrossedOutItem -----------------------------------------------
1165
1166 SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const sal_uInt16 nId )
1167 : SfxEnumItem( nId, eSt )
1168 {
1169 }
1170
1171
1172 bool SvxCrossedOutItem::HasBoolValue() const
1173 {
1174 return true;
1175 }
1176
1177
1178 bool SvxCrossedOutItem::GetBoolValue() const
1179 {
1180 return GetValue() != STRIKEOUT_NONE;
1181 }
1182
1183
1184 void SvxCrossedOutItem::SetBoolValue( bool bVal )
1185 {
1186 SetValue( bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE );
1187 }
1188
1189
1190 sal_uInt16 SvxCrossedOutItem::GetValueCount() const
1191 {
1192 return STRIKEOUT_DOUBLE + 1; // STRIKEOUT_NONE belongs also here
1193 }
1194
1195 SvxCrossedOutItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const
1196 {
1197 return new SvxCrossedOutItem( *this );
1198 }
1199
1200 bool SvxCrossedOutItem::GetPresentation
1201 (
1202 SfxItemPresentation /*ePres*/,
1203 MapUnit /*eCoreUnit*/,
1204 MapUnit /*ePresUnit*/,
1205 OUString& rText, const IntlWrapper& /*rIntl*/
1206 ) const
1207 {
1208 rText = GetValueTextByPos( GetValue() );
1209 return true;
1210 }
1211
1212 OUString SvxCrossedOutItem::GetValueTextByPos( sal_uInt16 nPos )
1213 {
1214 static TranslateId RID_SVXITEMS_STRIKEOUT[] =
1215 {
1216 RID_SVXITEMS_STRIKEOUT_NONE,
1217 RID_SVXITEMS_STRIKEOUT_SINGLE,
1218 RID_SVXITEMS_STRIKEOUT_DOUBLE,
1219 RID_SVXITEMS_STRIKEOUT_DONTKNOW,
1220 RID_SVXITEMS_STRIKEOUT_BOLD,
1221 RID_SVXITEMS_STRIKEOUT_SLASH,
1222 RID_SVXITEMS_STRIKEOUT_X
1223 };
1224 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_STRIKEOUT) - 1 == STRIKEOUT_X, "must match");
1225 assert(nPos <= sal_uInt16(STRIKEOUT_X) && "enum overflow!");
1226 return EditResId(RID_SVXITEMS_STRIKEOUT[nPos]);
1227 }
1228
1229 bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1230 {
1231 nMemberId &= ~CONVERT_TWIPS;
1232 switch(nMemberId)
1233 {
1234 case MID_CROSSED_OUT:
1235 rVal <<= GetBoolValue();
1236 break;
1237 case MID_CROSS_OUT:
1238 rVal <<= static_cast<sal_Int16>(GetValue());
1239 break;
1240 }
1241 return true;
1242 }
1243
1244 bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1245 {
1246 nMemberId &= ~CONVERT_TWIPS;
1247 switch(nMemberId)
1248 {
1249 case MID_CROSSED_OUT:
1250 SetBoolValue(Any2Bool(rVal));
1251 break;
1252 case MID_CROSS_OUT:
1253 {
1254 sal_Int32 nValue = 0;
1255 if(!(rVal >>= nValue))
1256 return false;
1257 SetValue(static_cast<FontStrikeout>(nValue));
1258 }
1259 break;
1260 }
1261 return true;
1262 }
1263 // class SvxShadowedItem -------------------------------------------------
1264
1265 SvxShadowedItem::SvxShadowedItem( const bool bShadowed, const sal_uInt16 nId ) :
1266 SfxBoolItem( nId, bShadowed )
1267 {
1268 }
1269
1270 SvxShadowedItem* SvxShadowedItem::Clone( SfxItemPool * ) const
1271 {
1272 return new SvxShadowedItem( *this );
1273 }
1274
1275 bool SvxShadowedItem::GetPresentation
1276 (
1277 SfxItemPresentation /*ePres*/,
1278 MapUnit /*eCoreUnit*/,
1279 MapUnit /*ePresUnit*/,
1280 OUString& rText, const IntlWrapper& /*rIntl*/
1281 ) const
1282 {
1283 TranslateId pId = RID_SVXITEMS_SHADOWED_FALSE;
1284
1285 if ( GetValue() )
1286 pId = RID_SVXITEMS_SHADOWED_TRUE;
1287 rText = EditResId(pId);
1288 return true;
1289 }
1290
1291 // class SvxAutoKernItem -------------------------------------------------
1292
1293 SvxAutoKernItem::SvxAutoKernItem( const bool bAutoKern, const sal_uInt16 nId ) :
1294 SfxBoolItem( nId, bAutoKern )
1295 {
1296 }
1297
1298 SvxAutoKernItem* SvxAutoKernItem::Clone( SfxItemPool * ) const
1299 {
1300 return new SvxAutoKernItem( *this );
1301 }
1302
1303 bool SvxAutoKernItem::GetPresentation
1304 (
1305 SfxItemPresentation /*ePres*/,
1306 MapUnit /*eCoreUnit*/,
1307 MapUnit /*ePresUnit*/,
1308 OUString& rText, const IntlWrapper& /*rIntl*/
1309 ) const
1310 {
1311 TranslateId pId = RID_SVXITEMS_AUTOKERN_FALSE;
1312
1313 if ( GetValue() )
1314 pId = RID_SVXITEMS_AUTOKERN_TRUE;
1315 rText = EditResId(pId);
1316 return true;
1317 }
1318
1319 // class SvxWordLineModeItem ---------------------------------------------
1320
1321 SvxWordLineModeItem::SvxWordLineModeItem( const bool bWordLineMode,
1322 const sal_uInt16 nId ) :
1323 SfxBoolItem( nId, bWordLineMode )
1324 {
1325 }
1326
1327 SvxWordLineModeItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const
1328 {
1329 return new SvxWordLineModeItem( *this );
1330 }
1331
1332 bool SvxWordLineModeItem::GetPresentation
1333 (
1334 SfxItemPresentation /*ePres*/,
1335 MapUnit /*eCoreUnit*/,
1336 MapUnit /*ePresUnit*/,
1337 OUString& rText, const IntlWrapper& /*rIntl*/
1338 ) const
1339 {
1340 TranslateId pId = RID_SVXITEMS_WORDLINE_FALSE;
1341
1342 if ( GetValue() )
1343 pId = RID_SVXITEMS_WORDLINE_TRUE;
1344 rText = EditResId(pId);
1345 return true;
1346 }
1347
1348 // class SvxContourItem --------------------------------------------------
1349
1350 SvxContourItem::SvxContourItem( const bool bContoured, const sal_uInt16 nId ) :
1351 SfxBoolItem( nId, bContoured )
1352 {
1353 }
1354
1355 SvxContourItem* SvxContourItem::Clone( SfxItemPool * ) const
1356 {
1357 return new SvxContourItem( *this );
1358 }
1359
1360 bool SvxContourItem::GetPresentation
1361 (
1362 SfxItemPresentation /*ePres*/,
1363 MapUnit /*eCoreUnit*/,
1364 MapUnit /*ePresUnit*/,
1365 OUString& rText, const IntlWrapper& /*rIntl*/
1366 ) const
1367 {
1368 TranslateId pId = RID_SVXITEMS_CONTOUR_FALSE;
1369
1370 if ( GetValue() )
1371 pId = RID_SVXITEMS_CONTOUR_TRUE;
1372 rText = EditResId(pId);
1373 return true;
1374 }
1375
1376 // class SvxColorItem ----------------------------------------------------
1377 SvxColorItem::SvxColorItem( const sal_uInt16 nId ) :
1378 SfxPoolItem(nId),
1379 mColor( COL_BLACK )
1380 {
1381 }
1382
1383 SvxColorItem::SvxColorItem( const Color& rCol, const sal_uInt16 nId ) :
1384 SfxPoolItem( nId ),
1385 mColor( rCol )
1386 {
1387 }
1388
1389 SvxColorItem::SvxColorItem(Color const& rColor, model::ComplexColor const& rComplexColor, const sal_uInt16 nId)
1390 : SfxPoolItem(nId)
1391 , mColor(rColor)
1392 , maComplexColor(rComplexColor)
1393 {
1394 }
1395
1396 SvxColorItem::~SvxColorItem()
1397 {
1398 }
1399
1400 bool SvxColorItem::operator==( const SfxPoolItem& rAttr ) const
1401 {
1402 assert(SfxPoolItem::operator==(rAttr));
1403 const SvxColorItem& rColorItem = static_cast<const SvxColorItem&>(rAttr);
1404
1405 return mColor == rColorItem.mColor &&
1406 maComplexColor == rColorItem.maComplexColor;
1407 }
1408
1409 bool SvxColorItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1410 {
1411 nMemberId &= ~CONVERT_TWIPS;
1412 switch (nMemberId)
1413 {
1414 case MID_COLOR_ALPHA:
1415 {
1416 auto fTransparency = static_cast<double>(255 - mColor.GetAlpha()) * 100 / 255;
1417 rVal <<= static_cast<sal_Int16>(basegfx::fround(fTransparency));
1418 break;
1419 }
1420 case MID_GRAPHIC_TRANSPARENT:
1421 {
1422 rVal <<= mColor.GetAlpha() == 0;
1423 break;
1424 }
1425 case MID_COLOR_THEME_INDEX:
1426 {
1427 rVal <<= sal_Int16(maComplexColor.meSchemeType);
1428 break;
1429 }
1430 case MID_COLOR_TINT_OR_SHADE:
1431 {
1432 sal_Int16 nValue = 0;
1433 for (auto const& rTransform : maComplexColor.getTransformations())
1434 {
1435 if (rTransform.meType == model::TransformationType::Tint)
1436 nValue = rTransform.mnValue;
1437 else if (rTransform.meType == model::TransformationType::Shade)
1438 nValue = -rTransform.mnValue;
1439 }
1440 rVal <<= nValue;
1441 break;
1442 }
1443 case MID_COLOR_LUM_MOD:
1444 {
1445 sal_Int16 nValue = 10000;
1446 for (auto const& rTransform : maComplexColor.getTransformations())
1447 {
1448 if (rTransform.meType == model::TransformationType::LumMod)
1449 nValue = rTransform.mnValue;
1450 }
1451 rVal <<= nValue;
1452 break;
1453 }
1454 case MID_COLOR_LUM_OFF:
1455 {
1456 sal_Int16 nValue = 0;
1457 for (auto const& rTransform : maComplexColor.getTransformations())
1458 {
1459 if (rTransform.meType == model::TransformationType::LumOff)
1460 nValue = rTransform.mnValue;
1461 }
1462 rVal <<= nValue;
1463 break;
1464 }
1465 case MID_COMPLEX_COLOR_JSON:
1466 {
1467 rVal <<= OStringToOUString(model::color::convertToJSON(maComplexColor), RTL_TEXTENCODING_UTF8);
1468 break;
1469 }
1470 case MID_COMPLEX_COLOR:
1471 {
1472 auto xComplexColor = model::color::createXComplexColor(maComplexColor);
1473 rVal <<= xComplexColor;
1474 break;
1475 }
1476 case MID_COLOR_RGB:
1477 default:
1478 {
1479 rVal <<= mColor;
1480 break;
1481 }
1482 }
1483 return true;
1484 }
1485
1486 bool SvxColorItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1487 {
1488 nMemberId &= ~CONVERT_TWIPS;
1489 switch(nMemberId)
1490 {
1491 case MID_COLOR_ALPHA:
1492 {
1493 sal_Int16 nTransparency = 0;
1494 bool bRet = rVal >>= nTransparency;
1495 if (bRet)
1496 {
1497 auto fTransparency = static_cast<double>(nTransparency) * 255 / 100;
1498 mColor.SetAlpha(255 - static_cast<sal_uInt8>(basegfx::fround(fTransparency)));
1499 }
1500 return bRet;
1501 }
1502 case MID_GRAPHIC_TRANSPARENT:
1503 {
1504 mColor.SetAlpha( Any2Bool( rVal ) ? 0 : 255 );
1505 return true;
1506 }
1507 case MID_COLOR_THEME_INDEX:
1508 {
1509 sal_Int16 nIndex = -1;
1510 if (!(rVal >>= nIndex))
1511 return false;
1512 maComplexColor.setSchemeColor(model::convertToThemeColorType(nIndex));
1513 }
1514 break;
1515 case MID_COLOR_TINT_OR_SHADE:
1516 {
1517 sal_Int16 nTintShade = 0;
1518 if (!(rVal >>= nTintShade))
1519 return false;
1520
1521 maComplexColor.removeTransformations(model::TransformationType::Tint);
1522 maComplexColor.removeTransformations(model::TransformationType::Shade);
1523
1524 if (nTintShade > 0)
1525 maComplexColor.addTransformation({model::TransformationType::Tint, nTintShade});
1526 else if (nTintShade < 0)
1527 {
1528 sal_Int16 nShade = o3tl::narrowing<sal_Int16>(-nTintShade);
1529 maComplexColor.addTransformation({model::TransformationType::Shade, nShade});
1530 }
1531 }
1532 break;
1533 case MID_COLOR_LUM_MOD:
1534 {
1535 sal_Int16 nLumMod = 10000;
1536 if (!(rVal >>= nLumMod))
1537 return false;
1538 maComplexColor.removeTransformations(model::TransformationType::LumMod);
1539 maComplexColor.addTransformation({model::TransformationType::LumMod, nLumMod});
1540 }
1541 break;
1542 case MID_COLOR_LUM_OFF:
1543 {
1544 sal_Int16 nLumOff = 0;
1545 if (!(rVal >>= nLumOff))
1546 return false;
1547 maComplexColor.removeTransformations(model::TransformationType::LumOff);
1548 maComplexColor.addTransformation({model::TransformationType::LumOff, nLumOff});
1549 }
1550 break;
1551 case MID_COMPLEX_COLOR_JSON:
1552 {
1553 OUString sComplexColorJson;
1554 if (!(rVal >>= sComplexColorJson))
1555 return false;
1556
1557 if (sComplexColorJson.isEmpty())
1558 return false;
1559
1560 OString aJSON = OUStringToOString(sComplexColorJson, RTL_TEXTENCODING_ASCII_US);
1561 if (!model::color::convertFromJSON(aJSON, maComplexColor))
1562 return false;
1563 }
1564 break;
1565 case MID_COMPLEX_COLOR:
1566 {
1567 css::uno::Reference<css::util::XComplexColor> xComplexColor;
1568 if (!(rVal >>= xComplexColor))
1569 return false;
1570
1571 if (xComplexColor.is())
1572 maComplexColor = model::color::getFromXComplexColor(xComplexColor);
1573 }
1574 break;
1575 case MID_COLOR_RGB:
1576 default:
1577 {
1578 if (!(rVal >>= mColor))
1579 return false;
1580 }
1581 break;
1582 }
1583 return true;
1584 }
1585
1586 SvxColorItem* SvxColorItem::Clone( SfxItemPool * ) const
1587 {
1588 return new SvxColorItem( *this );
1589 }
1590
1591 bool SvxColorItem::GetPresentation
1592 (
1593 SfxItemPresentation /*ePres*/,
1594 MapUnit /*eCoreUnit*/,
1595 MapUnit /*ePresUnit*/,
1596 OUString& rText, const IntlWrapper& /*rIntl*/
1597 ) const
1598 {
1599 rText = ::GetColorString( mColor );
1600 return true;
1601 }
1602
1603 void SvxColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
1604 {
1605 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxColorItem"));
1606 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1607
1608 std::stringstream ss;
1609 ss << mColor;
1610 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(ss.str().c_str()));
1611
1612 OUString aStr;
1613 IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
1614 GetPresentation( SfxItemPresentation::Complete, MapUnit::Map100thMM, MapUnit::Map100thMM, aStr, aIntlWrapper);
1615 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(OUStringToOString(aStr, RTL_TEXTENCODING_UTF8).getStr()));
1616
1617 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("complex-color"));
1618
1619 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"),
1620 BAD_CAST(OString::number(sal_Int16(maComplexColor.meType)).getStr()));
1621
1622 for (auto const& rTransform : maComplexColor.getTransformations())
1623 {
1624 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("transformation"));
1625 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"),
1626 BAD_CAST(OString::number(sal_Int16(rTransform.meType)).getStr()));
1627 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
1628 BAD_CAST(OString::number(rTransform.mnValue).getStr()));
1629 (void)xmlTextWriterEndElement(pWriter);
1630 }
1631
1632 (void)xmlTextWriterEndElement(pWriter);
1633
1634 (void)xmlTextWriterEndElement(pWriter);
1635 }
1636
1637 // class SvxKerningItem --------------------------------------------------
1638
1639 SvxKerningItem::SvxKerningItem( const short nKern, const sal_uInt16 nId ) :
1640 SfxInt16Item( nId, nKern )
1641 {
1642 }
1643
1644 SvxKerningItem* SvxKerningItem::Clone( SfxItemPool * ) const
1645 {
1646 return new SvxKerningItem( *this );
1647 }
1648
1649 void SvxKerningItem::ScaleMetrics( tools::Long nMult, tools::Long nDiv )
1650 {
1651 SetValue( static_cast<sal_Int16>(BigInt::Scale( GetValue(), nMult, nDiv )) );
1652 }
1653
1654
1655 bool SvxKerningItem::HasMetrics() const
1656 {
1657 return true;
1658 }
1659
1660
1661 bool SvxKerningItem::GetPresentation
1662 (
1663 SfxItemPresentation ePres,
1664 MapUnit eCoreUnit,
1665 MapUnit /*ePresUnit*/,
1666 OUString& rText, const IntlWrapper& rIntl
1667 ) const
1668 {
1669 switch ( ePres )
1670 {
1671 case SfxItemPresentation::Nameless:
1672 rText = GetMetricText( static_cast<tools::Long>(GetValue()), eCoreUnit, MapUnit::MapPoint, &rIntl ) +
1673 " " + EditResId(GetMetricId(MapUnit::MapPoint));
1674 return true;
1675 case SfxItemPresentation::Complete:
1676 {
1677 rText = EditResId(RID_SVXITEMS_KERNING_COMPLETE);
1678 TranslateId pId;
1679
1680 if ( GetValue() > 0 )
1681 pId = RID_SVXITEMS_KERNING_EXPANDED;
1682 else if ( GetValue() < 0 )
1683 pId = RID_SVXITEMS_KERNING_CONDENSED;
1684
1685 if (pId)
1686 rText += EditResId(pId);
1687 rText += GetMetricText( static_cast<tools::Long>(GetValue()), eCoreUnit, MapUnit::MapPoint, &rIntl ) +
1688 " " + EditResId(GetMetricId(MapUnit::MapPoint));
1689 return true;
1690 }
1691 default: ; //prevent warning
1692 }
1693 return false;
1694 }
1695
1696 bool SvxKerningItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1697 {
1698 sal_Int16 nVal = GetValue();
1699 if(nMemberId & CONVERT_TWIPS)
1700 nVal = static_cast<sal_Int16>(convertTwipToMm100(nVal));
1701 rVal <<= nVal;
1702 return true;
1703 }
1704
1705 bool SvxKerningItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
1706 {
1707 sal_Int16 nVal = sal_Int16();
1708 if(!(rVal >>= nVal))
1709 return false;
1710 if(nMemberId & CONVERT_TWIPS)
1711 nVal = o3tl::toTwips(nVal, o3tl::Length::mm100);
1712 SetValue(nVal);
1713 return true;
1714 }
1715
1716 // class SvxCaseMapItem --------------------------------------------------
1717
1718 SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const sal_uInt16 nId ) :
1719 SfxEnumItem( nId, eMap )
1720 {
1721 }
1722
1723 sal_uInt16 SvxCaseMapItem::GetValueCount() const
1724 {
1725 return sal_uInt16(SvxCaseMap::End); // SvxCaseMap::SmallCaps + 1
1726 }
1727
1728 SvxCaseMapItem* SvxCaseMapItem::Clone( SfxItemPool * ) const
1729 {
1730 return new SvxCaseMapItem( *this );
1731 }
1732
1733 bool SvxCaseMapItem::GetPresentation
1734 (
1735 SfxItemPresentation /*ePres*/,
1736 MapUnit /*eCoreUnit*/,
1737 MapUnit /*ePresUnit*/,
1738 OUString& rText, const IntlWrapper& /*rIntl*/
1739 ) const
1740 {
1741 rText = GetValueTextByPos( static_cast<sal_uInt16>(GetValue()) );
1742 return true;
1743 }
1744
1745 OUString SvxCaseMapItem::GetValueTextByPos( sal_uInt16 nPos )
1746 {
1747 static TranslateId RID_SVXITEMS_CASEMAP[] =
1748 {
1749 RID_SVXITEMS_CASEMAP_NONE,
1750 RID_SVXITEMS_CASEMAP_UPPERCASE,
1751 RID_SVXITEMS_CASEMAP_LOWERCASE,
1752 RID_SVXITEMS_CASEMAP_TITLE,
1753 RID_SVXITEMS_CASEMAP_SMALLCAPS
1754 };
1755
1756 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_CASEMAP) == size_t(SvxCaseMap::End), "must match");
1757 assert(nPos < sal_uInt16(SvxCaseMap::End) && "enum overflow!");
1758 return EditResId(RID_SVXITEMS_CASEMAP[nPos]);
1759 }
1760
1761 bool SvxCaseMapItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
1762 {
1763 sal_Int16 nRet = style::CaseMap::NONE;
1764 switch( GetValue() )
1765 {
1766 case SvxCaseMap::Uppercase : nRet = style::CaseMap::UPPERCASE; break;
1767 case SvxCaseMap::Lowercase : nRet = style::CaseMap::LOWERCASE; break;
1768 case SvxCaseMap::Capitalize : nRet = style::CaseMap::TITLE ; break;
1769 case SvxCaseMap::SmallCaps: nRet = style::CaseMap::SMALLCAPS; break;
1770 default: break;
1771 }
1772 rVal <<= nRet;
1773 return true;
1774 }
1775
1776 bool SvxCaseMapItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
1777 {
1778 sal_uInt16 nVal = sal_uInt16();
1779 if(!(rVal >>= nVal))
1780 return false;
1781
1782 SvxCaseMap eVal;
1783 switch( nVal )
1784 {
1785 case style::CaseMap::NONE : eVal = SvxCaseMap::NotMapped; break;
1786 case style::CaseMap::UPPERCASE: eVal = SvxCaseMap::Uppercase; break;
1787 case style::CaseMap::LOWERCASE: eVal = SvxCaseMap::Lowercase; break;
1788 case style::CaseMap::TITLE : eVal = SvxCaseMap::Capitalize; break;
1789 case style::CaseMap::SMALLCAPS: eVal = SvxCaseMap::SmallCaps; break;
1790 default: return false;
1791 }
1792 SetValue(eVal);
1793 return true;
1794 }
1795
1796 // class SvxEscapementItem -----------------------------------------------
1797
1798 SvxEscapementItem::SvxEscapementItem( const sal_uInt16 nId ) :
1799 SfxEnumItemInterface( nId ),
1800
1801 nEsc ( 0 ),
1802 nProp ( 100 )
1803 {
1804 }
1805
1806
1807 SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
1808 const sal_uInt16 nId ) :
1809 SfxEnumItemInterface( nId ),
1810 nProp( 100 )
1811 {
1812 SetEscapement( eEscape );
1813 if( nEsc )
1814 nProp = DFLT_ESC_PROP;
1815 }
1816
1817
1818 SvxEscapementItem::SvxEscapementItem( const short _nEsc,
1819 const sal_uInt8 _nProp,
1820 const sal_uInt16 nId ) :
1821 SfxEnumItemInterface( nId ),
1822 nEsc ( _nEsc ),
1823 nProp ( _nProp )
1824 {
1825 }
1826
1827
1828 bool SvxEscapementItem::operator==( const SfxPoolItem& rAttr ) const
1829 {
1830 assert(SfxPoolItem::operator==(rAttr));
1831
1832 return( nEsc == static_cast<const SvxEscapementItem&>(rAttr).nEsc &&
1833 nProp == static_cast<const SvxEscapementItem&>(rAttr).nProp );
1834 }
1835
1836 SvxEscapementItem* SvxEscapementItem::Clone( SfxItemPool * ) const
1837 {
1838 return new SvxEscapementItem( *this );
1839 }
1840
1841 sal_uInt16 SvxEscapementItem::GetValueCount() const
1842 {
1843 return sal_uInt16(SvxEscapement::End); // SvxEscapement::Subscript + 1
1844 }
1845
1846
1847 bool SvxEscapementItem::GetPresentation
1848 (
1849 SfxItemPresentation /*ePres*/,
1850 MapUnit /*eCoreUnit*/,
1851 MapUnit /*ePresUnit*/,
1852 OUString& rText, const IntlWrapper& /*rIntl*/
1853 ) const
1854 {
1855 rText = GetValueTextByPos( GetEnumValue() );
1856
1857 if ( nEsc != 0 )
1858 {
1859 if( DFLT_ESC_AUTO_SUPER == nEsc || DFLT_ESC_AUTO_SUB == nEsc )
1860 rText += EditResId(RID_SVXITEMS_ESCAPEMENT_AUTO);
1861 else
1862 rText += OUString::number( nEsc ) + "%";
1863 }
1864 return true;
1865 }
1866
1867 OUString SvxEscapementItem::GetValueTextByPos( sal_uInt16 nPos )
1868 {
1869 static TranslateId RID_SVXITEMS_ESCAPEMENT[] =
1870 {
1871 RID_SVXITEMS_ESCAPEMENT_OFF,
1872 RID_SVXITEMS_ESCAPEMENT_SUPER,
1873 RID_SVXITEMS_ESCAPEMENT_SUB
1874 };
1875
1876 static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_ESCAPEMENT) == size_t(SvxEscapement::End), "must match");
1877 assert(nPos < sal_uInt16(SvxEscapement::End) && "enum overflow!");
1878 return EditResId(RID_SVXITEMS_ESCAPEMENT[nPos]);
1879 }
1880
1881 sal_uInt16 SvxEscapementItem::GetEnumValue() const
1882 {
1883 if ( nEsc < 0 )
1884 return sal_uInt16(SvxEscapement::Subscript);
1885 else if ( nEsc > 0 )
1886 return sal_uInt16(SvxEscapement::Superscript);
1887 return sal_uInt16(SvxEscapement::Off);
1888 }
1889
1890
1891 void SvxEscapementItem::SetEnumValue( sal_uInt16 nVal )
1892 {
1893 SetEscapement( static_cast<SvxEscapement>(nVal) );
1894 }
1895
1896 bool SvxEscapementItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1897 {
1898 nMemberId &= ~CONVERT_TWIPS;
1899 switch(nMemberId)
1900 {
1901 case MID_ESC:
1902 rVal <<= static_cast<sal_Int16>(nEsc);
1903 break;
1904 case MID_ESC_HEIGHT:
1905 rVal <<= static_cast<sal_Int8>(nProp);
1906 break;
1907 case MID_AUTO_ESC:
1908 rVal <<= (DFLT_ESC_AUTO_SUB == nEsc || DFLT_ESC_AUTO_SUPER == nEsc);
1909 break;
1910 }
1911 return true;
1912 }
1913
1914 bool SvxEscapementItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
1915 {
1916 nMemberId &= ~CONVERT_TWIPS;
1917 switch(nMemberId)
1918 {
1919 case MID_ESC:
1920 {
1921 sal_Int16 nVal = sal_Int16();
1922 if( (rVal >>= nVal) && (std::abs(nVal) <= MAX_ESC_POS+1))
1923 nEsc = nVal;
1924 else
1925 return false;
1926 }
1927 break;
1928 case MID_ESC_HEIGHT:
1929 {
1930 sal_Int8 nVal = sal_Int8();
1931 if( (rVal >>= nVal) && (nVal <= 100))
1932 nProp = nVal;
1933 else
1934 return false;
1935 }
1936 break;
1937 case MID_AUTO_ESC:
1938 {
1939 bool bVal = Any2Bool(rVal);
1940 if(bVal)
1941 {
1942 if(nEsc < 0)
1943 nEsc = DFLT_ESC_AUTO_SUB;
1944 else
1945 nEsc = DFLT_ESC_AUTO_SUPER;
1946 }
1947 else
1948 if(DFLT_ESC_AUTO_SUPER == nEsc )
1949 --nEsc;
1950 else if(DFLT_ESC_AUTO_SUB == nEsc)
1951 ++nEsc;
1952 }
1953 break;
1954 }
1955 return true;
1956 }
1957
1958 // class SvxLanguageItem -------------------------------------------------
1959
1960 SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const sal_uInt16 nId )
1961 : SvxLanguageItem_Base( nId , eLang )
1962 {
1963 }
1964
1965
1966 sal_uInt16 SvxLanguageItem::GetValueCount() const
1967 {
1968 // #i50205# got rid of class International
1969 SAL_WARN( "editeng.items", "SvxLanguageItem::GetValueCount: supposed to return a count of what?");
1970 // Could be SvtLanguageTable::GetEntryCount() (all locales with resource string)?
1971 // Could be LocaleDataWrapper::getInstalledLanguageTypes() (all locales with locale data)?
1972 return 0;
1973 }
1974
1975 SvxLanguageItem* SvxLanguageItem::Clone( SfxItemPool * ) const
1976 {
1977 return new SvxLanguageItem( *this );
1978 }
1979
1980 bool SvxLanguageItem::GetPresentation
1981 (
1982 SfxItemPresentation /*ePres*/,
1983 MapUnit /*eCoreUnit*/,
1984 MapUnit /*ePresUnit*/,
1985 OUString& rText, const IntlWrapper& /*rIntl*/
1986 ) const
1987 {
1988 rText = SvtLanguageTable::GetLanguageString( GetValue() );
1989 return true;
1990 }
1991
1992 bool SvxLanguageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
1993 {
1994 nMemberId &= ~CONVERT_TWIPS;
1995 switch(nMemberId)
1996 {
1997 case MID_LANG_INT: // for basic conversions!
1998 rVal <<= static_cast<sal_Int16>(static_cast<sal_uInt16>(GetValue()));
1999 break;
2000 case MID_LANG_LOCALE:
2001 lang::Locale aRet( LanguageTag::convertToLocale( GetValue(), false));
2002 rVal <<= aRet;
2003 break;
2004 }
2005 return true;
2006 }
2007
2008 bool SvxLanguageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2009 {
2010 nMemberId &= ~CONVERT_TWIPS;
2011 switch(nMemberId)
2012 {
2013 case MID_LANG_INT: // for basic conversions!
2014 {
2015 sal_Int32 nValue = 0;
2016 if(!(rVal >>= nValue))
2017 return false;
2018
2019 SetValue(LanguageType(nValue));
2020 }
2021 break;
2022 case MID_LANG_LOCALE:
2023 {
2024 lang::Locale aLocale;
2025 if(!(rVal >>= aLocale))
2026 return false;
2027
2028 SetValue( LanguageTag::convertToLanguageType( aLocale, false));
2029 }
2030 break;
2031 }
2032 return true;
2033 }
2034
2035 // class SvxNoHyphenItem -------------------------------------------------
2036
2037 SvxNoHyphenItem::SvxNoHyphenItem( const sal_uInt16 nId ) :
2038 SfxBoolItem( nId , true )
2039 {
2040 }
2041
2042 SvxNoHyphenItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const
2043 {
2044 return new SvxNoHyphenItem( *this );
2045 }
2046
2047 bool SvxNoHyphenItem::GetPresentation
2048 (
2049 SfxItemPresentation /*ePres*/,
2050 MapUnit /*eCoreUnit*/,
2051 MapUnit /*ePresUnit*/,
2052 OUString& rText, const IntlWrapper& /*rIntl*/
2053 ) const
2054 {
2055 rText.clear();
2056 return false;
2057 }
2058
2059 /*
2060 * Dummy item for ToolBox controls:
2061 *
2062 */
2063
2064
2065 // class SvxBlinkItem -------------------------------------------------
2066
2067
2068 SvxBlinkItem::SvxBlinkItem( const bool bBlink, const sal_uInt16 nId ) :
2069 SfxBoolItem( nId, bBlink )
2070 {
2071 }
2072
2073 SvxBlinkItem* SvxBlinkItem::Clone( SfxItemPool * ) const
2074 {
2075 return new SvxBlinkItem( *this );
2076 }
2077
2078 bool SvxBlinkItem::GetPresentation
2079 (
2080 SfxItemPresentation /*ePres*/,
2081 MapUnit /*eCoreUnit*/,
2082 MapUnit /*ePresUnit*/,
2083 OUString& rText, const IntlWrapper& /*rIntl*/
2084 ) const
2085 {
2086 TranslateId pId = RID_SVXITEMS_BLINK_FALSE;
2087
2088 if ( GetValue() )
2089 pId = RID_SVXITEMS_BLINK_TRUE;
2090 rText = EditResId(pId);
2091 return true;
2092 }
2093
2094 // class SvxEmphaisMarkItem ---------------------------------------------------
2095
2096 SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue,
2097 TypedWhichId<SvxEmphasisMarkItem> nId )
2098 : SfxUInt16Item( nId, static_cast<sal_uInt16>(nValue) )
2099 {
2100 }
2101
2102 SvxEmphasisMarkItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const
2103 {
2104 return new SvxEmphasisMarkItem( *this );
2105 }
2106
2107 bool SvxEmphasisMarkItem::GetPresentation
2108 (
2109 SfxItemPresentation /*ePres*/,
2110 MapUnit /*eCoreUnit*/,
2111 MapUnit /*ePresUnit*/,
2112 OUString& rText,
2113 const IntlWrapper& /*rIntl*/
2114 ) const
2115 {
2116 static TranslateId RID_SVXITEMS_EMPHASIS[] =
2117 {
2118 RID_SVXITEMS_EMPHASIS_NONE_STYLE,
2119 RID_SVXITEMS_EMPHASIS_DOT_STYLE,
2120 RID_SVXITEMS_EMPHASIS_CIRCLE_STYLE,
2121 RID_SVXITEMS_EMPHASIS_DISC_STYLE,
2122 RID_SVXITEMS_EMPHASIS_ACCENT_STYLE
2123 };
2124
2125 FontEmphasisMark nVal = GetEmphasisMark();
2126 rText = EditResId(RID_SVXITEMS_EMPHASIS[
2127 static_cast<sal_uInt16>(static_cast<FontEmphasisMark>( nVal & FontEmphasisMark::Style ))]);
2128 TranslateId pId = ( FontEmphasisMark::PosAbove & nVal )
2129 ? RID_SVXITEMS_EMPHASIS_ABOVE_POS
2130 : ( FontEmphasisMark::PosBelow & nVal )
2131 ? RID_SVXITEMS_EMPHASIS_BELOW_POS
2132 : TranslateId();
2133 if( pId )
2134 rText += EditResId( pId );
2135 return true;
2136 }
2137
2138 bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
2139 {
2140 nMemberId &= ~CONVERT_TWIPS;
2141 switch( nMemberId )
2142 {
2143 case MID_EMPHASIS:
2144 {
2145 FontEmphasisMark nValue = GetEmphasisMark();
2146 sal_Int16 nRet = 0;
2147 switch(nValue & FontEmphasisMark::Style)
2148 {
2149 case FontEmphasisMark::NONE : nRet = FontEmphasis::NONE; break;
2150 case FontEmphasisMark::Dot : nRet = FontEmphasis::DOT_ABOVE; break;
2151 case FontEmphasisMark::Circle : nRet = FontEmphasis::CIRCLE_ABOVE; break;
2152 case FontEmphasisMark::Disc : nRet = FontEmphasis::DISK_ABOVE; break;
2153 case FontEmphasisMark::Accent : nRet = FontEmphasis::ACCENT_ABOVE; break;
2154 default: break;
2155 }
2156 if(nRet && nValue & FontEmphasisMark::PosBelow)
2157 nRet += 10;
2158 rVal <<= nRet;
2159 }
2160 break;
2161 }
2162 return true;
2163 }
2164
2165 bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
2166 {
2167 nMemberId &= ~CONVERT_TWIPS;
2168 switch( nMemberId )
2169 {
2170 case MID_EMPHASIS:
2171 {
2172 sal_Int32 nValue = -1;
2173 rVal >>= nValue;
2174 FontEmphasisMark nMark;
2175 switch(nValue)
2176 {
2177 case FontEmphasis::NONE : nMark = FontEmphasisMark::NONE; break;
2178 case FontEmphasis::DOT_ABOVE : nMark = FontEmphasisMark::Dot|FontEmphasisMark::PosAbove; break;
2179 case FontEmphasis::CIRCLE_ABOVE: nMark = FontEmphasisMark::Circle|FontEmphasisMark::PosAbove; break;
2180 case FontEmphasis::DISK_ABOVE : nMark = FontEmphasisMark::Disc|FontEmphasisMark::PosAbove; break;
2181 case FontEmphasis::ACCENT_ABOVE: nMark = FontEmphasisMark::Accent|FontEmphasisMark::PosAbove; break;
2182 case FontEmphasis::DOT_BELOW : nMark = FontEmphasisMark::Dot|FontEmphasisMark::PosBelow; break;
2183 case FontEmphasis::CIRCLE_BELOW: nMark = FontEmphasisMark::Circle|FontEmphasisMark::PosBelow; break;
2184 case FontEmphasis::DISK_BELOW : nMark = FontEmphasisMark::Disc|FontEmphasisMark::PosBelow; break;
2185 case FontEmphasis::ACCENT_BELOW: nMark = FontEmphasisMark::Accent|FontEmphasisMark::PosBelow; break;
2186 default: return false;
2187 }
2188 SetValue( static_cast<sal_Int16>(nMark) );
2189 }
2190 break;
2191 }
2192 return true;
2193 }
2194
2195 /*************************************************************************
2196 |* class SvxTwoLinesItem
2197 *************************************************************************/
2198
2199 SvxTwoLinesItem::SvxTwoLinesItem( bool bFlag, sal_Unicode nStartBracket,
2200 sal_Unicode nEndBracket, sal_uInt16 nW )
2201 : SfxPoolItem( nW ),
2202 cStartBracket( nStartBracket ), cEndBracket( nEndBracket ), bOn( bFlag )
2203 {
2204 }
2205
2206 SvxTwoLinesItem::~SvxTwoLinesItem()
2207 {
2208 }
2209
2210 bool SvxTwoLinesItem::operator==( const SfxPoolItem& rAttr ) const
2211 {
2212 assert(SfxPoolItem::operator==(rAttr));
2213 return bOn == static_cast<const SvxTwoLinesItem&>(rAttr).bOn &&
2214 cStartBracket == static_cast<const SvxTwoLinesItem&>(rAttr).cStartBracket &&
2215 cEndBracket == static_cast<const SvxTwoLinesItem&>(rAttr).cEndBracket;
2216 }
2217
2218 SvxTwoLinesItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const
2219 {
2220 return new SvxTwoLinesItem( *this );
2221 }
2222
2223 bool SvxTwoLinesItem::QueryValue( css::uno::Any& rVal,
2224 sal_uInt8 nMemberId ) const
2225 {
2226 nMemberId &= ~CONVERT_TWIPS;
2227 bool bRet = true;
2228 switch( nMemberId )
2229 {
2230 case MID_TWOLINES:
2231 rVal <<= bOn;
2232 break;
2233 case MID_START_BRACKET:
2234 {
2235 OUString s;
2236 if( cStartBracket )
2237 s = OUString( cStartBracket );
2238 rVal <<= s;
2239 }
2240 break;
2241 case MID_END_BRACKET:
2242 {
2243 OUString s;
2244 if( cEndBracket )
2245 s = OUString( cEndBracket );
2246 rVal <<= s;
2247 }
2248 break;
2249 default:
2250 bRet = false;
2251 break;
2252 }
2253 return bRet;
2254 }
2255
2256 bool SvxTwoLinesItem::PutValue( const css::uno::Any& rVal,
2257 sal_uInt8 nMemberId )
2258 {
2259 nMemberId &= ~CONVERT_TWIPS;
2260 bool bRet = false;
2261 OUString s;
2262 switch( nMemberId )
2263 {
2264 case MID_TWOLINES:
2265 bOn = Any2Bool( rVal );
2266 bRet = true;
2267 break;
2268 case MID_START_BRACKET:
2269 if( rVal >>= s )
2270 {
2271 cStartBracket = s.isEmpty() ? 0 : s[ 0 ];
2272 bRet = true;
2273 }
2274 break;
2275 case MID_END_BRACKET:
2276 if( rVal >>= s )
2277 {
2278 cEndBracket = s.isEmpty() ? 0 : s[ 0 ];
2279 bRet = true;
2280 }
2281 break;
2282 }
2283 return bRet;
2284 }
2285
2286 bool SvxTwoLinesItem::GetPresentation( SfxItemPresentation /*ePres*/,
2287 MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
2288 OUString &rText, const IntlWrapper& /*rIntl*/ ) const
2289 {
2290 if( !GetValue() )
2291 rText = EditResId( RID_SVXITEMS_TWOLINES_OFF );
2292 else
2293 {
2294 rText = EditResId( RID_SVXITEMS_TWOLINES );
2295 if( GetStartBracket() )
2296 rText = OUStringChar(GetStartBracket()) + rText;
2297 if( GetEndBracket() )
2298 rText += OUStringChar(GetEndBracket());
2299 }
2300 return true;
2301 }
2302
2303
2304 /*************************************************************************
2305 |* class SvxTextRotateItem
2306 *************************************************************************/
2307
2308 SvxTextRotateItem::SvxTextRotateItem(Degree10 nValue, TypedWhichId<SvxTextRotateItem> nW)
2309 : SfxUInt16Item(nW, nValue.get())
2310 {
2311 }
2312
2313 SvxTextRotateItem* SvxTextRotateItem::Clone(SfxItemPool*) const
2314 {
2315 return new SvxTextRotateItem(*this);
2316 }
2317
2318 bool SvxTextRotateItem::GetPresentation(
2319 SfxItemPresentation /*ePres*/,
2320 MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
2321 OUString &rText, const IntlWrapper&) const
2322 {
2323 if (!GetValue())
2324 rText = EditResId(RID_SVXITEMS_TEXTROTATE_OFF);
2325 else
2326 {
2327 rText = EditResId(RID_SVXITEMS_TEXTROTATE);
2328 rText = rText.replaceFirst("$(ARG1)",
2329 OUString::number(toDegrees(GetValue())));
2330 }
2331 return true;
2332 }
2333
2334 bool SvxTextRotateItem::QueryValue(css::uno::Any& rVal,
2335 sal_uInt8 nMemberId) const
2336 {
2337 nMemberId &= ~CONVERT_TWIPS;
2338 bool bRet = true;
2339 switch (nMemberId)
2340 {
2341 case MID_ROTATE:
2342 rVal <<= static_cast<sal_Int16>(GetValue());
2343 break;
2344 default:
2345 bRet = false;
2346 break;
2347 }
2348 return bRet;
2349 }
2350
2351 bool SvxTextRotateItem::PutValue(const css::uno::Any& rVal, sal_uInt8 nMemberId)
2352 {
2353 nMemberId &= ~CONVERT_TWIPS;
2354 bool bRet = true;
2355 switch (nMemberId)
2356 {
2357 case MID_ROTATE:
2358 {
2359 sal_Int16 nVal = 0;
2360 if ((rVal >>= nVal) && (0 == nVal || 900 == nVal || 2700 == nVal))
2361 SetValue(Degree10(nVal));
2362 else
2363 bRet = false;
2364 break;
2365 }
2366 default:
2367 bRet = false;
2368 }
2369 return bRet;
2370 }
2371
2372 void SvxTextRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2373 {
2374 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTextRotateItem"));
2375 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
2376 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
2377 (void)xmlTextWriterEndElement(pWriter);
2378 }
2379
2380
2381 /*************************************************************************
2382 |* class SvxCharRotateItem
2383 *************************************************************************/
2384
2385 SvxCharRotateItem::SvxCharRotateItem( Degree10 nValue,
2386 bool bFitIntoLine,
2387 TypedWhichId<SvxCharRotateItem> nW )
2388 : SvxTextRotateItem(nValue, nW), bFitToLine( bFitIntoLine )
2389 {
2390 }
2391
2392 SvxCharRotateItem* SvxCharRotateItem::Clone( SfxItemPool* ) const
2393 {
2394 return new SvxCharRotateItem( *this );
2395 }
2396
2397 bool SvxCharRotateItem::GetPresentation(
2398 SfxItemPresentation /*ePres*/,
2399 MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
2400 OUString &rText, const IntlWrapper&) const
2401 {
2402 if( !GetValue() )
2403 rText = EditResId( RID_SVXITEMS_CHARROTATE_OFF );
2404 else
2405 {
2406 rText = EditResId( RID_SVXITEMS_CHARROTATE );
2407 rText = rText.replaceFirst( "$(ARG1)",
2408 OUString::number( toDegrees(GetValue()) ));
2409 if( IsFitToLine() )
2410 rText += EditResId( RID_SVXITEMS_CHARROTATE_FITLINE );
2411 }
2412 return true;
2413 }
2414
2415 bool SvxCharRotateItem::QueryValue( css::uno::Any& rVal,
2416 sal_uInt8 nMemberId ) const
2417 {
2418 bool bRet = true;
2419 switch(nMemberId & ~CONVERT_TWIPS)
2420 {
2421 case MID_ROTATE:
2422 SvxTextRotateItem::QueryValue(rVal, nMemberId);
2423 break;
2424 case MID_FITTOLINE:
2425 rVal <<= IsFitToLine();
2426 break;
2427 default:
2428 bRet = false;
2429 break;
2430 }
2431 return bRet;
2432 }
2433
2434 bool SvxCharRotateItem::PutValue( const css::uno::Any& rVal,
2435 sal_uInt8 nMemberId )
2436 {
2437 bool bRet = true;
2438 switch(nMemberId & ~CONVERT_TWIPS)
2439 {
2440 case MID_ROTATE:
2441 {
2442 bRet = SvxTextRotateItem::PutValue(rVal, nMemberId);
2443 break;
2444 }
2445
2446 case MID_FITTOLINE:
2447 SetFitToLine( Any2Bool( rVal ) );
2448 break;
2449 default:
2450 bRet = false;
2451 }
2452 return bRet;
2453 }
2454
2455 bool SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const
2456 {
2457 assert(SfxPoolItem::operator==(rItem));
2458 return SvxTextRotateItem::operator==( rItem ) &&
2459 IsFitToLine() == static_cast<const SvxCharRotateItem&>(rItem).IsFitToLine();
2460 }
2461
2462 void SvxCharRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2463 {
2464 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxCharRotateItem"));
2465 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
2466 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue().get()).getStr()));
2467 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fitToLine"), BAD_CAST(OString::boolean(IsFitToLine()).getStr()));
2468 (void)xmlTextWriterEndElement(pWriter);
2469 }
2470
2471 /*************************************************************************
2472 |* class SvxCharScaleItem
2473 *************************************************************************/
2474
2475 SvxCharScaleWidthItem::SvxCharScaleWidthItem( sal_uInt16 nValue,
2476 TypedWhichId<SvxCharScaleWidthItem> nW )
2477 : SfxUInt16Item( nW, nValue )
2478 {
2479 }
2480
2481 SvxCharScaleWidthItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const
2482 {
2483 return new SvxCharScaleWidthItem( *this );
2484 }
2485
2486 bool SvxCharScaleWidthItem::GetPresentation(
2487 SfxItemPresentation /*ePres*/,
2488 MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
2489 OUString &rText, const IntlWrapper&) const
2490 {
2491 if( !GetValue() )
2492 rText = EditResId( RID_SVXITEMS_CHARSCALE_OFF );
2493 else
2494 {
2495 rText = EditResId( RID_SVXITEMS_CHARSCALE );
2496 rText = rText.replaceFirst( "$(ARG1)",
2497 OUString::number( GetValue() ));
2498 }
2499 return true;
2500 }
2501
2502 bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
2503 {
2504 // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
2505 // where we still want this to be a sal_Int16
2506 sal_Int16 nValue = sal_Int16();
2507 if (rVal >>= nValue)
2508 {
2509 SetValue( static_cast<sal_uInt16>(nValue) );
2510 return true;
2511 }
2512
2513 SAL_WARN("editeng.items", "SvxCharScaleWidthItem::PutValue - Wrong type!" );
2514 return false;
2515 }
2516
2517 bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
2518 {
2519 // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
2520 // where we still want this to be a sal_Int16
2521 rVal <<= static_cast<sal_Int16>(GetValue());
2522 return true;
2523 }
2524
2525 /*************************************************************************
2526 |* class SvxCharReliefItem
2527 *************************************************************************/
2528
2529 SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue,
2530 const sal_uInt16 nId )
2531 : SfxEnumItem( nId, eValue )
2532 {
2533 }
2534
2535 SvxCharReliefItem* SvxCharReliefItem::Clone( SfxItemPool * ) const
2536 {
2537 return new SvxCharReliefItem( *this );
2538 }
2539
2540 static TranslateId RID_SVXITEMS_RELIEF[] =
2541 {
2542 RID_SVXITEMS_RELIEF_NONE,
2543 RID_SVXITEMS_RELIEF_EMBOSSED,
2544 RID_SVXITEMS_RELIEF_ENGRAVED
2545 };
2546
2547 OUString SvxCharReliefItem::GetValueTextByPos(sal_uInt16 nPos)
2548 {
2549 assert(nPos < SAL_N_ELEMENTS(RID_SVXITEMS_RELIEF) && "enum overflow");
2550 return EditResId(RID_SVXITEMS_RELIEF[nPos]);
2551 }
2552
2553 sal_uInt16 SvxCharReliefItem::GetValueCount() const
2554 {
2555 return SAL_N_ELEMENTS(RID_SVXITEMS_RELIEF) - 1;
2556 }
2557
2558 bool SvxCharReliefItem::GetPresentation
2559 (
2560 SfxItemPresentation /*ePres*/,
2561 MapUnit /*eCoreUnit*/,
2562 MapUnit /*ePresUnit*/,
2563 OUString& rText, const IntlWrapper& /*rIntl*/
2564 ) const
2565 {
2566 rText = GetValueTextByPos( static_cast<sal_uInt16>(GetValue()) );
2567 return true;
2568 }
2569
2570 bool SvxCharReliefItem::PutValue( const css::uno::Any& rVal,
2571 sal_uInt8 nMemberId )
2572 {
2573 nMemberId &= ~CONVERT_TWIPS;
2574 bool bRet = true;
2575 switch( nMemberId )
2576 {
2577 case MID_RELIEF:
2578 {
2579 sal_Int16 nVal = -1;
2580 rVal >>= nVal;
2581 if(nVal >= 0 && nVal <= sal_Int16(FontRelief::Engraved))
2582 SetValue( static_cast<FontRelief>(nVal) );
2583 else
2584 bRet = false;
2585 }
2586 break;
2587 default:
2588 bRet = false;
2589 break;
2590 }
2591 return bRet;
2592 }
2593
2594 bool SvxCharReliefItem::QueryValue( css::uno::Any& rVal,
2595 sal_uInt8 nMemberId ) const
2596 {
2597 nMemberId &= ~CONVERT_TWIPS;
2598 bool bRet = true;
2599 switch( nMemberId )
2600 {
2601 case MID_RELIEF:
2602 rVal <<= static_cast<sal_Int16>(GetValue());
2603 break;
2604 default:
2605 bRet = false;
2606 break;
2607 }
2608 return bRet;
2609 }
2610
2611 /*************************************************************************
2612 |* class SvxScriptSetItem
2613 *************************************************************************/
2614
2615 SvxScriptSetItem::SvxScriptSetItem( sal_uInt16 nSlotId, SfxItemPool& rPool )
2616 : SfxSetItem( nSlotId, SfxItemSet( rPool,
2617 svl::Items<SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONT> ))
2618 {
2619 sal_uInt16 nLatin, nAsian, nComplex;
2620 GetWhichIds( nLatin, nAsian, nComplex );
2621 GetItemSet().MergeRange( nLatin, nLatin );
2622 GetItemSet().MergeRange( nAsian, nAsian );
2623 GetItemSet().MergeRange( nComplex, nComplex );
2624 }
2625
2626 SvxScriptSetItem* SvxScriptSetItem::Clone( SfxItemPool * ) const
2627 {
2628 SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() );
2629 p->GetItemSet().Put( GetItemSet(), false );
2630 return p;
2631 }
2632
2633 const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet(
2634 const SfxItemSet& rSet, sal_uInt16 nId )
2635 {
2636 const SfxPoolItem* pI;
2637 SfxItemState eSt = rSet.GetItemState( nId, false, &pI );
2638 if( SfxItemState::SET != eSt )
2639 pI = SfxItemState::DEFAULT == eSt ? &rSet.Get( nId ) : nullptr;
2640 return pI;
2641 }
2642
2643 const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nSlotId, const SfxItemSet& rSet, SvtScriptType nScript )
2644 {
2645 sal_uInt16 nLatin, nAsian, nComplex;
2646 GetWhichIds( nSlotId, rSet, nLatin, nAsian, nComplex );
2647
2648 const SfxPoolItem *pRet, *pAsn, *pCmplx;
2649 if (nScript == SvtScriptType::ASIAN)
2650 {
2651 pRet = GetItemOfScriptSet( rSet, nAsian );
2652 } else if (nScript == SvtScriptType::COMPLEX)
2653 {
2654 pRet = GetItemOfScriptSet( rSet, nComplex );
2655 } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::ASIAN))
2656 {
2657 if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
2658 nullptr == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
2659 *pRet != *pAsn )
2660 pRet = nullptr;
2661 } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::COMPLEX))
2662 {
2663 if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
2664 nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
2665 *pRet != *pCmplx )
2666 pRet = nullptr;
2667 } else if (nScript == (SvtScriptType::ASIAN|SvtScriptType::COMPLEX))
2668 {
2669 if( nullptr == (pRet = GetItemOfScriptSet( rSet, nAsian )) ||
2670 nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
2671 *pRet != *pCmplx )
2672 pRet = nullptr;
2673 } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::ASIAN|SvtScriptType::COMPLEX))
2674 {
2675 if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
2676 nullptr == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
2677 nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
2678 *pRet != *pAsn || *pRet != *pCmplx )
2679 pRet = nullptr;
2680 } else {
2681 //no one valid -> match to latin
2682 pRet = GetItemOfScriptSet( rSet, nLatin );
2683 }
2684 return pRet;
2685 }
2686
2687 const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( SvtScriptType nScript ) const
2688 {
2689 return GetItemOfScript( Which(), GetItemSet(), nScript );
2690 }
2691
2692 void SvxScriptSetItem::PutItemForScriptType( SvtScriptType nScriptType,
2693 const SfxPoolItem& rItem )
2694 {
2695 sal_uInt16 nLatin, nAsian, nComplex;
2696 GetWhichIds( nLatin, nAsian, nComplex );
2697
2698 if( SvtScriptType::LATIN & nScriptType )
2699 {
2700 GetItemSet().Put( rItem.CloneSetWhich(nLatin) );
2701 }
2702 if( SvtScriptType::ASIAN & nScriptType )
2703 {
2704 GetItemSet().Put( rItem.CloneSetWhich(nAsian) );
2705 }
2706 if( SvtScriptType::COMPLEX & nScriptType )
2707 {
2708 GetItemSet().Put( rItem.CloneSetWhich(nComplex) );
2709 }
2710 }
2711
2712 void SvxScriptSetItem::GetWhichIds( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16& rLatin, sal_uInt16& rAsian, sal_uInt16& rComplex )
2713 {
2714 const SfxItemPool& rPool = *rSet.GetPool();
2715 GetSlotIds( nSlotId, rLatin, rAsian, rComplex );
2716 rLatin = rPool.GetWhich( rLatin );
2717 rAsian = rPool.GetWhich( rAsian );
2718 rComplex = rPool.GetWhich( rComplex );
2719 }
2720
2721 void SvxScriptSetItem::GetWhichIds( sal_uInt16& rLatin, sal_uInt16& rAsian,
2722 sal_uInt16& rComplex ) const
2723 {
2724 GetWhichIds( Which(), GetItemSet(), rLatin, rAsian, rComplex );
2725 }
2726
2727 void SvxScriptSetItem::GetSlotIds( sal_uInt16 nSlotId, sal_uInt16& rLatin,
2728 sal_uInt16& rAsian, sal_uInt16& rComplex )
2729 {
2730 switch( nSlotId )
2731 {
2732 default:
2733 SAL_WARN( "editeng.items", "wrong SlotId for class SvxScriptSetItem" );
2734 [[fallthrough]]; // default to font - Id Range !!
2735
2736 case SID_ATTR_CHAR_FONT:
2737 rLatin = SID_ATTR_CHAR_FONT;
2738 rAsian = SID_ATTR_CHAR_CJK_FONT;
2739 rComplex = SID_ATTR_CHAR_CTL_FONT;
2740 break;
2741 case SID_ATTR_CHAR_FONTHEIGHT:
2742 rLatin = SID_ATTR_CHAR_FONTHEIGHT;
2743 rAsian = SID_ATTR_CHAR_CJK_FONTHEIGHT;
2744 rComplex = SID_ATTR_CHAR_CTL_FONTHEIGHT;
2745 break;
2746 case SID_ATTR_CHAR_WEIGHT:
2747 rLatin = SID_ATTR_CHAR_WEIGHT;
2748 rAsian = SID_ATTR_CHAR_CJK_WEIGHT;
2749 rComplex = SID_ATTR_CHAR_CTL_WEIGHT;
2750 break;
2751 case SID_ATTR_CHAR_POSTURE:
2752 rLatin = SID_ATTR_CHAR_POSTURE;
2753 rAsian = SID_ATTR_CHAR_CJK_POSTURE;
2754 rComplex = SID_ATTR_CHAR_CTL_POSTURE;
2755 break;
2756 case SID_ATTR_CHAR_LANGUAGE:
2757 rLatin = SID_ATTR_CHAR_LANGUAGE;
2758 rAsian = SID_ATTR_CHAR_CJK_LANGUAGE;
2759 rComplex = SID_ATTR_CHAR_CTL_LANGUAGE;
2760 break;
2761 case SID_ATTR_CHAR_SHADOWED:
2762 rLatin = SID_ATTR_CHAR_SHADOWED;
2763 rAsian = SID_ATTR_CHAR_SHADOWED;
2764 rComplex = SID_ATTR_CHAR_SHADOWED;
2765 break;
2766 case SID_ATTR_CHAR_STRIKEOUT:
2767 rLatin = SID_ATTR_CHAR_STRIKEOUT;
2768 rAsian = SID_ATTR_CHAR_STRIKEOUT;
2769 rComplex = SID_ATTR_CHAR_STRIKEOUT;
2770 break;
2771 }
2772 }
2773
2774 void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex )
2775 {
2776 const sal_uInt16 nItemCnt = 3;
2777
2778 static struct
2779 {
2780 DefaultFontType nFontType;
2781 LanguageType nLanguage;
2782 }
2783 const aOutTypeArr[ nItemCnt ] =
2784 {
2785 { DefaultFontType::LATIN_TEXT, LANGUAGE_ENGLISH_US },
2786 { DefaultFontType::CJK_TEXT, LANGUAGE_ENGLISH_US },
2787 { DefaultFontType::CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA }
2788 };
2789
2790 SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };
2791
2792 for ( sal_uInt16 n = 0; n < nItemCnt; ++n )
2793 {
2794 vcl::Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType,
2795 aOutTypeArr[ n ].nLanguage,
2796 GetDefaultFontFlags::OnlyOne ) );
2797 SvxFontItem* pItem = aItemArr[ n ];
2798 pItem->SetFamily( aFont.GetFamilyType() );
2799 pItem->SetFamilyName( aFont.GetFamilyName() );
2800 pItem->SetStyleName( OUString() );
2801 pItem->SetPitch( aFont.GetPitch());
2802 pItem->SetCharSet(aFont.GetCharSet());
2803 }
2804 }
2805
2806
2807 bool SvxRsidItem::QueryValue( uno::Any& rVal, sal_uInt8 ) const
2808 {
2809 rVal <<= GetValue();
2810 return true;
2811 }
2812
2813 bool SvxRsidItem::PutValue( const uno::Any& rVal, sal_uInt8 )
2814 {
2815 sal_uInt32 nRsid = 0;
2816 if( !( rVal >>= nRsid ) )
2817 return false;
2818
2819 SetValue( nRsid );
2820 return true;
2821 }
2822
2823 SvxRsidItem* SvxRsidItem::Clone( SfxItemPool * ) const
2824 {
2825 return new SvxRsidItem( *this );
2826 }
2827
2828 bool SvxRsidItem::GetPresentation
2829 (
2830 SfxItemPresentation /*ePres*/,
2831 MapUnit /*eCoreUnit*/,
2832 MapUnit /*ePresUnit*/,
2833 OUString& rText, const IntlWrapper& /*rIntl*/
2834 ) const
2835 {
2836 rText.clear();
2837 return false;
2838 }
2839
2840 void SvxRsidItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2841 {
2842 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxRsidItem"));
2843 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
2844 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%" SAL_PRIuUINT32, GetValue());
2845 (void)xmlTextWriterEndElement(pWriter);
2846 }
2847
2848 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE