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/TabStop.hpp> 29 #include <com/sun/star/style/LineSpacing.hpp> 30 #include <com/sun/star/style/LineSpacingMode.hpp> 31 #include <com/sun/star/uno/Sequence.hxx> 32 #include <comphelper/processfactory.hxx> 33 #include <unotools/syslocale.hxx> 34 #include <comphelper/types.hxx> 35 36 using namespace ::rtl; 37 using namespace ::com::sun::star; 38 39 #include <tools/rtti.hxx> 40 #define GLOBALOVERFLOW3 41 42 #define _SVX_PARAITEM_CXX 43 #include <svl/itempool.hxx> 44 45 #include <svl/memberid.hrc> 46 #include <editeng/editrids.hrc> 47 48 #include <editeng/lspcitem.hxx> 49 #include <editeng/adjitem.hxx> 50 #include <editeng/orphitem.hxx> 51 #include <editeng/widwitem.hxx> 52 #include <editeng/tstpitem.hxx> 53 #include <editeng/pmdlitem.hxx> 54 #include <editeng/spltitem.hxx> 55 #include <editeng/hyznitem.hxx> 56 #include <editeng/scriptspaceitem.hxx> 57 #include <editeng/hngpnctitem.hxx> 58 #include <editeng/forbiddenruleitem.hxx> 59 #include <editeng/paravertalignitem.hxx> 60 #include <editeng/pgrditem.hxx> 61 #include <rtl/ustring.hxx> 62 #include <editeng/memberids.hrc> 63 #include <editeng/editids.hrc> 64 #include <editeng/itemtype.hxx> 65 #include <editeng/eerdll.hxx> 66 #include <editeng/paperinf.hxx> 67 #include <vcl/svapp.hxx> 68 #include <algorithm> 69 70 using namespace ::rtl; 71 using namespace ::com::sun::star; 72 73 // Konvertierung fuer UNO 74 #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L)) 75 #define TWIP_TO_MM100_UNSIGNED(TWIP) ((((TWIP)*127L+36L)/72L)) 76 #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L)) 77 #define MM100_TO_TWIP_UNSIGNED(MM100) ((((MM100)*72L+63L)/127L)) 78 79 80 // STATIC DATA ----------------------------------------------------------- 81 82 83 // ----------------------------------------------------------------------- 84 85 86 TYPEINIT1_FACTORY(SvxLineSpacingItem, SfxPoolItem , new SvxLineSpacingItem(LINE_SPACE_DEFAULT_HEIGHT, 0)); 87 TYPEINIT1_FACTORY(SvxAdjustItem, SfxPoolItem, new SvxAdjustItem(SVX_ADJUST_LEFT, 0)); 88 TYPEINIT1_FACTORY(SvxWidowsItem, SfxByteItem, new SvxWidowsItem(0, 0)); 89 TYPEINIT1_FACTORY(SvxOrphansItem, SfxByteItem, new SvxOrphansItem(0, 0)); 90 TYPEINIT1_FACTORY(SvxHyphenZoneItem, SfxPoolItem, new SvxHyphenZoneItem(sal_False, 0)); 91 TYPEINIT1_FACTORY(SvxTabStopItem, SfxPoolItem, new SvxTabStopItem(0)); 92 TYPEINIT1_FACTORY(SvxFmtSplitItem, SfxBoolItem, new SvxFmtSplitItem(sal_False, 0)); 93 TYPEINIT1_FACTORY(SvxPageModelItem, SfxStringItem, new SvxPageModelItem(0)); 94 TYPEINIT1_FACTORY(SvxScriptSpaceItem, SfxBoolItem, new SvxScriptSpaceItem(sal_False, 0)); 95 TYPEINIT1_FACTORY(SvxHangingPunctuationItem, SfxBoolItem, new SvxHangingPunctuationItem(sal_False, 0)); 96 TYPEINIT1_FACTORY(SvxForbiddenRuleItem, SfxBoolItem, new SvxForbiddenRuleItem(sal_False, 0)); 97 TYPEINIT1_FACTORY(SvxParaVertAlignItem, SfxUInt16Item, new SvxParaVertAlignItem(0, 0)); 98 TYPEINIT1_FACTORY(SvxParaGridItem, SfxBoolItem, new SvxParaGridItem(sal_True, 0)); 99 100 SV_IMPL_VARARR_SORT( SvxTabStopArr, SvxTabStop ) 101 102 // ----------------------------------------------------------------------- 103 104 SvxLineSpacingItem::SvxLineSpacingItem( sal_uInt16 nHeight, const sal_uInt16 nId ) 105 : SfxEnumItemInterface( nId ) 106 { 107 nPropLineSpace = 100; 108 nInterLineSpace = 0; 109 nLineHeight = nHeight; 110 eLineSpace = SVX_LINE_SPACE_AUTO; 111 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; 112 } 113 114 // ----------------------------------------------------------------------- 115 116 int SvxLineSpacingItem::operator==( const SfxPoolItem& rAttr ) const 117 { 118 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 119 120 const SvxLineSpacingItem& rLineSpace = (const SvxLineSpacingItem&)rAttr; 121 return ( 122 // Gleiche Linespacing Rule? 123 (eLineSpace == rLineSpace.eLineSpace) 124 // Bei maximalem und minimalem Linespacing muss das Mass 125 // uebereinstimmen. 126 && (eLineSpace == SVX_LINE_SPACE_AUTO || 127 nLineHeight == rLineSpace.nLineHeight) 128 // Gleiche Interlinespacing Rule? 129 && ( eInterLineSpace == rLineSpace.eInterLineSpace ) 130 // Entweder proportional oder draufaddieren eingestellt. 131 && (( eInterLineSpace == SVX_INTER_LINE_SPACE_OFF) 132 || (eInterLineSpace == SVX_INTER_LINE_SPACE_PROP 133 && nPropLineSpace == rLineSpace.nPropLineSpace) 134 || (eInterLineSpace == SVX_INTER_LINE_SPACE_FIX 135 && (nInterLineSpace == rLineSpace.nInterLineSpace)))) ? 136 1 : 0; 137 } 138 139 /*-----------------18.03.98 16:32------------------- 140 os: wer weiss noch, wieso das LineSpacingItem so 141 kompliziert ist? Fuer UNO koennen wir das nicht 142 gebrauchen. Da gibt es nur zwei Werte: 143 - ein sal_uInt16 fuer den Modus 144 - ein sal_uInt32 fuer alle Werte (Abstand, Hoehe, rel. Angaben) 145 146 --------------------------------------------------*/ 147 sal_Bool SvxLineSpacingItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 148 { 149 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 150 nMemberId &= ~CONVERT_TWIPS; 151 152 style::LineSpacing aLSp; 153 switch( eLineSpace ) 154 { 155 case SVX_LINE_SPACE_AUTO: 156 if(eInterLineSpace == SVX_INTER_LINE_SPACE_FIX) 157 { 158 aLSp.Mode = style::LineSpacingMode::LEADING; 159 aLSp.Height = ( bConvert ? (short)TWIP_TO_MM100(nInterLineSpace) : nInterLineSpace); 160 } 161 else if(eInterLineSpace == SVX_INTER_LINE_SPACE_OFF) 162 { 163 aLSp.Mode = style::LineSpacingMode::PROP; 164 aLSp.Height = 100; 165 } 166 else 167 { 168 aLSp.Mode = style::LineSpacingMode::PROP; 169 aLSp.Height = nPropLineSpace; 170 } 171 break; 172 case SVX_LINE_SPACE_FIX : 173 case SVX_LINE_SPACE_MIN : 174 aLSp.Mode = eLineSpace == SVX_LINE_SPACE_FIX ? style::LineSpacingMode::FIX : style::LineSpacingMode::MINIMUM; 175 aLSp.Height = ( bConvert ? (short)TWIP_TO_MM100_UNSIGNED(nLineHeight) : nLineHeight ); 176 break; 177 default: 178 ;//prevent warning about SVX_LINE_SPACE_END 179 } 180 181 switch ( nMemberId ) 182 { 183 case 0 : rVal <<= aLSp; break; 184 case MID_LINESPACE : rVal <<= aLSp.Mode; break; 185 case MID_HEIGHT : rVal <<= aLSp.Height; break; 186 default: DBG_ERROR("Wrong MemberId!"); break; 187 } 188 189 return sal_True; 190 } 191 /*-----------------18.03.98 16:32------------------- 192 193 --------------------------------------------------*/ 194 sal_Bool SvxLineSpacingItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 195 { 196 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 197 nMemberId &= ~CONVERT_TWIPS; 198 199 // fill with current data 200 style::LineSpacing aLSp; 201 uno::Any aAny; 202 sal_Bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aLSp ); 203 204 // get new data 205 switch ( nMemberId ) 206 { 207 case 0 : bRet = (rVal >>= aLSp); break; 208 case MID_LINESPACE : bRet = (rVal >>= aLSp.Mode); break; 209 case MID_HEIGHT : bRet = (rVal >>= aLSp.Height); break; 210 default: DBG_ERROR("Wrong MemberId!"); break; 211 } 212 213 if( bRet ) 214 { 215 nLineHeight = aLSp.Height; 216 switch( aLSp.Mode ) 217 { 218 case style::LineSpacingMode::LEADING: 219 { 220 eInterLineSpace = SVX_INTER_LINE_SPACE_FIX; 221 eLineSpace = SVX_LINE_SPACE_AUTO; 222 nInterLineSpace = aLSp.Height; 223 if(bConvert) 224 nInterLineSpace = (short)MM100_TO_TWIP(nInterLineSpace); 225 226 } 227 break; 228 case style::LineSpacingMode::PROP: 229 { 230 eLineSpace = SVX_LINE_SPACE_AUTO; 231 nPropLineSpace = (sal_Int8)std::min(aLSp.Height, (short)0xFF); 232 if(100 == aLSp.Height) 233 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; 234 else 235 eInterLineSpace = SVX_INTER_LINE_SPACE_PROP; 236 } 237 break; 238 case style::LineSpacingMode::FIX: 239 case style::LineSpacingMode::MINIMUM: 240 { 241 eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; 242 eLineSpace = aLSp.Mode == style::LineSpacingMode::FIX ? SVX_LINE_SPACE_FIX : SVX_LINE_SPACE_MIN; 243 nLineHeight = aLSp.Height; 244 if(bConvert) 245 nLineHeight = (sal_uInt16)MM100_TO_TWIP_UNSIGNED(nLineHeight); 246 } 247 break; 248 } 249 } 250 251 return bRet; 252 } 253 254 // ----------------------------------------------------------------------- 255 256 SfxPoolItem* SvxLineSpacingItem::Clone( SfxItemPool * ) const 257 { 258 return new SvxLineSpacingItem( *this ); 259 } 260 261 //------------------------------------------------------------------------ 262 263 SfxItemPresentation SvxLineSpacingItem::GetPresentation 264 ( 265 SfxItemPresentation /*ePres*/, 266 SfxMapUnit /*eCoreUnit*/, 267 SfxMapUnit /*ePresUnit*/, 268 XubString& rText, const IntlWrapper * 269 ) const 270 { 271 #ifdef DBG_UTIL 272 rText.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SvxLineSpacingItem" )); 273 #else 274 rText.Erase(); 275 #endif 276 return SFX_ITEM_PRESENTATION_NONE; 277 } 278 279 // ----------------------------------------------------------------------- 280 281 SfxPoolItem* SvxLineSpacingItem::Create(SvStream& rStrm, sal_uInt16) const 282 { 283 sal_Int8 nPropSpace; 284 short nInterSpace; 285 sal_uInt16 nHeight; 286 sal_Int8 nRule, nInterRule; 287 288 rStrm >> nPropSpace 289 >> nInterSpace 290 >> nHeight 291 >> nRule 292 >> nInterRule; 293 294 SvxLineSpacingItem* pAttr = new SvxLineSpacingItem( nHeight, Which() ); 295 pAttr->SetInterLineSpace( nInterSpace ); 296 pAttr->SetPropLineSpace( nPropSpace ); 297 pAttr->GetLineSpaceRule() = (SvxLineSpace)nRule; 298 pAttr->GetInterLineSpaceRule() = (SvxInterLineSpace)nInterRule; 299 return pAttr; 300 } 301 302 // ----------------------------------------------------------------------- 303 304 SvStream& SvxLineSpacingItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 305 { 306 rStrm << (sal_Int8) GetPropLineSpace() 307 << (short) GetInterLineSpace() 308 << (sal_uInt16) GetLineHeight() 309 << (sal_Int8) GetLineSpaceRule() 310 << (sal_Int8) GetInterLineSpaceRule(); 311 return rStrm; 312 } 313 314 // ----------------------------------------------------------------------- 315 316 sal_uInt16 SvxLineSpacingItem::GetValueCount() const 317 { 318 return SVX_LINESPACE_END; // SVX_LINESPACE_TWO_LINES + 1 319 } 320 321 // ----------------------------------------------------------------------- 322 323 XubString SvxLineSpacingItem::GetValueTextByPos( sal_uInt16 nPos ) const 324 { 325 //! Strings demnaechst aus Resource laden 326 XubString aText; 327 switch ( nPos ) 328 { 329 case SVX_LINESPACE_USER : aText.AppendAscii( "Benutzer" ); break; 330 case SVX_LINESPACE_ONE_LINE : aText.AppendAscii( "Einzeilig" ); break; 331 case SVX_LINESPACE_ONE_POINT_FIVE_LINES : aText.AppendAscii( "1,5zeilig" ); break; 332 case SVX_LINESPACE_TWO_LINES : aText.AppendAscii( "Zweizeilig" ); break; 333 } 334 return aText; 335 } 336 337 // ----------------------------------------------------------------------- 338 339 sal_uInt16 SvxLineSpacingItem::GetEnumValue() const 340 { 341 sal_uInt16 nVal; 342 switch ( nPropLineSpace ) 343 { 344 case 100: nVal = SVX_LINESPACE_ONE_LINE; break; 345 case 150: nVal = SVX_LINESPACE_ONE_POINT_FIVE_LINES; break; 346 case 200: nVal = SVX_LINESPACE_TWO_LINES; break; 347 default: nVal = SVX_LINESPACE_USER; break; 348 } 349 return nVal; 350 } 351 352 // ----------------------------------------------------------------------- 353 354 void SvxLineSpacingItem::SetEnumValue( sal_uInt16 nVal ) 355 { 356 switch ( nVal ) 357 { 358 case SVX_LINESPACE_ONE_LINE: nPropLineSpace = 100; break; 359 case SVX_LINESPACE_ONE_POINT_FIVE_LINES: nPropLineSpace = 150; break; 360 case SVX_LINESPACE_TWO_LINES: nPropLineSpace = 200; break; 361 } 362 } 363 364 // class SvxAdjustItem --------------------------------------------------- 365 366 SvxAdjustItem::SvxAdjustItem(const SvxAdjust eAdjst, const sal_uInt16 nId ) 367 : SfxEnumItemInterface( nId ), 368 bOneBlock( sal_False ), bLastCenter( sal_False ), bLastBlock( sal_False ) 369 { 370 SetAdjust( eAdjst ); 371 } 372 373 // ----------------------------------------------------------------------- 374 375 int SvxAdjustItem::operator==( const SfxPoolItem& rAttr ) const 376 { 377 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 378 379 return( ( GetAdjust() == ((SvxAdjustItem&)rAttr).GetAdjust() && 380 bOneBlock == ((SvxAdjustItem&)rAttr).bOneBlock && 381 bLastCenter == ((SvxAdjustItem&)rAttr).bLastCenter && 382 bLastBlock == ((SvxAdjustItem&)rAttr).bLastBlock ) 383 ? 1 : 0 ); 384 } 385 386 /*-----------------18.03.98 16:15------------------- 387 388 --------------------------------------------------*/ 389 sal_Bool SvxAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 390 { 391 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 392 nMemberId &= ~CONVERT_TWIPS; 393 switch( nMemberId ) 394 { 395 case MID_PARA_ADJUST : rVal <<= (sal_Int16)GetAdjust(); break; 396 case MID_LAST_LINE_ADJUST : rVal <<= (sal_Int16)GetLastBlock(); break; 397 case MID_EXPAND_SINGLE : 398 { 399 sal_Bool bValue = bOneBlock; 400 rVal.setValue( &bValue, ::getCppuBooleanType() ); 401 break; 402 } 403 default: ;//prevent warning 404 } 405 return sal_True; 406 } 407 /*-----------------18.03.98 16:15------------------- 408 409 --------------------------------------------------*/ 410 411 sal_Bool SvxAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 412 { 413 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 414 nMemberId &= ~CONVERT_TWIPS; 415 switch( nMemberId ) 416 { 417 case MID_PARA_ADJUST : 418 case MID_LAST_LINE_ADJUST : 419 { 420 sal_Int32 eVal = - 1; 421 try 422 { 423 eVal = ::comphelper::getEnumAsINT32(rVal); 424 } 425 catch(...) {} 426 if(eVal >= 0 && eVal <= 4) 427 { 428 if(MID_LAST_LINE_ADJUST == nMemberId && 429 eVal != SVX_ADJUST_LEFT && 430 eVal != SVX_ADJUST_BLOCK && 431 eVal != SVX_ADJUST_CENTER) 432 return sal_False; 433 if(eVal < (sal_uInt16)SVX_ADJUST_END) 434 nMemberId == MID_PARA_ADJUST ? 435 SetAdjust((SvxAdjust)eVal) : 436 SetLastBlock((SvxAdjust)eVal); 437 } 438 } 439 break; 440 case MID_EXPAND_SINGLE : 441 bOneBlock = Any2Bool(rVal); 442 break; 443 } 444 return sal_True; 445 } 446 447 // ----------------------------------------------------------------------- 448 449 SfxPoolItem* SvxAdjustItem::Clone( SfxItemPool * ) const 450 { 451 return new SvxAdjustItem( *this ); 452 } 453 454 //------------------------------------------------------------------------ 455 456 SfxItemPresentation SvxAdjustItem::GetPresentation 457 ( 458 SfxItemPresentation ePres, 459 SfxMapUnit /*eCoreUnit*/, 460 SfxMapUnit /*ePresUnit*/, 461 XubString& rText, const IntlWrapper * 462 ) const 463 { 464 switch ( ePres ) 465 { 466 case SFX_ITEM_PRESENTATION_NONE: 467 rText.Erase(); 468 return SFX_ITEM_PRESENTATION_NONE; 469 case SFX_ITEM_PRESENTATION_NAMELESS: 470 case SFX_ITEM_PRESENTATION_COMPLETE: 471 rText = GetValueTextByPos( (sal_uInt16)GetAdjust() ); 472 return ePres; 473 default: ;//prevent warning 474 } 475 return SFX_ITEM_PRESENTATION_NONE; 476 } 477 478 // ----------------------------------------------------------------------- 479 480 sal_uInt16 SvxAdjustItem::GetValueCount() const 481 { 482 return SVX_ADJUST_END; // SVX_ADJUST_BLOCKLINE + 1 483 } 484 485 // ----------------------------------------------------------------------- 486 487 XubString SvxAdjustItem::GetValueTextByPos( sal_uInt16 nPos ) const 488 { 489 DBG_ASSERT( nPos <= (sal_uInt16)SVX_ADJUST_BLOCKLINE, "enum overflow!" ); 490 return EE_RESSTR(RID_SVXITEMS_ADJUST_BEGIN + nPos); 491 } 492 493 // ----------------------------------------------------------------------- 494 495 sal_uInt16 SvxAdjustItem::GetEnumValue() const 496 { 497 return (sal_uInt16)GetAdjust(); 498 } 499 500 // ----------------------------------------------------------------------- 501 502 void SvxAdjustItem::SetEnumValue( sal_uInt16 nVal ) 503 { 504 SetAdjust( (const SvxAdjust)nVal ); 505 } 506 507 // ----------------------------------------------------------------------- 508 509 sal_uInt16 SvxAdjustItem::GetVersion( sal_uInt16 nFileVersion ) const 510 { 511 return (nFileVersion == SOFFICE_FILEFORMAT_31) 512 ? 0 : ADJUST_LASTBLOCK_VERSION; 513 } 514 515 // ----------------------------------------------------------------------- 516 517 SfxPoolItem* SvxAdjustItem::Create(SvStream& rStrm, sal_uInt16 nVersion) const 518 { 519 char eAdjustment; 520 rStrm >> eAdjustment; 521 SvxAdjustItem *pRet = new SvxAdjustItem( (SvxAdjust)eAdjustment, Which() ); 522 if( nVersion >= ADJUST_LASTBLOCK_VERSION ) 523 { 524 sal_Int8 nFlags; 525 rStrm >> nFlags; 526 pRet->bOneBlock = 0 != (nFlags & 0x0001); 527 pRet->bLastCenter = 0 != (nFlags & 0x0002); 528 pRet->bLastBlock = 0 != (nFlags & 0x0004); 529 } 530 return pRet; 531 } 532 533 // ----------------------------------------------------------------------- 534 535 SvStream& SvxAdjustItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const 536 { 537 rStrm << (char)GetAdjust(); 538 if ( nItemVersion >= ADJUST_LASTBLOCK_VERSION ) 539 { 540 sal_Int8 nFlags = 0; 541 if ( bOneBlock ) 542 nFlags |= 0x0001; 543 if ( bLastCenter ) 544 nFlags |= 0x0002; 545 if ( bLastBlock ) 546 nFlags |= 0x0004; 547 rStrm << (sal_Int8) nFlags; 548 } 549 return rStrm; 550 } 551 552 // class SvxWidowsItem --------------------------------------------------- 553 554 SvxWidowsItem::SvxWidowsItem(const sal_uInt8 nL, const sal_uInt16 nId ) : 555 SfxByteItem( nId, nL ) 556 { 557 } 558 559 // ----------------------------------------------------------------------- 560 561 SfxPoolItem* SvxWidowsItem::Clone( SfxItemPool * ) const 562 { 563 return new SvxWidowsItem( *this ); 564 } 565 566 // ----------------------------------------------------------------------- 567 568 SfxPoolItem* SvxWidowsItem::Create(SvStream& rStrm, sal_uInt16) const 569 { 570 sal_Int8 nLines; 571 rStrm >> nLines; 572 return new SvxWidowsItem( nLines, Which() ); 573 } 574 575 // ----------------------------------------------------------------------- 576 577 SvStream& SvxWidowsItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 578 { 579 rStrm << (sal_Int8)GetValue(); 580 return rStrm; 581 } 582 583 //------------------------------------------------------------------------ 584 585 SfxItemPresentation SvxWidowsItem::GetPresentation 586 ( 587 SfxItemPresentation ePres, 588 SfxMapUnit /*eCoreUnit*/, 589 SfxMapUnit /*ePresUnit*/, 590 XubString& rText, const IntlWrapper * 591 ) const 592 { 593 switch ( ePres ) 594 { 595 case SFX_ITEM_PRESENTATION_NONE: 596 { 597 rText.Erase(); 598 break; 599 } 600 601 case SFX_ITEM_PRESENTATION_NAMELESS: 602 { 603 rText = EE_RESSTR(RID_SVXITEMS_LINES); 604 break; 605 } 606 607 case SFX_ITEM_PRESENTATION_COMPLETE: 608 { 609 rText = EE_RESSTR(RID_SVXITEMS_WIDOWS_COMPLETE); 610 rText += ' '; 611 rText += EE_RESSTR(RID_SVXITEMS_LINES); 612 } 613 614 default: 615 { 616 DBG_ERRORFILE( "SvxWidowsItem::GetPresentation(): unknown SfxItemPresentation" ); 617 } 618 } 619 620 rText.SearchAndReplace( String::CreateFromAscii( "%1" ), String::CreateFromInt32( GetValue() ) ); 621 return ePres; 622 } 623 624 // class SvxOrphansItem -------------------------------------------------- 625 626 SvxOrphansItem::SvxOrphansItem(const sal_uInt8 nL, const sal_uInt16 nId ) : 627 SfxByteItem( nId, nL ) 628 { 629 } 630 631 // ----------------------------------------------------------------------- 632 633 SfxPoolItem* SvxOrphansItem::Clone( SfxItemPool * ) const 634 { 635 return new SvxOrphansItem( *this ); 636 } 637 638 // ----------------------------------------------------------------------- 639 640 SfxPoolItem* SvxOrphansItem::Create(SvStream& rStrm, sal_uInt16) const 641 { 642 sal_Int8 nLines; 643 rStrm >> nLines; 644 return new SvxOrphansItem( nLines, Which() ); 645 } 646 647 // ----------------------------------------------------------------------- 648 649 SvStream& SvxOrphansItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 650 { 651 rStrm << (sal_Int8) GetValue(); 652 return rStrm; 653 } 654 655 //------------------------------------------------------------------------ 656 657 SfxItemPresentation SvxOrphansItem::GetPresentation 658 ( 659 SfxItemPresentation ePres, 660 SfxMapUnit /*eCoreUnit*/, 661 SfxMapUnit /*ePresUnit*/, 662 XubString& rText, const IntlWrapper * 663 ) const 664 { 665 switch ( ePres ) 666 { 667 case SFX_ITEM_PRESENTATION_NONE: 668 { 669 rText.Erase(); 670 break; 671 } 672 673 case SFX_ITEM_PRESENTATION_NAMELESS: 674 { 675 rText = EE_RESSTR(RID_SVXITEMS_LINES); 676 break; 677 } 678 679 case SFX_ITEM_PRESENTATION_COMPLETE: 680 { 681 rText = EE_RESSTR(RID_SVXITEMS_ORPHANS_COMPLETE); 682 rText += ' '; 683 rText += EE_RESSTR(RID_SVXITEMS_LINES); 684 } 685 686 default: 687 { 688 DBG_ERRORFILE( "SvxOrphansItem::GetPresentation(): unknown SfxItemPresentation" ); 689 } 690 } 691 692 rText.SearchAndReplace( String::CreateFromAscii( "%1" ), String::CreateFromInt32( GetValue() ) ); 693 return ePres; 694 } 695 696 // class SvxHyphenZoneItem ----------------------------------------------- 697 698 SvxHyphenZoneItem::SvxHyphenZoneItem( const sal_Bool bHyph, const sal_uInt16 nId ) : 699 SfxPoolItem( nId ) 700 { 701 bHyphen = bHyph; 702 bPageEnd = sal_True; 703 nMinLead = nMinTrail = 0; 704 nMaxHyphens = 255; 705 } 706 707 // ----------------------------------------------------------------------- 708 sal_Bool SvxHyphenZoneItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 709 { 710 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 711 nMemberId &= ~CONVERT_TWIPS; 712 switch(nMemberId) 713 { 714 case MID_IS_HYPHEN: 715 rVal = Bool2Any(bHyphen); 716 break; 717 case MID_HYPHEN_MIN_LEAD: 718 rVal <<= (sal_Int16)nMinLead; 719 break; 720 case MID_HYPHEN_MIN_TRAIL: 721 rVal <<= (sal_Int16)nMinTrail; 722 break; 723 case MID_HYPHEN_MAX_HYPHENS: 724 rVal <<= (sal_Int16)nMaxHyphens; 725 break; 726 } 727 return sal_True; 728 } 729 // ----------------------------------------------------------------------- 730 sal_Bool SvxHyphenZoneItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 731 { 732 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 733 nMemberId &= ~CONVERT_TWIPS; 734 sal_Int16 nNewVal = 0; 735 736 if( nMemberId != MID_IS_HYPHEN ) 737 if(!(rVal >>= nNewVal)) 738 return sal_False; 739 740 switch(nMemberId) 741 { 742 case MID_IS_HYPHEN: 743 bHyphen = Any2Bool(rVal); 744 break; 745 case MID_HYPHEN_MIN_LEAD: 746 nMinLead = (sal_uInt8)nNewVal; 747 break; 748 case MID_HYPHEN_MIN_TRAIL: 749 nMinTrail = (sal_uInt8)nNewVal; 750 break; 751 case MID_HYPHEN_MAX_HYPHENS: 752 nMaxHyphens = (sal_uInt8)nNewVal; 753 break; 754 } 755 return sal_True; 756 } 757 758 // ----------------------------------------------------------------------- 759 760 int SvxHyphenZoneItem::operator==( const SfxPoolItem& rAttr ) const 761 { 762 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 763 764 return ( (((SvxHyphenZoneItem&)rAttr).bHyphen == bHyphen) 765 && (((SvxHyphenZoneItem&)rAttr).bPageEnd == bPageEnd) 766 && (((SvxHyphenZoneItem&)rAttr).nMinLead == nMinLead) 767 && (((SvxHyphenZoneItem&)rAttr).nMinTrail == nMinTrail) 768 && (((SvxHyphenZoneItem&)rAttr).nMaxHyphens == nMaxHyphens) ); 769 } 770 771 // ----------------------------------------------------------------------- 772 773 SfxPoolItem* SvxHyphenZoneItem::Clone( SfxItemPool * ) const 774 { 775 return new SvxHyphenZoneItem( *this ); 776 } 777 778 //------------------------------------------------------------------------ 779 780 SfxItemPresentation SvxHyphenZoneItem::GetPresentation 781 ( 782 SfxItemPresentation ePres, 783 SfxMapUnit /*eCoreUnit*/, 784 SfxMapUnit /*ePresUnit*/, 785 XubString& rText, const IntlWrapper * 786 ) const 787 { 788 switch ( ePres ) 789 { 790 case SFX_ITEM_PRESENTATION_NONE: 791 rText.Erase(); 792 return SFX_ITEM_PRESENTATION_NONE; 793 case SFX_ITEM_PRESENTATION_NAMELESS: 794 { 795 sal_uInt16 nId = RID_SVXITEMS_HYPHEN_FALSE; 796 797 if ( bHyphen ) 798 nId = RID_SVXITEMS_HYPHEN_TRUE; 799 rText = EE_RESSTR(nId); 800 rText += cpDelim; 801 nId = RID_SVXITEMS_PAGE_END_FALSE; 802 803 if ( bPageEnd ) 804 nId = RID_SVXITEMS_PAGE_END_TRUE; 805 rText += EE_RESSTR(nId); 806 rText += cpDelim; 807 rText += String::CreateFromInt32( nMinLead ); 808 rText += cpDelim; 809 rText += String::CreateFromInt32( nMinTrail ); 810 rText += cpDelim; 811 rText += String::CreateFromInt32( nMaxHyphens ); 812 return SFX_ITEM_PRESENTATION_COMPLETE; 813 } 814 case SFX_ITEM_PRESENTATION_COMPLETE: 815 { 816 sal_uInt16 nId = RID_SVXITEMS_HYPHEN_FALSE; 817 818 if ( bHyphen ) 819 nId = RID_SVXITEMS_HYPHEN_TRUE; 820 rText = EE_RESSTR(nId); 821 rText += cpDelim; 822 nId = RID_SVXITEMS_PAGE_END_FALSE; 823 824 if ( bPageEnd ) 825 nId = RID_SVXITEMS_PAGE_END_TRUE; 826 rText += EE_RESSTR(nId); 827 rText += cpDelim; 828 rText += String::CreateFromInt32(nMinLead); 829 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MINLEAD); 830 rText += cpDelim; 831 rText += String::CreateFromInt32(nMinTrail); 832 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MINTRAIL); 833 rText += cpDelim; 834 rText += String::CreateFromInt32(nMaxHyphens); 835 rText += EE_RESSTR(RID_SVXITEMS_HYPHEN_MAX); 836 return SFX_ITEM_PRESENTATION_COMPLETE; 837 } 838 default: ;//prevent warning 839 } 840 return SFX_ITEM_PRESENTATION_NONE; 841 } 842 843 // ----------------------------------------------------------------------- 844 845 SfxPoolItem* SvxHyphenZoneItem::Create(SvStream& rStrm, sal_uInt16) const 846 { 847 sal_Int8 _bHyphen, _bHyphenPageEnd; 848 sal_Int8 _nMinLead, _nMinTrail, _nMaxHyphens; 849 rStrm >> _bHyphen >> _bHyphenPageEnd >> _nMinLead >> _nMinTrail >> _nMaxHyphens; 850 SvxHyphenZoneItem* pAttr = new SvxHyphenZoneItem( sal_False, Which() ); 851 pAttr->SetHyphen( sal_Bool( _bHyphen != 0 ) ); 852 pAttr->SetPageEnd( sal_Bool( _bHyphenPageEnd != 0 ) ); 853 pAttr->GetMinLead() = _nMinLead; 854 pAttr->GetMinTrail() = _nMinTrail; 855 pAttr->GetMaxHyphens() = _nMaxHyphens; 856 return pAttr; 857 } 858 859 // ----------------------------------------------------------------------- 860 861 SvStream& SvxHyphenZoneItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 862 { 863 rStrm << (sal_Int8) IsHyphen() 864 << (sal_Int8) IsPageEnd() 865 << (sal_Int8) GetMinLead() 866 << (sal_Int8) GetMinTrail() 867 << (sal_Int8) GetMaxHyphens(); 868 return rStrm; 869 } 870 871 // class SvxTabStop ------------------------------------------------------ 872 873 SvxTabStop::SvxTabStop() 874 { 875 nTabPos = 0; 876 eAdjustment = SVX_TAB_ADJUST_LEFT; 877 m_cDecimal = cDfltDecimalChar; 878 cFill = cDfltFillChar; 879 } 880 881 // ----------------------------------------------------------------------- 882 883 SvxTabStop::SvxTabStop( const long nPos, const SvxTabAdjust eAdjst, 884 const sal_Unicode cDec, const sal_Unicode cFil ) 885 { 886 nTabPos = nPos; 887 eAdjustment = eAdjst; 888 m_cDecimal = cDec; 889 cFill = cFil; 890 } 891 // ----------------------------------------------------------------------------- 892 void SvxTabStop::fillDecimal() const 893 { 894 if ( cDfltDecimalChar == m_cDecimal ) 895 m_cDecimal = SvtSysLocale().GetLocaleData().getNumDecimalSep().GetChar(0); 896 } 897 // ----------------------------------------------------------------------- 898 899 XubString SvxTabStop::GetValueString() const 900 { 901 XubString aStr; 902 903 aStr += sal_Unicode( '(' ); 904 aStr += UniString::CreateFromInt32(nTabPos); 905 aStr += cpDelim; 906 aStr += XubString( EditResId( RID_SVXITEMS_TAB_ADJUST_BEGIN + (sal_uInt16)eAdjustment ) ); 907 908 aStr += cpDelim; 909 aStr += sal_Unicode('['); 910 aStr += XubString( EditResId( RID_SVXITEMS_TAB_DECIMAL_CHAR ) ); 911 aStr += GetDecimal(); 912 aStr += sal_Unicode(']'); 913 aStr += cpDelim; 914 aStr += cpDelim; 915 aStr += sal_Unicode('['); 916 aStr += XubString( EditResId( RID_SVXITEMS_TAB_FILL_CHAR ) ); 917 aStr += cFill; 918 aStr += sal_Unicode(']'); 919 aStr += sal_Unicode(')'); 920 921 return aStr; 922 } 923 924 // class SvxTabStopItem -------------------------------------------------- 925 926 SvxTabStopItem::SvxTabStopItem( sal_uInt16 _nWhich ) : 927 SfxPoolItem( _nWhich ), 928 SvxTabStopArr( sal_Int8(SVX_TAB_DEFCOUNT) ) 929 { 930 const sal_uInt16 nTabs = SVX_TAB_DEFCOUNT, nDist = SVX_TAB_DEFDIST; 931 const SvxTabAdjust eAdjst= SVX_TAB_ADJUST_DEFAULT; 932 933 for (sal_uInt16 i = 0; i < nTabs; ++i) 934 { 935 SvxTabStop aTab( (i + 1) * nDist, eAdjst ); 936 SvxTabStopArr::Insert( aTab ); 937 } 938 } 939 940 // ----------------------------------------------------------------------- 941 942 SvxTabStopItem::SvxTabStopItem( const sal_uInt16 nTabs, 943 const sal_uInt16 nDist, 944 const SvxTabAdjust eAdjst, 945 sal_uInt16 _nWhich ) : 946 SfxPoolItem( _nWhich ), 947 SvxTabStopArr( sal_Int8(nTabs) ) 948 { 949 for ( sal_uInt16 i = 0; i < nTabs; ++i ) 950 { 951 SvxTabStop aTab( (i + 1) * nDist, eAdjst ); 952 SvxTabStopArr::Insert( aTab ); 953 } 954 } 955 956 // ----------------------------------------------------------------------- 957 958 SvxTabStopItem::SvxTabStopItem( const SvxTabStopItem& rTSI ) : 959 SfxPoolItem( rTSI.Which() ), 960 SvxTabStopArr( (sal_Int8)rTSI.Count() ) 961 { 962 SvxTabStopArr::Insert( &rTSI ); 963 } 964 965 // ----------------------------------------------------------------------- 966 967 sal_uInt16 SvxTabStopItem::GetPos( const SvxTabStop& rTab ) const 968 { 969 sal_uInt16 nFound; 970 return Seek_Entry( rTab, &nFound ) ? nFound : SVX_TAB_NOTFOUND; 971 } 972 973 // ----------------------------------------------------------------------- 974 975 sal_uInt16 SvxTabStopItem::GetPos( const long nPos ) const 976 { 977 sal_uInt16 nFound; 978 return Seek_Entry( SvxTabStop( nPos ), &nFound ) ? nFound : SVX_TAB_NOTFOUND; 979 } 980 981 // ----------------------------------------------------------------------- 982 983 SvxTabStopItem& SvxTabStopItem::operator=( const SvxTabStopItem& rTSI ) 984 { 985 Remove( 0, Count() ); 986 SvxTabStopArr::Insert( &rTSI ); 987 return *this; 988 } 989 990 991 /* 992 enum ::com::sun::star::style::TabAlign 993 { 994 TABALIGN_LEFT, 995 TABALIGN_CENTER, 996 TABALIGN_RIGHT, 997 TABALIGN_DECIMAL 998 }; 999 1000 struct ::com::sun::star::style::TabStop 1001 { 1002 long Position; 1003 ::com::sun::star::style::TabAlign ::com::sun::star::drawing::Alignment; 1004 unsigned short DecimalChar; 1005 unsigned short FillChar; 1006 }; 1007 typedef sequence ::com::sun::star::style::TabStop> TabSTopSequence; 1008 1009 */ 1010 /*-----------------19.03.98 08:50------------------- 1011 1012 --------------------------------------------------*/ 1013 1014 sal_Bool SvxTabStopItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1015 { 1016 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1017 nMemberId &= ~CONVERT_TWIPS; 1018 switch ( nMemberId ) 1019 { 1020 case MID_TABSTOPS: 1021 { 1022 sal_uInt16 nCount = Count(); 1023 uno::Sequence< style::TabStop> aSeq(nCount); 1024 style::TabStop* pArr = aSeq.getArray(); 1025 for(sal_uInt16 i = 0; i < nCount; i++) 1026 { 1027 const SvxTabStop& rTab = *(GetStart() + i); 1028 pArr[i].Position = bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos(); 1029 switch(rTab.GetAdjustment()) 1030 { 1031 case SVX_TAB_ADJUST_LEFT : pArr[i].Alignment = style::TabAlign_LEFT; break; 1032 case SVX_TAB_ADJUST_RIGHT : pArr[i].Alignment = style::TabAlign_RIGHT; break; 1033 case SVX_TAB_ADJUST_DECIMAL: pArr[i].Alignment = style::TabAlign_DECIMAL; break; 1034 case SVX_TAB_ADJUST_CENTER : pArr[i].Alignment = style::TabAlign_CENTER; break; 1035 default: //SVX_TAB_ADJUST_DEFAULT 1036 pArr[i].Alignment = style::TabAlign_DEFAULT; 1037 1038 } 1039 pArr[i].DecimalChar = rTab.GetDecimal(); 1040 pArr[i].FillChar = rTab.GetFill(); 1041 } 1042 rVal <<= aSeq; 1043 break; 1044 } 1045 case MID_STD_TAB: 1046 { 1047 const SvxTabStop &rTab = *(GetStart()); 1048 rVal <<= static_cast<sal_Int32>(bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos()); 1049 break; 1050 } 1051 } 1052 return sal_True; 1053 } 1054 /*-----------------19.03.98 08:50------------------- 1055 1056 --------------------------------------------------*/ 1057 1058 sal_Bool SvxTabStopItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1059 { 1060 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1061 nMemberId &= ~CONVERT_TWIPS; 1062 switch ( nMemberId ) 1063 { 1064 case MID_TABSTOPS: 1065 { 1066 uno::Sequence< style::TabStop> aSeq; 1067 if(!(rVal >>= aSeq)) 1068 { 1069 uno::Sequence < uno::Sequence < uno::Any > > aAnySeq; 1070 if (!(rVal >>= aAnySeq)) 1071 return sal_False; 1072 sal_Int32 nLength = aAnySeq.getLength(); 1073 aSeq.realloc( nLength ); 1074 for ( sal_Int32 n=0; n<nLength; n++ ) 1075 { 1076 uno::Sequence < uno::Any >& rAnySeq = aAnySeq[n]; 1077 if ( rAnySeq.getLength() == 4 ) 1078 { 1079 if (!(rAnySeq[0] >>= aSeq[n].Position)) return sal_False; 1080 if (!(rAnySeq[1] >>= aSeq[n].Alignment)) 1081 { 1082 sal_Int32 nVal = 0; 1083 if (rAnySeq[1] >>= nVal) 1084 aSeq[n].Alignment = (com::sun::star::style::TabAlign) nVal; 1085 else 1086 return sal_False; 1087 } 1088 if (!(rAnySeq[2] >>= aSeq[n].DecimalChar)) 1089 { 1090 ::rtl::OUString aVal; 1091 if ( (rAnySeq[2] >>= aVal) && aVal.getLength() == 1 ) 1092 aSeq[n].DecimalChar = aVal.toChar(); 1093 else 1094 return sal_False; 1095 } 1096 if (!(rAnySeq[3] >>= aSeq[n].FillChar)) 1097 { 1098 ::rtl::OUString aVal; 1099 if ( (rAnySeq[3] >>= aVal) && aVal.getLength() == 1 ) 1100 aSeq[n].FillChar = aVal.toChar(); 1101 else 1102 return sal_False; 1103 } 1104 } 1105 else 1106 return sal_False; 1107 } 1108 } 1109 1110 SvxTabStopArr::Remove( 0, Count() ); 1111 const style::TabStop* pArr = aSeq.getConstArray(); 1112 const sal_uInt16 nCount = (sal_uInt16)aSeq.getLength(); 1113 for(sal_uInt16 i = 0; i < nCount ; i++) 1114 { 1115 SvxTabAdjust eAdjust = SVX_TAB_ADJUST_DEFAULT; 1116 switch(pArr[i].Alignment) 1117 { 1118 case style::TabAlign_LEFT : eAdjust = SVX_TAB_ADJUST_LEFT; break; 1119 case style::TabAlign_CENTER : eAdjust = SVX_TAB_ADJUST_CENTER; break; 1120 case style::TabAlign_RIGHT : eAdjust = SVX_TAB_ADJUST_RIGHT; break; 1121 case style::TabAlign_DECIMAL: eAdjust = SVX_TAB_ADJUST_DECIMAL; break; 1122 default: ;//prevent warning 1123 } 1124 sal_Unicode cFill = pArr[i].FillChar; 1125 sal_Unicode cDecimal = pArr[i].DecimalChar; 1126 SvxTabStop aTab( bConvert ? MM100_TO_TWIP(pArr[i].Position) : pArr[i].Position, 1127 eAdjust, 1128 cDecimal, 1129 cFill ); 1130 Insert(aTab); 1131 } 1132 break; 1133 } 1134 case MID_STD_TAB: 1135 { 1136 sal_Int32 nNewPos = 0; 1137 if (!(rVal >>= nNewPos) ) 1138 return sal_False; 1139 const SvxTabStop& rTab = *(GetStart()); 1140 SvxTabStop aNewTab ( bConvert ? MM100_TO_TWIP ( nNewPos ) : nNewPos, 1141 rTab.GetAdjustment(), rTab.GetDecimal(), rTab.GetFill() ); 1142 Remove ( 0 ); 1143 Insert( aNewTab ); 1144 break; 1145 } 1146 } 1147 return sal_True; 1148 } 1149 // ----------------------------------------------------------------------- 1150 1151 int SvxTabStopItem::operator==( const SfxPoolItem& rAttr ) const 1152 { 1153 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 1154 1155 const SvxTabStopItem& rTSI = (SvxTabStopItem&)rAttr; 1156 1157 if ( Count() != rTSI.Count() ) 1158 return 0; 1159 1160 for ( sal_uInt16 i = 0; i < Count(); ++i ) 1161 if( !(*this)[i].IsEqual( rTSI[i] ) ) 1162 return 0; 1163 return 1; 1164 } 1165 1166 // ----------------------------------------------------------------------- 1167 1168 SfxPoolItem* SvxTabStopItem::Clone( SfxItemPool * ) const 1169 { 1170 return new SvxTabStopItem( *this ); 1171 } 1172 1173 //------------------------------------------------------------------------ 1174 1175 SfxItemPresentation SvxTabStopItem::GetPresentation 1176 ( 1177 SfxItemPresentation ePres, 1178 SfxMapUnit eCoreUnit, 1179 SfxMapUnit ePresUnit, 1180 XubString& rText, const IntlWrapper *pIntl 1181 ) const 1182 { 1183 rText.Erase(); 1184 1185 if ( ePres > SFX_ITEM_PRESENTATION_NONE ) 1186 { 1187 #ifndef SVX_LIGHT 1188 sal_Bool bComma = sal_False; 1189 1190 for ( sal_uInt16 i = 0; i < Count(); ++i ) 1191 { 1192 if ( SVX_TAB_ADJUST_DEFAULT != ((*this)[i]).GetAdjustment() ) 1193 { 1194 if ( bComma ) 1195 rText += sal_Unicode(','); 1196 rText += GetMetricText( 1197 (long)((*this)[i]).GetTabPos(), eCoreUnit, ePresUnit, pIntl ); 1198 if ( SFX_ITEM_PRESENTATION_COMPLETE == ePres ) 1199 { 1200 rText += sal_Unicode(' '); 1201 rText += EE_RESSTR(GetMetricId(ePresUnit)); 1202 } 1203 bComma = sal_True; 1204 } 1205 } 1206 #endif 1207 } 1208 return ePres; 1209 } 1210 1211 // ----------------------------------------------------------------------- 1212 1213 SfxPoolItem* SvxTabStopItem::Create( SvStream& rStrm, sal_uInt16 ) const 1214 { 1215 sal_Int8 nTabs; 1216 rStrm >> nTabs; 1217 SvxTabStopItem* pAttr = 1218 new SvxTabStopItem( 0, 0, SVX_TAB_ADJUST_DEFAULT, Which() ); 1219 1220 for ( sal_Int8 i = 0; i < nTabs; i++ ) 1221 { 1222 long nPos; 1223 sal_Int8 eAdjust; 1224 unsigned char cDecimal, cFill; 1225 rStrm >> nPos >> eAdjust >> cDecimal >> cFill; 1226 if( !i || SVX_TAB_ADJUST_DEFAULT != eAdjust ) 1227 pAttr->Insert( SvxTabStop 1228 ( nPos, (SvxTabAdjust)eAdjust, sal_Unicode(cDecimal), sal_Unicode(cFill) ) ); 1229 } 1230 return pAttr; 1231 } 1232 1233 // ----------------------------------------------------------------------- 1234 1235 SvStream& SvxTabStopItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 1236 { 1237 //MA 05. Sep. 96: Default-Tabs werden nur noch fuer das default-Attr 1238 //expandiert. Fuer vollstaendige Rueckwaertskompatibilitaet (<=304) 1239 //muessten alle Tabs expandiert werden, dass blaeht aber das File u.U. 1240 //enorm auf. 1241 //Alles nur SWG! 1242 1243 const SfxItemPool *pPool = SfxItemPool::GetStoringPool(); 1244 const FASTBOOL bStoreDefTabs = pPool 1245 && pPool->GetName().EqualsAscii("SWG") 1246 && ::IsDefaultItem( this ); 1247 1248 const short nTabs = Count(); 1249 sal_uInt16 nCount = 0, nDefDist = 0; 1250 long nNew = 0; 1251 1252 if( bStoreDefTabs ) 1253 { 1254 const SvxTabStopItem& rDefTab = (const SvxTabStopItem &) 1255 pPool->GetDefaultItem( pPool->GetWhich( SID_ATTR_TABSTOP, sal_False ) ); 1256 nDefDist = sal_uInt16( rDefTab.GetStart()->GetTabPos() ); 1257 const long nPos = nTabs > 0 ? (*this)[nTabs-1].GetTabPos() : 0; 1258 nCount = (sal_uInt16)(nPos / nDefDist); 1259 nNew = (nCount + 1) * nDefDist; 1260 1261 if( nNew <= nPos + 50 ) 1262 nNew += nDefDist; 1263 1264 long lA3Width = SvxPaperInfo::GetPaperSize(PAPER_A3).Width(); 1265 nCount = (sal_uInt16)(nNew < lA3Width ? ( lA3Width - nNew ) / nDefDist + 1 : 0); 1266 } 1267 1268 rStrm << (sal_Int8) ( nTabs + nCount ); 1269 for ( short i = 0; i < nTabs; i++ ) 1270 { 1271 const SvxTabStop& rTab = (*this)[ i ]; 1272 rStrm << (long) rTab.GetTabPos() 1273 << (sal_Int8) rTab.GetAdjustment() 1274 << (unsigned char) rTab.GetDecimal() 1275 << (unsigned char) rTab.GetFill(); 1276 } 1277 1278 if ( bStoreDefTabs ) 1279 for( ; nCount; --nCount ) 1280 { 1281 SvxTabStop aSwTabStop(nNew, SVX_TAB_ADJUST_DEFAULT); 1282 rStrm << (long) aSwTabStop.GetTabPos() 1283 << (sal_Int8) aSwTabStop.GetAdjustment() 1284 << (unsigned char) aSwTabStop.GetDecimal() 1285 << (unsigned char) aSwTabStop.GetFill(); 1286 nNew += nDefDist; 1287 } 1288 1289 return rStrm; 1290 } 1291 1292 // ----------------------------------------------------------------------- 1293 sal_Bool SvxTabStopItem::Insert( const SvxTabStop& rTab ) 1294 { 1295 sal_uInt16 nTabPos = GetPos(rTab); 1296 if(SVX_TAB_NOTFOUND != nTabPos ) 1297 Remove(nTabPos); 1298 return SvxTabStopArr::Insert( rTab ); 1299 } 1300 // ----------------------------------------------------------------------- 1301 void SvxTabStopItem::Insert( const SvxTabStopItem* pTabs, sal_uInt16 nStart, 1302 sal_uInt16 nEnd ) 1303 { 1304 for( sal_uInt16 i = nStart; i < nEnd && i < pTabs->Count(); i++ ) 1305 { 1306 const SvxTabStop& rTab = (*pTabs)[i]; 1307 sal_uInt16 nTabPos = GetPos(rTab); 1308 if(SVX_TAB_NOTFOUND != nTabPos) 1309 Remove(nTabPos); 1310 } 1311 SvxTabStopArr::Insert( pTabs, nStart, nEnd ); 1312 } 1313 1314 1315 1316 // class SvxFmtSplitItem ------------------------------------------------- 1317 SvxFmtSplitItem::~SvxFmtSplitItem() 1318 { 1319 } 1320 // ----------------------------------------------------------------------- 1321 SfxPoolItem* SvxFmtSplitItem::Clone( SfxItemPool * ) const 1322 { 1323 return new SvxFmtSplitItem( *this ); 1324 } 1325 1326 // ----------------------------------------------------------------------- 1327 1328 SvStream& SvxFmtSplitItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const 1329 { 1330 rStrm << (sal_Int8)GetValue(); 1331 return rStrm; 1332 } 1333 1334 // ----------------------------------------------------------------------- 1335 1336 SfxPoolItem* SvxFmtSplitItem::Create( SvStream& rStrm, sal_uInt16 ) const 1337 { 1338 sal_Int8 bIsSplit; 1339 rStrm >> bIsSplit; 1340 return new SvxFmtSplitItem( sal_Bool( bIsSplit != 0 ), Which() ); 1341 } 1342 1343 //------------------------------------------------------------------------ 1344 1345 SfxItemPresentation SvxFmtSplitItem::GetPresentation 1346 ( 1347 SfxItemPresentation ePres, 1348 SfxMapUnit /*eCoreUnit*/, 1349 SfxMapUnit /*ePresUnit*/, 1350 XubString& rText, const IntlWrapper * 1351 ) const 1352 { 1353 switch ( ePres ) 1354 { 1355 case SFX_ITEM_PRESENTATION_NONE: 1356 rText.Erase(); 1357 return SFX_ITEM_PRESENTATION_NONE; 1358 case SFX_ITEM_PRESENTATION_NAMELESS: 1359 case SFX_ITEM_PRESENTATION_COMPLETE: 1360 { 1361 sal_uInt16 nId = RID_SVXITEMS_FMTSPLIT_FALSE; 1362 1363 if ( GetValue() ) 1364 nId = RID_SVXITEMS_FMTSPLIT_TRUE; 1365 rText = EE_RESSTR(nId); 1366 return ePres; 1367 } 1368 default: ;//prevent warning 1369 } 1370 return SFX_ITEM_PRESENTATION_NONE; 1371 } 1372 1373 // -------------------------------------------------------------------- 1374 1375 SfxPoolItem* SvxPageModelItem::Clone( SfxItemPool* ) const 1376 { 1377 return new SvxPageModelItem( *this ); 1378 } 1379 1380 //------------------------------------------------------------------------ 1381 1382 sal_Bool SvxPageModelItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const 1383 { 1384 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1385 nMemberId &= ~CONVERT_TWIPS; 1386 1387 switch ( nMemberId ) 1388 { 1389 case MID_AUTO: rVal <<= (sal_Bool) bAuto; break; 1390 case MID_NAME: rVal <<= ::rtl::OUString( GetValue() ); break; 1391 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 1392 } 1393 1394 return sal_True; 1395 } 1396 1397 sal_Bool SvxPageModelItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) 1398 { 1399 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1400 nMemberId &= ~CONVERT_TWIPS; 1401 sal_Bool bRet; 1402 ::rtl::OUString aStr; 1403 switch ( nMemberId ) 1404 { 1405 case MID_AUTO: bRet = ( rVal >>= bAuto ); break; 1406 case MID_NAME: bRet = ( rVal >>= aStr ); if ( bRet ) SetValue(aStr); break; 1407 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 1408 } 1409 1410 return bRet; 1411 } 1412 1413 SfxItemPresentation SvxPageModelItem::GetPresentation 1414 ( 1415 SfxItemPresentation ePres, 1416 SfxMapUnit /*eCoreUnit*/, 1417 SfxMapUnit /*ePresUnit*/, 1418 XubString& rText, const IntlWrapper * 1419 ) const 1420 { 1421 rText.Erase(); 1422 FASTBOOL bSet = ( GetValue().Len() > 0 ); 1423 1424 switch ( ePres ) 1425 { 1426 case SFX_ITEM_PRESENTATION_NONE: 1427 return SFX_ITEM_PRESENTATION_NONE; 1428 1429 case SFX_ITEM_PRESENTATION_NAMELESS: 1430 if ( bSet ) 1431 rText = GetValue(); 1432 return SFX_ITEM_PRESENTATION_NAMELESS; 1433 1434 case SFX_ITEM_PRESENTATION_COMPLETE: 1435 if ( bSet ) 1436 { 1437 rText = EE_RESSTR(RID_SVXITEMS_PAGEMODEL_COMPLETE); 1438 rText += GetValue(); 1439 } 1440 return SFX_ITEM_PRESENTATION_COMPLETE; 1441 default: ;//prevent warning 1442 } 1443 return SFX_ITEM_PRESENTATION_NONE; 1444 } 1445 1446 //------------------------------------------------------------------------ 1447 1448 SvxScriptSpaceItem::SvxScriptSpaceItem( sal_Bool bOn, const sal_uInt16 nId ) 1449 : SfxBoolItem( nId, bOn ) 1450 { 1451 } 1452 1453 SfxPoolItem* SvxScriptSpaceItem::Clone( SfxItemPool * ) const 1454 { 1455 return new SvxScriptSpaceItem( GetValue(), Which() ); 1456 } 1457 1458 SfxPoolItem* SvxScriptSpaceItem::Create(SvStream & rStrm, sal_uInt16) const 1459 { 1460 sal_Bool bFlag; 1461 rStrm >> bFlag; 1462 return new SvxScriptSpaceItem( bFlag, Which() ); 1463 } 1464 1465 sal_uInt16 SvxScriptSpaceItem::GetVersion( sal_uInt16 nFFVer ) const 1466 { 1467 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 1468 SOFFICE_FILEFORMAT_40==nFFVer || 1469 SOFFICE_FILEFORMAT_50==nFFVer, 1470 "SvxTwoLinesItem: Gibt es ein neues Fileformat?" ); 1471 1472 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; 1473 } 1474 1475 SfxItemPresentation SvxScriptSpaceItem::GetPresentation( 1476 SfxItemPresentation ePres, 1477 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/, 1478 String &rText, const IntlWrapper* /*pIntl*/ ) const 1479 { 1480 switch( ePres ) 1481 { 1482 case SFX_ITEM_PRESENTATION_NONE: 1483 rText.Erase(); 1484 break; 1485 case SFX_ITEM_PRESENTATION_NAMELESS: 1486 case SFX_ITEM_PRESENTATION_COMPLETE: 1487 { 1488 rText = EE_RESSTR( !GetValue() 1489 ? RID_SVXITEMS_SCRPTSPC_OFF 1490 : RID_SVXITEMS_SCRPTSPC_ON ); 1491 return ePres; 1492 } 1493 default: ;//prevent warning 1494 } 1495 return SFX_ITEM_PRESENTATION_NONE; 1496 } 1497 1498 //------------------------------------------------------------------------ 1499 1500 SvxHangingPunctuationItem::SvxHangingPunctuationItem( 1501 sal_Bool bOn, const sal_uInt16 nId ) 1502 : SfxBoolItem( nId, bOn ) 1503 { 1504 } 1505 1506 SfxPoolItem* SvxHangingPunctuationItem::Clone( SfxItemPool * ) const 1507 { 1508 return new SvxHangingPunctuationItem( GetValue(), Which() ); 1509 } 1510 1511 SfxPoolItem* SvxHangingPunctuationItem::Create(SvStream & rStrm, sal_uInt16) const 1512 { 1513 sal_Bool nValue; 1514 rStrm >> nValue; 1515 return new SvxHangingPunctuationItem( nValue, Which() ); 1516 } 1517 1518 sal_uInt16 SvxHangingPunctuationItem::GetVersion( sal_uInt16 nFFVer ) const 1519 { 1520 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 1521 SOFFICE_FILEFORMAT_40==nFFVer || 1522 SOFFICE_FILEFORMAT_50==nFFVer, 1523 "SvxHangingPunctuationItem: Gibt es ein neues Fileformat?" ); 1524 1525 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; 1526 } 1527 1528 SfxItemPresentation SvxHangingPunctuationItem::GetPresentation( 1529 SfxItemPresentation ePres, 1530 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/, 1531 String &rText, const IntlWrapper* /*pIntl*/ ) const 1532 { 1533 switch( ePres ) 1534 { 1535 case SFX_ITEM_PRESENTATION_NONE: 1536 rText.Erase(); 1537 break; 1538 case SFX_ITEM_PRESENTATION_NAMELESS: 1539 case SFX_ITEM_PRESENTATION_COMPLETE: 1540 { 1541 rText = EE_RESSTR( !GetValue() 1542 ? RID_SVXITEMS_HNGPNCT_OFF 1543 : RID_SVXITEMS_HNGPNCT_ON ); 1544 return ePres; 1545 } 1546 default: ;//prevent warning 1547 break; 1548 } 1549 return SFX_ITEM_PRESENTATION_NONE; 1550 } 1551 //------------------------------------------------------------------------ 1552 1553 SvxForbiddenRuleItem::SvxForbiddenRuleItem( 1554 sal_Bool bOn, const sal_uInt16 nId ) 1555 : SfxBoolItem( nId, bOn ) 1556 { 1557 } 1558 /* -----------------------------29.11.00 11:23-------------------------------- 1559 1560 ---------------------------------------------------------------------------*/ 1561 SfxPoolItem* SvxForbiddenRuleItem::Clone( SfxItemPool * ) const 1562 { 1563 return new SvxForbiddenRuleItem( GetValue(), Which() ); 1564 } 1565 /* -----------------------------29.11.00 11:23-------------------------------- 1566 1567 ---------------------------------------------------------------------------*/ 1568 SfxPoolItem* SvxForbiddenRuleItem::Create(SvStream & rStrm, sal_uInt16) const 1569 { 1570 sal_Bool nValue; 1571 rStrm >> nValue; 1572 return new SvxForbiddenRuleItem( nValue, Which() ); 1573 } 1574 /* -----------------------------29.11.00 11:23-------------------------------- 1575 1576 ---------------------------------------------------------------------------*/ 1577 sal_uInt16 SvxForbiddenRuleItem::GetVersion( sal_uInt16 nFFVer ) const 1578 { 1579 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 1580 SOFFICE_FILEFORMAT_40==nFFVer || 1581 SOFFICE_FILEFORMAT_50==nFFVer, 1582 "SvxForbiddenRuleItem: Gibt es ein neues Fileformat?" ); 1583 1584 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; 1585 } 1586 /* -----------------------------29.11.00 11:23-------------------------------- 1587 1588 ---------------------------------------------------------------------------*/ 1589 SfxItemPresentation SvxForbiddenRuleItem::GetPresentation( 1590 SfxItemPresentation ePres, 1591 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/, 1592 String &rText, const IntlWrapper* /*pIntl*/ ) const 1593 { 1594 switch( ePres ) 1595 { 1596 case SFX_ITEM_PRESENTATION_NONE: 1597 rText.Erase(); 1598 break; 1599 case SFX_ITEM_PRESENTATION_NAMELESS: 1600 case SFX_ITEM_PRESENTATION_COMPLETE: 1601 { 1602 rText = EE_RESSTR( !GetValue() 1603 ? RID_SVXITEMS_FORBIDDEN_RULE_OFF 1604 : RID_SVXITEMS_FORBIDDEN_RULE_ON ); 1605 return ePres; 1606 } 1607 default: ;//prevent warning 1608 break; 1609 } 1610 return SFX_ITEM_PRESENTATION_NONE; 1611 } 1612 1613 /************************************************************************* 1614 |* class SvxParaVertAlignItem 1615 *************************************************************************/ 1616 1617 SvxParaVertAlignItem::SvxParaVertAlignItem( sal_uInt16 nValue, 1618 const sal_uInt16 nW ) 1619 : SfxUInt16Item( nW, nValue ) 1620 { 1621 } 1622 1623 SfxPoolItem* SvxParaVertAlignItem::Clone( SfxItemPool* ) const 1624 { 1625 return new SvxParaVertAlignItem( GetValue(), Which() ); 1626 } 1627 1628 SfxPoolItem* SvxParaVertAlignItem::Create( SvStream& rStrm, sal_uInt16 ) const 1629 { 1630 sal_uInt16 nVal; 1631 rStrm >> nVal; 1632 return new SvxParaVertAlignItem( nVal, Which() ); 1633 } 1634 1635 SvStream& SvxParaVertAlignItem::Store( SvStream & rStrm, sal_uInt16 ) const 1636 { 1637 rStrm << GetValue(); 1638 return rStrm; 1639 } 1640 1641 sal_uInt16 SvxParaVertAlignItem::GetVersion( sal_uInt16 nFFVer ) const 1642 { 1643 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; 1644 } 1645 1646 SfxItemPresentation SvxParaVertAlignItem::GetPresentation( 1647 SfxItemPresentation ePres, 1648 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/, 1649 String &rText, const IntlWrapper* ) const 1650 { 1651 switch( ePres ) 1652 { 1653 case SFX_ITEM_PRESENTATION_NONE: 1654 rText.Erase(); 1655 break; 1656 case SFX_ITEM_PRESENTATION_NAMELESS: 1657 case SFX_ITEM_PRESENTATION_COMPLETE: 1658 { 1659 sal_uInt16 nTmp; 1660 switch( GetValue() ) 1661 { 1662 case AUTOMATIC: nTmp = RID_SVXITEMS_PARAVERTALIGN_AUTO; break; 1663 case TOP: nTmp = RID_SVXITEMS_PARAVERTALIGN_TOP; break; 1664 case CENTER: nTmp = RID_SVXITEMS_PARAVERTALIGN_CENTER; break; 1665 case BOTTOM: nTmp = RID_SVXITEMS_PARAVERTALIGN_BOTTOM; break; 1666 default: nTmp = RID_SVXITEMS_PARAVERTALIGN_BASELINE; break; 1667 } 1668 rText = EE_RESSTR( nTmp ); 1669 return ePres; 1670 } 1671 default: ;//prevent warning 1672 break; 1673 } 1674 return SFX_ITEM_PRESENTATION_NONE; 1675 } 1676 1677 sal_Bool SvxParaVertAlignItem::QueryValue( com::sun::star::uno::Any& rVal, 1678 sal_uInt8 /*nMemberId*/ ) const 1679 { 1680 rVal <<= (sal_Int16)GetValue(); 1681 return sal_True; 1682 } 1683 1684 sal_Bool SvxParaVertAlignItem::PutValue( const com::sun::star::uno::Any& rVal, 1685 sal_uInt8 /*nMemberId*/ ) 1686 { 1687 sal_Int16 nVal = sal_Int16(); 1688 if((rVal >>= nVal) && nVal >=0 && nVal <= BOTTOM ) 1689 { 1690 SetValue( (sal_uInt16)nVal ); 1691 return sal_True; 1692 } 1693 else 1694 return sal_False; 1695 } 1696 1697 int SvxParaVertAlignItem::operator==( const SfxPoolItem& rItem ) const 1698 { 1699 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); 1700 return SfxUInt16Item::operator==( rItem ); 1701 } 1702 1703 1704 SvxParaGridItem::SvxParaGridItem( sal_Bool bOn, const sal_uInt16 nId ) 1705 : SfxBoolItem( nId, bOn ) 1706 { 1707 } 1708 1709 SfxPoolItem* SvxParaGridItem::Clone( SfxItemPool * ) const 1710 { 1711 return new SvxParaGridItem( GetValue(), Which() ); 1712 } 1713 1714 SfxPoolItem* SvxParaGridItem::Create(SvStream & rStrm, sal_uInt16) const 1715 { 1716 sal_Bool bFlag; 1717 rStrm >> bFlag; 1718 return new SvxParaGridItem( bFlag, Which() ); 1719 } 1720 1721 sal_uInt16 SvxParaGridItem::GetVersion( sal_uInt16 nFFVer ) const 1722 { 1723 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 1724 SOFFICE_FILEFORMAT_40==nFFVer || 1725 SOFFICE_FILEFORMAT_50==nFFVer, 1726 "SvxParaGridItem: Gibt es ein neues Fileformat?" ); 1727 1728 return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; 1729 } 1730 1731 SfxItemPresentation SvxParaGridItem::GetPresentation( 1732 SfxItemPresentation ePres, 1733 SfxMapUnit /*eCoreMetric*/, SfxMapUnit /*ePresMetric*/, 1734 String &rText, const IntlWrapper* /*pIntl*/ ) const 1735 { 1736 switch( ePres ) 1737 { 1738 case SFX_ITEM_PRESENTATION_NONE: 1739 rText.Erase(); 1740 break; 1741 case SFX_ITEM_PRESENTATION_NAMELESS: 1742 case SFX_ITEM_PRESENTATION_COMPLETE: 1743 { 1744 rText = GetValue() ? 1745 EE_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_ON ) : 1746 EE_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_OFF ); 1747 1748 return ePres; 1749 } 1750 default: ;//prevent warning 1751 break; 1752 } 1753 return SFX_ITEM_PRESENTATION_NONE; 1754 } 1755 1756 1757