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