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/uno/Any.hxx> 29 #include <com/sun/star/script/XTypeConverter.hpp> 30 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 31 #include <com/sun/star/table/CellVertJustify.hpp> 32 #include <com/sun/star/table/ShadowLocation.hpp> 33 #include <com/sun/star/table/TableBorder.hpp> 34 #include <com/sun/star/table/ShadowFormat.hpp> 35 #include <com/sun/star/table/CellRangeAddress.hpp> 36 #include <com/sun/star/table/CellContentType.hpp> 37 #include <com/sun/star/table/TableOrientation.hpp> 38 #include <com/sun/star/table/CellHoriJustify.hpp> 39 #include <com/sun/star/util/SortField.hpp> 40 #include <com/sun/star/util/SortFieldType.hpp> 41 #include <com/sun/star/table/CellOrientation.hpp> 42 #include <com/sun/star/table/CellAddress.hpp> 43 #include <com/sun/star/style/PageStyleLayout.hpp> 44 #include <com/sun/star/style/BreakType.hpp> 45 #include <com/sun/star/style/GraphicLocation.hpp> 46 #include <com/sun/star/awt/Rectangle.hpp> 47 #include <com/sun/star/awt/Selection.hpp> 48 #include <com/sun/star/awt/Size.hpp> 49 #include <com/sun/star/text/WritingMode2.hpp> 50 #include <com/sun/star/frame/status/UpperLowerMarginScale.hpp> 51 52 #include <unotools/ucbstreamhelper.hxx> 53 #include <limits.h> 54 #include <comphelper/processfactory.hxx> 55 #include <svtools/grfmgr.hxx> 56 #include <tools/urlobj.hxx> 57 #include <comphelper/types.hxx> 58 #include <svl/memberid.hrc> 59 #include <svtools/wallitem.hxx> 60 #include <svl/cntwall.hxx> 61 #include <rtl/ustring.hxx> 62 #include <rtl/ustrbuf.hxx> 63 #include <svtools/filter.hxx> 64 65 #define GLOBALOVERFLOW3 66 67 #define _SVX_FRMITEMS_CXX 68 69 #include <editeng/editids.hrc> 70 #include <editeng/editrids.hrc> 71 #include <editeng/pbinitem.hxx> 72 #include <editeng/sizeitem.hxx> 73 #include <editeng/lrspitem.hxx> 74 #include <editeng/ulspitem.hxx> 75 #include <editeng/prntitem.hxx> 76 #include <editeng/opaqitem.hxx> 77 #include <editeng/protitem.hxx> 78 #include <editeng/shaditem.hxx> 79 #include <editeng/boxitem.hxx> 80 #include <editeng/brkitem.hxx> 81 #include <editeng/keepitem.hxx> 82 #include <editeng/bolnitem.hxx> 83 #include <editeng/brshitem.hxx> 84 #include <editeng/frmdiritem.hxx> 85 #include <editeng/itemtype.hxx> 86 #include <editeng/eerdll.hxx> 87 #include <editeng/unoprnms.hxx> 88 #include <editeng/memberids.hrc> 89 #include <editeng/editerr.hxx> 90 91 using namespace ::rtl; 92 using namespace ::com::sun::star; 93 94 95 // Konvertierung fuer UNO 96 #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L)) 97 #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L)) 98 #define TWIP_TO_MM100_UNSIGNED(TWIP) ((((TWIP)*127L+36L)/72L)) 99 #define MM100_TO_TWIP_UNSIGNED(MM100) ((((MM100)*72L+63L)/127L)) 100 101 // STATIC DATA ----------------------------------------------------------- 102 103 104 inline void SetValueProp( XubString& rStr, const sal_uInt16 nValue, 105 const sal_uInt16 nProp ) 106 { 107 if( 100 == nProp ) 108 rStr += String::CreateFromInt32( nValue ); 109 else 110 ( rStr += String::CreateFromInt32( nProp )) += sal_Unicode('%'); 111 } 112 113 inline void SetValueProp( XubString& rStr, const short nValue, 114 const sal_uInt16 nProp ) 115 { 116 if( 100 == nProp ) 117 rStr += String::CreateFromInt32( nValue ); 118 else 119 ( rStr += String::CreateFromInt32( nProp )) += sal_Unicode('%'); 120 } 121 122 // ----------------------------------------------------------------------- 123 124 TYPEINIT1_FACTORY(SvxPaperBinItem, SfxByteItem, new SvxPaperBinItem(0)); 125 TYPEINIT1_FACTORY(SvxSizeItem, SfxPoolItem, new SvxSizeItem(0)); 126 TYPEINIT1_FACTORY(SvxLRSpaceItem, SfxPoolItem, new SvxLRSpaceItem(0)); 127 TYPEINIT1_FACTORY(SvxULSpaceItem, SfxPoolItem, new SvxULSpaceItem(0)); 128 TYPEINIT1_FACTORY(SvxPrintItem, SfxBoolItem, new SvxPrintItem(0)); 129 TYPEINIT1_FACTORY(SvxOpaqueItem, SfxBoolItem, new SvxOpaqueItem(0)); 130 TYPEINIT1_FACTORY(SvxProtectItem, SfxPoolItem, new SvxProtectItem(0)); 131 TYPEINIT1_FACTORY(SvxBrushItem, SfxPoolItem, new SvxBrushItem(0)); 132 TYPEINIT1_FACTORY(SvxShadowItem, SfxPoolItem, new SvxShadowItem(0)); 133 TYPEINIT1_FACTORY(SvxBoxItem, SfxPoolItem, new SvxBoxItem(0)); 134 TYPEINIT1_FACTORY(SvxBoxInfoItem, SfxPoolItem, new SvxBoxInfoItem(0)); 135 TYPEINIT1_FACTORY(SvxFmtBreakItem, SfxEnumItem, new SvxFmtBreakItem(SVX_BREAK_NONE, 0)); 136 TYPEINIT1_FACTORY(SvxFmtKeepItem, SfxBoolItem, new SvxFmtKeepItem(sal_False, 0)); 137 TYPEINIT1_FACTORY(SvxLineItem, SfxPoolItem, new SvxLineItem(0)); 138 TYPEINIT1_FACTORY(SvxFrameDirectionItem, SfxUInt16Item, new SvxFrameDirectionItem(FRMDIR_HORI_LEFT_TOP, 0)); 139 140 141 // class SvxPaperBinItem ------------------------------------------------ 142 143 SfxPoolItem* SvxPaperBinItem::Clone( SfxItemPool* ) const 144 { 145 return new SvxPaperBinItem( *this ); 146 } 147 148 // ----------------------------------------------------------------------- 149 150 SvStream& SvxPaperBinItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 151 { 152 rStrm << GetValue(); 153 return rStrm; 154 } 155 156 // ----------------------------------------------------------------------- 157 158 SfxPoolItem* SvxPaperBinItem::Create( SvStream& rStrm, sal_uInt16 ) const 159 { 160 sal_Int8 nBin; 161 rStrm >> nBin; 162 return new SvxPaperBinItem( Which(), nBin ); 163 } 164 165 // ----------------------------------------------------------------------- 166 167 SfxItemPresentation SvxPaperBinItem::GetPresentation 168 ( 169 SfxItemPresentation ePres, 170 SfxMapUnit /*eCoreUnit*/, 171 SfxMapUnit /*ePresUnit*/, 172 XubString& rText, const IntlWrapper * 173 ) const 174 { 175 switch ( ePres ) 176 { 177 case SFX_ITEM_PRESENTATION_NONE: 178 rText.Erase(); 179 return SFX_ITEM_PRESENTATION_NONE; 180 181 case SFX_ITEM_PRESENTATION_NAMELESS: 182 rText = String::CreateFromInt32( GetValue() ); 183 return SFX_ITEM_PRESENTATION_NAMELESS; 184 185 case SFX_ITEM_PRESENTATION_COMPLETE: 186 { 187 sal_uInt8 nValue = GetValue(); 188 189 if ( PAPERBIN_PRINTER_SETTINGS == nValue ) 190 rText = EE_RESSTR(RID_SVXSTR_PAPERBIN_SETTINGS); 191 else 192 { 193 rText = EE_RESSTR(RID_SVXSTR_PAPERBIN); 194 rText += sal_Unicode(' '); 195 rText += String::CreateFromInt32( nValue ); 196 } 197 return SFX_ITEM_PRESENTATION_COMPLETE; 198 } 199 //no break necessary 200 default: ;//prevent warning 201 } 202 203 return SFX_ITEM_PRESENTATION_NONE; 204 } 205 206 // class SvxSizeItem ----------------------------------------------------- 207 208 SvxSizeItem::SvxSizeItem( const sal_uInt16 nId, const Size& rSize ) : 209 210 SfxPoolItem( nId ), 211 212 aSize( rSize ) 213 { 214 } 215 216 // ----------------------------------------------------------------------- 217 sal_Bool SvxSizeItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 218 { 219 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 220 nMemberId &= ~CONVERT_TWIPS; 221 222 awt::Size aTmp(aSize.Width(), aSize.Height()); 223 if( bConvert ) 224 { 225 aTmp.Height = TWIP_TO_MM100(aTmp.Height); 226 aTmp.Width = TWIP_TO_MM100(aTmp.Width); 227 } 228 229 switch( nMemberId ) 230 { 231 case MID_SIZE_SIZE: rVal <<= aTmp; break; 232 case MID_SIZE_WIDTH: rVal <<= aTmp.Width; break; 233 case MID_SIZE_HEIGHT: rVal <<= aTmp.Height; break; 234 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 235 } 236 237 return sal_True; 238 } 239 // ----------------------------------------------------------------------- 240 sal_Bool SvxSizeItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 241 { 242 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 243 nMemberId &= ~CONVERT_TWIPS; 244 245 switch( nMemberId ) 246 { 247 case MID_SIZE_SIZE: 248 { 249 awt::Size aTmp; 250 if( rVal >>= aTmp ) 251 { 252 if(bConvert) 253 { 254 aTmp.Height = MM100_TO_TWIP(aTmp.Height); 255 aTmp.Width = MM100_TO_TWIP(aTmp.Width); 256 } 257 aSize = Size( aTmp.Width, aTmp.Height ); 258 } 259 else 260 { 261 return sal_False; 262 } 263 } 264 break; 265 case MID_SIZE_WIDTH: 266 { 267 sal_Int32 nVal = 0; 268 if(!(rVal >>= nVal )) 269 return sal_False; 270 271 aSize.Width() = bConvert ? MM100_TO_TWIP(nVal) : nVal; 272 } 273 break; 274 case MID_SIZE_HEIGHT: 275 { 276 sal_Int32 nVal = 0; 277 if(!(rVal >>= nVal)) 278 return sal_True; 279 280 aSize.Height() = bConvert ? MM100_TO_TWIP(nVal) : nVal; 281 } 282 break; 283 default: DBG_ERROR("Wrong MemberId!"); 284 return sal_False; 285 } 286 return sal_True; 287 } 288 289 // ----------------------------------------------------------------------- 290 291 SvxSizeItem::SvxSizeItem( const sal_uInt16 nId ) : 292 293 SfxPoolItem( nId ) 294 { 295 } 296 297 // ----------------------------------------------------------------------- 298 299 int SvxSizeItem::operator==( const SfxPoolItem& rAttr ) const 300 { 301 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 302 303 return ( aSize == ( (SvxSizeItem&)rAttr ).GetSize() ); 304 } 305 306 // ----------------------------------------------------------------------- 307 308 SfxPoolItem* SvxSizeItem::Clone( SfxItemPool* ) const 309 { 310 return new SvxSizeItem( *this ); 311 } 312 313 //------------------------------------------------------------------------ 314 315 SfxItemPresentation SvxSizeItem::GetPresentation 316 ( 317 SfxItemPresentation ePres, 318 SfxMapUnit eCoreUnit, 319 SfxMapUnit ePresUnit, 320 XubString& rText, const IntlWrapper *pIntl 321 ) const 322 { 323 #ifndef SVX_LIGHT 324 switch ( ePres ) 325 { 326 case SFX_ITEM_PRESENTATION_NONE: 327 rText.Erase(); 328 return SFX_ITEM_PRESENTATION_NONE; 329 330 case SFX_ITEM_PRESENTATION_NAMELESS: 331 rText = GetMetricText( aSize.Width(), eCoreUnit, ePresUnit, pIntl ); 332 rText += cpDelim; 333 rText += GetMetricText( aSize.Height(), eCoreUnit, ePresUnit, pIntl ); 334 return SFX_ITEM_PRESENTATION_NAMELESS; 335 336 case SFX_ITEM_PRESENTATION_COMPLETE: 337 rText = EE_RESSTR(RID_SVXITEMS_SIZE_WIDTH); 338 rText += GetMetricText( aSize.Width(), eCoreUnit, ePresUnit, pIntl ); 339 rText += sal_Unicode(' '); 340 rText += EE_RESSTR(GetMetricId(ePresUnit)); 341 rText += cpDelim; 342 rText += EE_RESSTR(RID_SVXITEMS_SIZE_HEIGHT); 343 rText += GetMetricText( aSize.Height(), eCoreUnit, ePresUnit, pIntl ); 344 rText += sal_Unicode(' '); 345 rText += EE_RESSTR(GetMetricId(ePresUnit)); 346 return SFX_ITEM_PRESENTATION_COMPLETE; 347 //no break necessary 348 default: ;//prevent warning 349 350 } 351 #endif // !SVX_LIGHT 352 return SFX_ITEM_PRESENTATION_NONE; 353 } 354 355 // ----------------------------------------------------------------------- 356 357 SvStream& SvxSizeItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 358 { 359 rStrm << aSize.Width(); 360 rStrm << aSize.Height(); 361 return rStrm; 362 } 363 364 // ----------------------------------------------------------------------- 365 366 int SvxSizeItem::ScaleMetrics( long nMult, long nDiv ) 367 { 368 aSize.Width() = Scale( aSize.Width(), nMult, nDiv ); 369 aSize.Height() = Scale( aSize.Height(), nMult, nDiv ); 370 return 1; 371 } 372 373 // ----------------------------------------------------------------------- 374 375 int SvxSizeItem::HasMetrics() const 376 { 377 return 1; 378 } 379 380 // ----------------------------------------------------------------------- 381 382 383 SfxPoolItem* SvxSizeItem::Create( SvStream& rStrm, sal_uInt16 ) const 384 { 385 long nWidth, nHeight; 386 rStrm >> nWidth >> nHeight; 387 388 SvxSizeItem* pAttr = new SvxSizeItem( Which() ); 389 pAttr->SetSize(Size(nWidth, nHeight)); 390 391 return pAttr; 392 } 393 394 // class SvxLRSpaceItem -------------------------------------------------- 395 396 SvxLRSpaceItem::SvxLRSpaceItem( const sal_uInt16 nId ) : 397 398 SfxPoolItem( nId ), 399 400 nFirstLineOfst ( 0 ), 401 nTxtLeft ( 0 ), 402 nLeftMargin ( 0 ), 403 nRightMargin ( 0 ), 404 nPropFirstLineOfst( 100 ), 405 nPropLeftMargin( 100 ), 406 nPropRightMargin( 100 ), 407 bAutoFirst ( 0 ) 408 { 409 } 410 411 // ----------------------------------------------------------------------- 412 413 SvxLRSpaceItem::SvxLRSpaceItem( const long nLeft, const long nRight, 414 const long nTLeft, const short nOfset, 415 const sal_uInt16 nId ) : 416 417 SfxPoolItem( nId ), 418 419 nFirstLineOfst ( nOfset ), 420 nTxtLeft ( nTLeft ), 421 nLeftMargin ( nLeft ), 422 nRightMargin ( nRight ), 423 nPropFirstLineOfst( 100 ), 424 nPropLeftMargin( 100 ), 425 nPropRightMargin( 100 ), 426 bAutoFirst ( 0 ) 427 { 428 } 429 430 // ----------------------------------------------------------------------- 431 sal_Bool SvxLRSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 432 { 433 sal_Bool bRet = sal_True; 434 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 435 nMemberId &= ~CONVERT_TWIPS; 436 switch( nMemberId ) 437 { 438 // jetzt alles signed 439 case MID_L_MARGIN: 440 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nLeftMargin) : nLeftMargin); 441 break; 442 443 case MID_TXT_LMARGIN : 444 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nTxtLeft) : nTxtLeft); 445 break; 446 case MID_R_MARGIN: 447 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nRightMargin) : nRightMargin); 448 break; 449 case MID_L_REL_MARGIN: 450 rVal <<= (sal_Int16)nPropLeftMargin; 451 break; 452 case MID_R_REL_MARGIN: 453 rVal <<= (sal_Int16)nPropRightMargin; 454 break; 455 456 case MID_FIRST_LINE_INDENT: 457 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nFirstLineOfst) : nFirstLineOfst); 458 break; 459 460 case MID_FIRST_LINE_REL_INDENT: 461 rVal <<= (sal_Int16)(nPropFirstLineOfst); 462 break; 463 464 case MID_FIRST_AUTO: 465 rVal = Bool2Any(IsAutoFirst()); 466 break; 467 468 default: 469 bRet = sal_False; 470 DBG_ERROR("unknown MemberId"); 471 } 472 return bRet; 473 } 474 475 // ----------------------------------------------------------------------- 476 sal_Bool SvxLRSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 477 { 478 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 479 nMemberId &= ~CONVERT_TWIPS; 480 sal_Int32 nVal = 0; 481 if( nMemberId != MID_FIRST_AUTO && 482 nMemberId != MID_L_REL_MARGIN && nMemberId != MID_R_REL_MARGIN) 483 if(!(rVal >>= nVal)) 484 return sal_False; 485 486 switch( nMemberId ) 487 { 488 case MID_L_MARGIN: 489 SetLeft((sal_Int32)bConvert ? MM100_TO_TWIP(nVal) : nVal); 490 break; 491 492 case MID_TXT_LMARGIN : 493 SetTxtLeft((sal_Int32)bConvert ? MM100_TO_TWIP(nVal) : nVal); 494 break; 495 496 case MID_R_MARGIN: 497 SetRight((sal_Int32) bConvert ? MM100_TO_TWIP(nVal) : nVal); 498 break; 499 case MID_L_REL_MARGIN: 500 case MID_R_REL_MARGIN: 501 { 502 sal_Int32 nRel = 0; 503 if((rVal >>= nRel) && nRel >= 0 && nRel < USHRT_MAX) 504 { 505 if(MID_L_REL_MARGIN== nMemberId) 506 nPropLeftMargin = (sal_uInt16)nRel; 507 else 508 nPropRightMargin = (sal_uInt16)nRel; 509 } 510 else 511 return sal_False; 512 } 513 break; 514 case MID_FIRST_LINE_INDENT : 515 SetTxtFirstLineOfst((short)(bConvert ? MM100_TO_TWIP(nVal) : nVal)); 516 break; 517 518 case MID_FIRST_LINE_REL_INDENT: 519 SetPropTxtFirstLineOfst ( (sal_uInt16)nVal ); 520 break; 521 522 case MID_FIRST_AUTO: 523 SetAutoFirst( Any2Bool(rVal) ); 524 break; 525 526 default: 527 DBG_ERROR("unknown MemberId"); 528 return sal_False; 529 } 530 return sal_True; 531 } 532 533 // ----------------------------------------------------------------------- 534 535 // nLeftMargin und nTxtLeft anpassen. 536 537 void SvxLRSpaceItem::AdjustLeft() 538 { 539 if ( 0 > nFirstLineOfst ) 540 nLeftMargin = nTxtLeft + nFirstLineOfst; 541 else 542 nLeftMargin = nTxtLeft; 543 } 544 545 // ----------------------------------------------------------------------- 546 547 int SvxLRSpaceItem::operator==( const SfxPoolItem& rAttr ) const 548 { 549 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 550 551 return ( 552 nLeftMargin == ((SvxLRSpaceItem&)rAttr).GetLeft() && 553 nRightMargin == ((SvxLRSpaceItem&)rAttr).GetRight() && 554 nFirstLineOfst == ((SvxLRSpaceItem&)rAttr).GetTxtFirstLineOfst() && 555 nPropLeftMargin == ((SvxLRSpaceItem&)rAttr).GetPropLeft() && 556 nPropRightMargin == ((SvxLRSpaceItem&)rAttr).GetPropRight() && 557 nPropFirstLineOfst == ((SvxLRSpaceItem&)rAttr).GetPropTxtFirstLineOfst() && 558 bAutoFirst == ((SvxLRSpaceItem&)rAttr).IsAutoFirst() ); 559 } 560 561 // ----------------------------------------------------------------------- 562 563 SfxPoolItem* SvxLRSpaceItem::Clone( SfxItemPool* ) const 564 { 565 return new SvxLRSpaceItem( *this ); 566 } 567 568 //------------------------------------------------------------------------ 569 570 SfxItemPresentation SvxLRSpaceItem::GetPresentation 571 ( 572 SfxItemPresentation ePres, 573 SfxMapUnit eCoreUnit, 574 SfxMapUnit ePresUnit, 575 XubString& rText, const IntlWrapper* pIntl 576 ) const 577 { 578 #ifndef SVX_LIGHT 579 switch ( ePres ) 580 { 581 case SFX_ITEM_PRESENTATION_NONE: 582 rText.Erase(); 583 return SFX_ITEM_PRESENTATION_NONE; 584 case SFX_ITEM_PRESENTATION_NAMELESS: 585 { 586 if ( 100 != nPropLeftMargin ) 587 ( rText = String::CreateFromInt32( nPropLeftMargin )) += sal_Unicode('%'); 588 else 589 rText = GetMetricText( (long)nLeftMargin, 590 eCoreUnit, ePresUnit, pIntl ); 591 rText += cpDelim; 592 if ( 100 != nPropFirstLineOfst ) 593 ( rText += String::CreateFromInt32( nPropFirstLineOfst )) += sal_Unicode('%'); 594 else 595 rText += GetMetricText( (long)nFirstLineOfst, 596 eCoreUnit, ePresUnit, pIntl ); 597 rText += cpDelim; 598 if ( 100 != nRightMargin ) 599 ( rText += String::CreateFromInt32( nRightMargin )) += sal_Unicode('%'); 600 else 601 rText += GetMetricText( (long)nRightMargin, 602 eCoreUnit, ePresUnit, pIntl ); 603 return SFX_ITEM_PRESENTATION_NAMELESS; 604 } 605 case SFX_ITEM_PRESENTATION_COMPLETE: 606 { 607 rText = EE_RESSTR(RID_SVXITEMS_LRSPACE_LEFT); 608 if ( 100 != nPropLeftMargin ) 609 ( rText += String::CreateFromInt32( nPropLeftMargin )) += sal_Unicode('%'); 610 else 611 { 612 rText += GetMetricText( (long)nLeftMargin, 613 eCoreUnit, ePresUnit, pIntl ); 614 rText += sal_Unicode(' '); 615 rText += EE_RESSTR(GetMetricId(ePresUnit)); 616 } 617 rText += cpDelim; 618 if ( 100 != nPropFirstLineOfst || nFirstLineOfst ) 619 { 620 rText += EE_RESSTR(RID_SVXITEMS_LRSPACE_FLINE); 621 if ( 100 != nPropFirstLineOfst ) 622 ( rText += String::CreateFromInt32( nPropFirstLineOfst )) 623 += sal_Unicode('%'); 624 else 625 { 626 rText += GetMetricText( (long)nFirstLineOfst, 627 eCoreUnit, ePresUnit, pIntl ); 628 rText += sal_Unicode(' '); 629 rText += EE_RESSTR(GetMetricId(ePresUnit)); 630 } 631 rText += cpDelim; 632 } 633 rText += EE_RESSTR(RID_SVXITEMS_LRSPACE_RIGHT); 634 if ( 100 != nPropRightMargin ) 635 ( rText += String::CreateFromInt32( nPropRightMargin )) += sal_Unicode('%'); 636 else 637 { 638 rText += GetMetricText( (long)nRightMargin, 639 eCoreUnit, ePresUnit, pIntl ); 640 rText += sal_Unicode(' '); 641 rText += EE_RESSTR(GetMetricId(ePresUnit)); 642 } 643 return SFX_ITEM_PRESENTATION_COMPLETE; 644 } 645 default: ;//prevent warning 646 } 647 #endif // !SVX_LIGHT 648 return SFX_ITEM_PRESENTATION_NONE; 649 } 650 651 // ----------------------------------------------------------------------- 652 653 // MT: BulletFI: Vor 501 wurde im Outliner das Bullet nicht auf der Position des 654 // FI positioniert, deshalb muss in aelteren Dokumenten der FI auf 0 stehen. 655 656 #define BULLETLR_MARKER 0x599401FE 657 658 SvStream& SvxLRSpaceItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const 659 { 660 short nSaveFI = nFirstLineOfst; 661 ((SvxLRSpaceItem*)this)->SetTxtFirstLineOfst( 0 ); // nLeftMargin wird mitmanipuliert, siehe Create() 662 663 sal_uInt16 nMargin = 0; 664 if( nLeftMargin > 0 ) 665 nMargin = sal_uInt16( nLeftMargin ); 666 rStrm << nMargin; 667 rStrm << nPropLeftMargin; 668 if( nRightMargin > 0 ) 669 nMargin = sal_uInt16( nRightMargin ); 670 else 671 nMargin = 0; 672 rStrm << nMargin; 673 rStrm << nPropRightMargin; 674 rStrm << nFirstLineOfst; 675 rStrm << nPropFirstLineOfst; 676 if( nTxtLeft > 0 ) 677 nMargin = sal_uInt16( nTxtLeft ); 678 else 679 nMargin = 0; 680 rStrm << nMargin; 681 if( nItemVersion >= LRSPACE_AUTOFIRST_VERSION ) 682 { 683 sal_Int8 nAutoFirst = bAutoFirst ? 1 : 0; 684 if( nItemVersion >= LRSPACE_NEGATIVE_VERSION && 685 ( nLeftMargin < 0 || nRightMargin < 0 || nTxtLeft < 0 ) ) 686 nAutoFirst |= 0x80; 687 rStrm << nAutoFirst; 688 689 // Ab 6.0 keine Magicnumber schreiben... 690 DBG_ASSERT( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_50, "MT: Fileformat SvxLRSpaceItem aendern!" ); 691 rStrm << (sal_uInt32) BULLETLR_MARKER; 692 rStrm << nSaveFI; 693 694 if( 0x80 & nAutoFirst ) 695 { 696 rStrm << nLeftMargin; 697 rStrm << nRightMargin; 698 } 699 } 700 701 ((SvxLRSpaceItem*)this)->SetTxtFirstLineOfst( nSaveFI ); 702 703 return rStrm; 704 } 705 706 // ----------------------------------------------------------------------- 707 708 SfxPoolItem* SvxLRSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const 709 { 710 sal_uInt16 left, prpleft, right, prpright, prpfirstline, txtleft; 711 short firstline; 712 sal_Int8 autofirst = 0; 713 714 if ( nVersion >= LRSPACE_AUTOFIRST_VERSION ) 715 { 716 rStrm >> left >> prpleft >> right >> prpright >> firstline >> 717 prpfirstline >> txtleft >> autofirst; 718 719 sal_uInt32 nPos = rStrm.Tell(); 720 sal_uInt32 nMarker; 721 rStrm >> nMarker; 722 if ( nMarker == BULLETLR_MARKER ) 723 { 724 rStrm >> firstline; 725 if ( firstline < 0 ) 726 left = left + static_cast<sal_uInt16>(firstline); // s.u.: txtleft = ... 727 } 728 else 729 rStrm.Seek( nPos ); 730 } 731 else if ( nVersion == LRSPACE_TXTLEFT_VERSION ) 732 { 733 rStrm >> left >> prpleft >> right >> prpright >> firstline >> 734 prpfirstline >> txtleft; 735 } 736 else if ( nVersion == LRSPACE_16_VERSION ) 737 { 738 rStrm >> left >> prpleft >> right >> prpright >> firstline >> 739 prpfirstline; 740 } 741 else 742 { 743 sal_Int8 nL, nR, nFL; 744 rStrm >> left >> nL >> right >> nR >> firstline >> nFL; 745 prpleft = (sal_uInt16)nL; 746 prpright = (sal_uInt16)nR; 747 prpfirstline = (sal_uInt16)nFL; 748 } 749 750 txtleft = firstline >= 0 ? left : left - firstline; 751 SvxLRSpaceItem* pAttr = new SvxLRSpaceItem( Which() ); 752 753 pAttr->nLeftMargin = left; 754 pAttr->nPropLeftMargin = prpleft; 755 pAttr->nRightMargin = right; 756 pAttr->nPropRightMargin = prpright; 757 pAttr->nFirstLineOfst = firstline; 758 pAttr->nPropFirstLineOfst = prpfirstline; 759 pAttr->nTxtLeft = txtleft; 760 pAttr->bAutoFirst = autofirst & 0x01; 761 if( nVersion >= LRSPACE_NEGATIVE_VERSION && ( autofirst & 0x80 ) ) 762 { 763 sal_Int32 nMargin; 764 rStrm >> nMargin; 765 pAttr->nLeftMargin = nMargin; 766 pAttr->nTxtLeft = firstline >= 0 ? nMargin : nMargin - firstline; 767 rStrm >> nMargin; 768 pAttr->nRightMargin = nMargin; 769 } 770 return pAttr; 771 } 772 773 // ----------------------------------------------------------------------- 774 775 sal_uInt16 SvxLRSpaceItem::GetVersion( sal_uInt16 nFileVersion ) const 776 { 777 return (nFileVersion == SOFFICE_FILEFORMAT_31) 778 ? LRSPACE_TXTLEFT_VERSION 779 : LRSPACE_NEGATIVE_VERSION; 780 } 781 782 // ----------------------------------------------------------------------- 783 784 int SvxLRSpaceItem::ScaleMetrics( long nMult, long nDiv ) 785 { 786 nFirstLineOfst = (short)Scale( nFirstLineOfst, nMult, nDiv ); 787 nTxtLeft = Scale( nTxtLeft, nMult, nDiv ); 788 nLeftMargin = Scale( nLeftMargin, nMult, nDiv ); 789 nRightMargin = Scale( nRightMargin, nMult, nDiv ); 790 return 1; 791 } 792 793 // ----------------------------------------------------------------------- 794 795 int SvxLRSpaceItem::HasMetrics() const 796 { 797 return 1; 798 } 799 800 // class SvxULSpaceItem -------------------------------------------------- 801 802 SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nId ) : 803 804 SfxPoolItem( nId ), 805 806 nUpper( 0 ), 807 nLower( 0 ), 808 nPropUpper( 100 ), 809 nPropLower( 100 ) 810 { 811 } 812 813 // ----------------------------------------------------------------------- 814 815 SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nUp, const sal_uInt16 nLow, 816 const sal_uInt16 nId ) : 817 818 SfxPoolItem( nId ), 819 820 nUpper( nUp ), 821 nLower( nLow ), 822 nPropUpper( 100 ), 823 nPropLower( 100 ) 824 { 825 } 826 827 // ----------------------------------------------------------------------- 828 sal_Bool SvxULSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 829 { 830 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 831 nMemberId &= ~CONVERT_TWIPS; 832 switch( nMemberId ) 833 { 834 // jetzt alles signed 835 case 0: 836 { 837 ::com::sun::star::frame::status::UpperLowerMarginScale aUpperLowerMarginScale; 838 aUpperLowerMarginScale.Upper = (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(nUpper) : nUpper); 839 aUpperLowerMarginScale.Lower = (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(nLower) : nPropUpper); 840 aUpperLowerMarginScale.ScaleUpper = (sal_Int16)nPropUpper; 841 aUpperLowerMarginScale.ScaleLower = (sal_Int16)nPropLower; 842 rVal <<= aUpperLowerMarginScale; 843 break; 844 } 845 case MID_UP_MARGIN: rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(nUpper) : nUpper); break; 846 case MID_LO_MARGIN: rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(nLower) : nLower); break; 847 case MID_UP_REL_MARGIN: rVal <<= (sal_Int16) nPropUpper; break; 848 case MID_LO_REL_MARGIN: rVal <<= (sal_Int16) nPropLower; break; 849 } 850 return sal_True; 851 } 852 853 // ----------------------------------------------------------------------- 854 sal_Bool SvxULSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 855 { 856 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 857 nMemberId &= ~CONVERT_TWIPS; 858 sal_Int32 nVal = 0; 859 switch( nMemberId ) 860 { 861 case 0: 862 { 863 ::com::sun::star::frame::status::UpperLowerMarginScale aUpperLowerMarginScale; 864 if ( !(rVal >>= aUpperLowerMarginScale )) 865 return sal_False; 866 { 867 SetUpper((sal_uInt16)(bConvert ? MM100_TO_TWIP( aUpperLowerMarginScale.Upper ) : aUpperLowerMarginScale.Upper)); 868 SetLower((sal_uInt16)(bConvert ? MM100_TO_TWIP( aUpperLowerMarginScale.Lower ) : aUpperLowerMarginScale.Lower)); 869 if( aUpperLowerMarginScale.ScaleUpper > 1 ) 870 nPropUpper = aUpperLowerMarginScale.ScaleUpper; 871 if( aUpperLowerMarginScale.ScaleLower > 1 ) 872 nPropUpper = aUpperLowerMarginScale.ScaleLower; 873 } 874 } 875 876 case MID_UP_MARGIN : 877 if(!(rVal >>= nVal) || nVal < 0) 878 return sal_False; 879 SetUpper((sal_uInt16)(bConvert ? MM100_TO_TWIP(nVal) : nVal)); 880 break; 881 case MID_LO_MARGIN : 882 if(!(rVal >>= nVal) || nVal < 0) 883 return sal_False; 884 SetLower((sal_uInt16)(bConvert ? MM100_TO_TWIP(nVal) : nVal)); 885 break; 886 case MID_UP_REL_MARGIN: 887 case MID_LO_REL_MARGIN: 888 { 889 sal_Int32 nRel = 0; 890 if((rVal >>= nRel) && nRel > 1 ) 891 { 892 if(MID_UP_REL_MARGIN == nMemberId) 893 nPropUpper = (sal_uInt16)nRel; 894 else 895 nPropLower = (sal_uInt16)nRel; 896 } 897 else 898 return sal_False; 899 } 900 break; 901 902 903 default: 904 DBG_ERROR("unknown MemberId"); 905 return sal_False; 906 } 907 return sal_True; 908 } 909 910 // ----------------------------------------------------------------------- 911 912 int SvxULSpaceItem::operator==( const SfxPoolItem& rAttr ) const 913 { 914 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 915 916 return ( nUpper == ( (SvxULSpaceItem&)rAttr ).nUpper && 917 nLower == ( (SvxULSpaceItem&)rAttr ).nLower && 918 nPropUpper == ( (SvxULSpaceItem&)rAttr ).nPropUpper && 919 nPropLower == ( (SvxULSpaceItem&)rAttr ).nPropLower ); 920 } 921 922 // ----------------------------------------------------------------------- 923 924 SfxPoolItem* SvxULSpaceItem::Clone( SfxItemPool* ) const 925 { 926 return new SvxULSpaceItem( *this ); 927 } 928 929 //------------------------------------------------------------------------ 930 931 SfxItemPresentation SvxULSpaceItem::GetPresentation 932 ( 933 SfxItemPresentation ePres, 934 SfxMapUnit eCoreUnit, 935 SfxMapUnit ePresUnit, 936 XubString& rText, const IntlWrapper *pIntl 937 ) const 938 { 939 #ifndef SVX_LIGHT 940 switch ( ePres ) 941 { 942 case SFX_ITEM_PRESENTATION_NONE: 943 rText.Erase(); 944 return SFX_ITEM_PRESENTATION_NONE; 945 case SFX_ITEM_PRESENTATION_NAMELESS: 946 { 947 if ( 100 != nPropUpper ) 948 ( rText = String::CreateFromInt32( nPropUpper )) += sal_Unicode('%'); 949 else 950 rText = GetMetricText( (long)nUpper, eCoreUnit, ePresUnit, pIntl ); 951 rText += cpDelim; 952 if ( 100 != nPropLower ) 953 ( rText += String::CreateFromInt32( nPropLower )) += sal_Unicode('%'); 954 else 955 rText += GetMetricText( (long)nLower, eCoreUnit, ePresUnit, pIntl ); 956 return SFX_ITEM_PRESENTATION_NAMELESS; 957 } 958 case SFX_ITEM_PRESENTATION_COMPLETE: 959 { 960 rText = EE_RESSTR(RID_SVXITEMS_ULSPACE_UPPER); 961 if ( 100 != nPropUpper ) 962 ( rText += String::CreateFromInt32( nPropUpper )) += sal_Unicode('%'); 963 else 964 { 965 rText += GetMetricText( (long)nUpper, eCoreUnit, ePresUnit, pIntl ); 966 rText += sal_Unicode(' '); 967 rText += EE_RESSTR(GetMetricId(ePresUnit)); 968 } 969 rText += cpDelim; 970 rText += EE_RESSTR(RID_SVXITEMS_ULSPACE_LOWER); 971 if ( 100 != nPropLower ) 972 ( rText += String::CreateFromInt32( nPropLower )) += sal_Unicode('%'); 973 else 974 { 975 rText += GetMetricText( (long)nLower, eCoreUnit, ePresUnit, pIntl ); 976 rText += sal_Unicode(' '); 977 rText += EE_RESSTR(GetMetricId(ePresUnit)); 978 } 979 return SFX_ITEM_PRESENTATION_COMPLETE; 980 } 981 default: ;//prevent warning 982 } 983 #endif 984 return SFX_ITEM_PRESENTATION_NONE; 985 } 986 987 // ----------------------------------------------------------------------- 988 989 SvStream& SvxULSpaceItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 990 { 991 rStrm << GetUpper() 992 << GetPropUpper() 993 << GetLower() 994 << GetPropLower(); 995 return rStrm; 996 } 997 998 // ----------------------------------------------------------------------- 999 1000 SfxPoolItem* SvxULSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const 1001 { 1002 sal_uInt16 upper, lower, nPL = 0, nPU = 0; 1003 1004 if ( nVersion == ULSPACE_16_VERSION ) 1005 rStrm >> upper >> nPU >> lower >> nPL; 1006 else 1007 { 1008 sal_Int8 nU, nL; 1009 rStrm >> upper >> nU >> lower >> nL; 1010 nPL = (sal_uInt16)nL; 1011 nPU = (sal_uInt16)nU; 1012 } 1013 1014 SvxULSpaceItem* pAttr = new SvxULSpaceItem( Which() ); 1015 pAttr->SetUpperValue( upper ); 1016 pAttr->SetLowerValue( lower ); 1017 pAttr->SetPropUpper( nPU ); 1018 pAttr->SetPropLower( nPL ); 1019 return pAttr; 1020 } 1021 1022 // ----------------------------------------------------------------------- 1023 1024 sal_uInt16 SvxULSpaceItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const 1025 { 1026 return ULSPACE_16_VERSION; 1027 } 1028 1029 // ----------------------------------------------------------------------- 1030 1031 int SvxULSpaceItem::ScaleMetrics( long nMult, long nDiv ) 1032 { 1033 nUpper = (sal_uInt16)Scale( nUpper, nMult, nDiv ); 1034 nLower = (sal_uInt16)Scale( nLower, nMult, nDiv ); 1035 return 1; 1036 } 1037 1038 // ----------------------------------------------------------------------- 1039 1040 int SvxULSpaceItem::HasMetrics() const 1041 { 1042 return 1; 1043 } 1044 1045 1046 // class SvxPrintItem ---------------------------------------------------- 1047 1048 SfxPoolItem* SvxPrintItem::Clone( SfxItemPool* ) const 1049 { 1050 return new SvxPrintItem( *this ); 1051 } 1052 1053 // ----------------------------------------------------------------------- 1054 1055 SvStream& SvxPrintItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 1056 { 1057 rStrm << (sal_Int8)GetValue(); 1058 return rStrm; 1059 } 1060 1061 // ----------------------------------------------------------------------- 1062 1063 SfxPoolItem* SvxPrintItem::Create( SvStream& rStrm, sal_uInt16 ) const 1064 { 1065 sal_Int8 bIsPrint; 1066 rStrm >> bIsPrint; 1067 return new SvxPrintItem( Which(), sal_Bool( bIsPrint != 0 ) ); 1068 } 1069 1070 //------------------------------------------------------------------------ 1071 1072 SfxItemPresentation SvxPrintItem::GetPresentation 1073 ( 1074 SfxItemPresentation ePres, 1075 SfxMapUnit /*eCoreUnit*/, 1076 SfxMapUnit /*ePresUnit*/, 1077 XubString& rText, const IntlWrapper * 1078 ) const 1079 { 1080 #ifndef SVX_LIGHT 1081 switch ( ePres ) 1082 { 1083 case SFX_ITEM_PRESENTATION_NONE: 1084 rText.Erase(); 1085 return ePres; 1086 1087 case SFX_ITEM_PRESENTATION_NAMELESS: 1088 case SFX_ITEM_PRESENTATION_COMPLETE: 1089 { 1090 sal_uInt16 nId = RID_SVXITEMS_PRINT_FALSE; 1091 1092 if ( GetValue() ) 1093 nId = RID_SVXITEMS_PRINT_TRUE; 1094 rText = EE_RESSTR(nId); 1095 return ePres; 1096 } 1097 default: ;//prevent warning 1098 } 1099 #endif // !SVX_LIGHT 1100 return SFX_ITEM_PRESENTATION_NONE; 1101 } 1102 1103 // class SvxOpaqueItem --------------------------------------------------- 1104 1105 SfxPoolItem* SvxOpaqueItem::Clone( SfxItemPool* ) const 1106 { 1107 return new SvxOpaqueItem( *this ); 1108 } 1109 1110 // ----------------------------------------------------------------------- 1111 1112 SvStream& SvxOpaqueItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 1113 { 1114 rStrm << (sal_Int8)GetValue(); 1115 return rStrm; 1116 } 1117 1118 // ----------------------------------------------------------------------- 1119 1120 SfxPoolItem* SvxOpaqueItem::Create( SvStream& rStrm, sal_uInt16 ) const 1121 { 1122 sal_Int8 bIsOpaque; 1123 rStrm >> bIsOpaque; 1124 return new SvxOpaqueItem( Which(), sal_Bool( bIsOpaque != 0 ) ); 1125 } 1126 1127 //------------------------------------------------------------------------ 1128 1129 SfxItemPresentation SvxOpaqueItem::GetPresentation 1130 ( 1131 SfxItemPresentation ePres, 1132 SfxMapUnit /*eCoreUnit*/, 1133 SfxMapUnit /*ePresUnit*/, 1134 XubString& rText, const IntlWrapper * 1135 ) const 1136 { 1137 #ifndef SVX_LIGHT 1138 switch ( ePres ) 1139 { 1140 case SFX_ITEM_PRESENTATION_NONE: 1141 rText.Erase(); 1142 return ePres; 1143 1144 case SFX_ITEM_PRESENTATION_NAMELESS: 1145 case SFX_ITEM_PRESENTATION_COMPLETE: 1146 { 1147 sal_uInt16 nId = RID_SVXITEMS_OPAQUE_FALSE; 1148 1149 if ( GetValue() ) 1150 nId = RID_SVXITEMS_OPAQUE_TRUE; 1151 rText = EE_RESSTR(nId); 1152 return ePres; 1153 } 1154 default: ;//prevent warning 1155 } 1156 #endif // !SVX_LIGHT 1157 return SFX_ITEM_PRESENTATION_NONE; 1158 } 1159 1160 // class SvxProtectItem -------------------------------------------------- 1161 1162 int SvxProtectItem::operator==( const SfxPoolItem& rAttr ) const 1163 { 1164 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 1165 1166 return ( bCntnt == ( (SvxProtectItem&)rAttr ).bCntnt && 1167 bSize == ( (SvxProtectItem&)rAttr ).bSize && 1168 bPos == ( (SvxProtectItem&)rAttr ).bPos ); 1169 } 1170 1171 /*-----------------16.03.98 12:42------------------- 1172 --------------------------------------------------*/ 1173 sal_Bool SvxProtectItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1174 { 1175 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1176 nMemberId &= ~CONVERT_TWIPS; 1177 sal_Bool bValue; 1178 switch(nMemberId) 1179 { 1180 case MID_PROTECT_CONTENT : bValue = bCntnt; break; 1181 case MID_PROTECT_SIZE : bValue = bSize; break; 1182 case MID_PROTECT_POSITION: bValue = bPos; break; 1183 default: 1184 DBG_ERROR("falsche MemberId"); 1185 return sal_False; 1186 } 1187 1188 rVal = Bool2Any( bValue ); 1189 return sal_True; 1190 } 1191 /*-----------------16.03.98 12:42------------------- 1192 1193 --------------------------------------------------*/ 1194 sal_Bool SvxProtectItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1195 { 1196 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1197 nMemberId &= ~CONVERT_TWIPS; 1198 sal_Bool bVal( Any2Bool(rVal) ); 1199 switch(nMemberId) 1200 { 1201 case MID_PROTECT_CONTENT : bCntnt = bVal; break; 1202 case MID_PROTECT_SIZE : bSize = bVal; break; 1203 case MID_PROTECT_POSITION: bPos = bVal; break; 1204 default: 1205 DBG_ERROR("falsche MemberId"); 1206 return sal_False; 1207 } 1208 return sal_True; 1209 } 1210 1211 // ----------------------------------------------------------------------- 1212 1213 SfxPoolItem* SvxProtectItem::Clone( SfxItemPool* ) const 1214 { 1215 return new SvxProtectItem( *this ); 1216 } 1217 1218 //------------------------------------------------------------------------ 1219 1220 SfxItemPresentation SvxProtectItem::GetPresentation 1221 ( 1222 SfxItemPresentation ePres, 1223 SfxMapUnit /*eCoreUnit*/, 1224 SfxMapUnit /*ePresUnit*/, 1225 XubString& rText, const IntlWrapper * 1226 ) const 1227 { 1228 #ifndef SVX_LIGHT 1229 switch ( ePres ) 1230 { 1231 case SFX_ITEM_PRESENTATION_NONE: 1232 rText.Erase(); 1233 return ePres; 1234 1235 case SFX_ITEM_PRESENTATION_NAMELESS: 1236 case SFX_ITEM_PRESENTATION_COMPLETE: 1237 { 1238 sal_uInt16 nId = RID_SVXITEMS_PROT_CONTENT_FALSE; 1239 1240 if ( bCntnt ) 1241 nId = RID_SVXITEMS_PROT_CONTENT_TRUE; 1242 rText = EE_RESSTR(nId); 1243 rText += cpDelim; 1244 nId = RID_SVXITEMS_PROT_SIZE_FALSE; 1245 1246 if ( bSize ) 1247 nId = RID_SVXITEMS_PROT_SIZE_TRUE; 1248 rText += EE_RESSTR(nId); 1249 rText += cpDelim; 1250 nId = RID_SVXITEMS_PROT_POS_FALSE; 1251 1252 if ( bPos ) 1253 nId = RID_SVXITEMS_PROT_POS_TRUE; 1254 rText += EE_RESSTR(nId); 1255 return ePres; 1256 } 1257 default: ;//prevent warning 1258 } 1259 #endif // !SVX_LIGHT 1260 return SFX_ITEM_PRESENTATION_NONE; 1261 } 1262 1263 // ----------------------------------------------------------------------- 1264 1265 SvStream& SvxProtectItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 1266 { 1267 sal_Int8 cProt = 0; 1268 if( IsPosProtected() ) cProt |= 0x01; 1269 if( IsSizeProtected() ) cProt |= 0x02; 1270 if( IsCntntProtected() ) cProt |= 0x04; 1271 rStrm << (sal_Int8) cProt; 1272 return rStrm; 1273 } 1274 1275 // ----------------------------------------------------------------------- 1276 1277 SfxPoolItem* SvxProtectItem::Create( SvStream& rStrm, sal_uInt16 ) const 1278 { 1279 sal_Int8 cFlags; 1280 rStrm >> cFlags; 1281 SvxProtectItem* pAttr = new SvxProtectItem( Which() ); 1282 pAttr->SetPosProtect( sal_Bool( ( cFlags & 0x01 ) != 0 ) ); 1283 pAttr->SetSizeProtect( sal_Bool( ( cFlags & 0x02 ) != 0 ) ); 1284 pAttr->SetCntntProtect( sal_Bool( ( cFlags & 0x04 ) != 0 ) ); 1285 return pAttr; 1286 } 1287 1288 // class SvxShadowItem --------------------------------------------------- 1289 1290 SvxShadowItem::SvxShadowItem( const sal_uInt16 nId, 1291 const Color *pColor, const sal_uInt16 nW, 1292 const SvxShadowLocation eLoc ) : 1293 SfxEnumItemInterface( nId ), 1294 aShadowColor(COL_GRAY), 1295 nWidth ( nW ), 1296 eLocation ( eLoc ) 1297 { 1298 if ( pColor ) 1299 aShadowColor = *pColor; 1300 } 1301 1302 // ----------------------------------------------------------------------- 1303 sal_Bool SvxShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1304 { 1305 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1306 nMemberId &= ~CONVERT_TWIPS; 1307 1308 table::ShadowFormat aShadow; 1309 table::ShadowLocation eSet = table::ShadowLocation_NONE; 1310 switch( eLocation ) 1311 { 1312 case SVX_SHADOW_TOPLEFT : eSet = table::ShadowLocation_TOP_LEFT ; break; 1313 case SVX_SHADOW_TOPRIGHT : eSet = table::ShadowLocation_TOP_RIGHT ; break; 1314 case SVX_SHADOW_BOTTOMLEFT : eSet = table::ShadowLocation_BOTTOM_LEFT ; break; 1315 case SVX_SHADOW_BOTTOMRIGHT: eSet = table::ShadowLocation_BOTTOM_RIGHT; break; 1316 default: ;//prevent warning 1317 } 1318 aShadow.Location = eSet; 1319 aShadow.ShadowWidth = bConvert ? TWIP_TO_MM100_UNSIGNED(nWidth) : nWidth; 1320 aShadow.IsTransparent = aShadowColor.GetTransparency() > 0; 1321 aShadow.Color = aShadowColor.GetRGBColor(); 1322 1323 switch ( nMemberId ) 1324 { 1325 case MID_LOCATION: rVal <<= aShadow.Location; break; 1326 case MID_WIDTH: rVal <<= aShadow.ShadowWidth; break; 1327 case MID_TRANSPARENT: rVal <<= aShadow.IsTransparent; break; 1328 case MID_BG_COLOR: rVal <<= aShadow.Color; break; 1329 case 0: rVal <<= aShadow; break; 1330 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 1331 } 1332 1333 return sal_True; 1334 } 1335 // ----------------------------------------------------------------------- 1336 sal_Bool SvxShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1337 { 1338 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1339 nMemberId &= ~CONVERT_TWIPS; 1340 1341 table::ShadowFormat aShadow; 1342 uno::Any aAny; 1343 sal_Bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aShadow ); 1344 switch ( nMemberId ) 1345 { 1346 case MID_LOCATION: 1347 { 1348 bRet = (rVal >>= aShadow.Location); 1349 if ( !bRet ) 1350 { 1351 sal_Int16 nVal = 0; 1352 bRet = (rVal >>= nVal); 1353 aShadow.Location = (table::ShadowLocation) nVal; 1354 } 1355 1356 break; 1357 } 1358 1359 case MID_WIDTH: rVal >>= aShadow.ShadowWidth; break; 1360 case MID_TRANSPARENT: rVal >>= aShadow.IsTransparent; break; 1361 case MID_BG_COLOR: rVal >>= aShadow.Color; break; 1362 case 0: rVal >>= aShadow; break; 1363 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 1364 } 1365 1366 if ( bRet ) 1367 { 1368 // SvxShadowLocation eSet = SVX_SHADOW_NONE; 1369 switch( aShadow.Location ) 1370 { 1371 case table::ShadowLocation_TOP_LEFT : eLocation = SVX_SHADOW_TOPLEFT; break; 1372 case table::ShadowLocation_TOP_RIGHT : eLocation = SVX_SHADOW_TOPRIGHT; break; 1373 case table::ShadowLocation_BOTTOM_LEFT : eLocation = SVX_SHADOW_BOTTOMLEFT ; break; 1374 case table::ShadowLocation_BOTTOM_RIGHT: eLocation = SVX_SHADOW_BOTTOMRIGHT; break; 1375 default: ;//prevent warning 1376 } 1377 1378 nWidth = bConvert ? MM100_TO_TWIP(aShadow.ShadowWidth) : aShadow.ShadowWidth; 1379 Color aSet(aShadow.Color); 1380 aSet.SetTransparency(aShadow.IsTransparent ? 0xff : 0); 1381 aShadowColor = aSet; 1382 } 1383 1384 return bRet; 1385 } 1386 1387 // ----------------------------------------------------------------------- 1388 1389 int SvxShadowItem::operator==( const SfxPoolItem& rAttr ) const 1390 { 1391 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 1392 1393 return ( ( aShadowColor == ( (SvxShadowItem&)rAttr ).aShadowColor ) && 1394 ( nWidth == ( (SvxShadowItem&)rAttr ).GetWidth() ) && 1395 ( eLocation == ( (SvxShadowItem&)rAttr ).GetLocation() ) ); 1396 } 1397 1398 // ----------------------------------------------------------------------- 1399 1400 SfxPoolItem* SvxShadowItem::Clone( SfxItemPool* ) const 1401 { 1402 return new SvxShadowItem( *this ); 1403 } 1404 1405 // ----------------------------------------------------------------------- 1406 1407 sal_uInt16 SvxShadowItem::CalcShadowSpace( sal_uInt16 nShadow ) const 1408 { 1409 sal_uInt16 nSpace = 0; 1410 1411 switch ( nShadow ) 1412 { 1413 case SHADOW_TOP: 1414 if ( eLocation == SVX_SHADOW_TOPLEFT || 1415 eLocation == SVX_SHADOW_TOPRIGHT ) 1416 nSpace = nWidth; 1417 break; 1418 1419 case SHADOW_BOTTOM: 1420 if ( eLocation == SVX_SHADOW_BOTTOMLEFT || 1421 eLocation == SVX_SHADOW_BOTTOMRIGHT ) 1422 nSpace = nWidth; 1423 break; 1424 1425 case SHADOW_LEFT: 1426 if ( eLocation == SVX_SHADOW_TOPLEFT || 1427 eLocation == SVX_SHADOW_BOTTOMLEFT ) 1428 nSpace = nWidth; 1429 break; 1430 1431 case SHADOW_RIGHT: 1432 if ( eLocation == SVX_SHADOW_TOPRIGHT || 1433 eLocation == SVX_SHADOW_BOTTOMRIGHT ) 1434 nSpace = nWidth; 1435 break; 1436 1437 default: 1438 DBG_ERROR( "wrong shadow" ); 1439 } 1440 return nSpace; 1441 } 1442 1443 //------------------------------------------------------------------------ 1444 1445 SfxItemPresentation SvxShadowItem::GetPresentation 1446 ( 1447 SfxItemPresentation ePres, 1448 SfxMapUnit eCoreUnit, 1449 SfxMapUnit ePresUnit, 1450 XubString& rText, const IntlWrapper *pIntl 1451 ) const 1452 { 1453 #ifndef SVX_LIGHT 1454 switch ( ePres ) 1455 { 1456 case SFX_ITEM_PRESENTATION_NONE: 1457 rText.Erase(); 1458 return ePres; 1459 1460 case SFX_ITEM_PRESENTATION_NAMELESS: 1461 { 1462 rText = ::GetColorString( aShadowColor ); 1463 rText += cpDelim; 1464 sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE; 1465 1466 if ( aShadowColor.GetTransparency() ) 1467 nId = RID_SVXITEMS_TRANSPARENT_TRUE; 1468 rText += EE_RESSTR(nId); 1469 rText += cpDelim; 1470 rText += GetMetricText( (long)nWidth, eCoreUnit, ePresUnit, pIntl ); 1471 rText += cpDelim; 1472 rText += EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + eLocation); 1473 return ePres; 1474 } 1475 case SFX_ITEM_PRESENTATION_COMPLETE: 1476 { 1477 rText = EE_RESSTR(RID_SVXITEMS_SHADOW_COMPLETE); 1478 rText += ::GetColorString( aShadowColor ); 1479 rText += cpDelim; 1480 1481 sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE; 1482 if ( aShadowColor.GetTransparency() ) 1483 nId = RID_SVXITEMS_TRANSPARENT_TRUE; 1484 rText += EE_RESSTR(nId); 1485 rText += cpDelim; 1486 rText += GetMetricText( (long)nWidth, eCoreUnit, ePresUnit, pIntl ); 1487 rText += sal_Unicode(' '); 1488 rText += EE_RESSTR(GetMetricId(ePresUnit)); 1489 rText += cpDelim; 1490 rText += EE_RESSTR(RID_SVXITEMS_SHADOW_BEGIN + eLocation); 1491 return ePres; 1492 } 1493 default: ;//prevent warning 1494 } 1495 #endif 1496 return SFX_ITEM_PRESENTATION_NONE; 1497 } 1498 1499 // ----------------------------------------------------------------------- 1500 1501 SvStream& SvxShadowItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 1502 { 1503 rStrm << (sal_Int8) GetLocation() 1504 << (sal_uInt16) GetWidth() 1505 << (sal_Bool)(aShadowColor.GetTransparency() > 0) 1506 << GetColor() 1507 << GetColor() 1508 << (sal_Int8)(aShadowColor.GetTransparency() > 0 ? 0 : 1); //BRUSH_NULL : BRUSH_SOLID 1509 return rStrm; 1510 } 1511 1512 // ----------------------------------------------------------------------- 1513 1514 int SvxShadowItem::ScaleMetrics( long nMult, long nDiv ) 1515 { 1516 nWidth = (sal_uInt16)Scale( nWidth, nMult, nDiv ); 1517 return 1; 1518 } 1519 1520 // ----------------------------------------------------------------------- 1521 1522 int SvxShadowItem::HasMetrics() const 1523 { 1524 return 1; 1525 } 1526 1527 // ----------------------------------------------------------------------- 1528 1529 SfxPoolItem* SvxShadowItem::Create( SvStream& rStrm, sal_uInt16 ) const 1530 { 1531 sal_Int8 cLoc; 1532 sal_uInt16 _nWidth; 1533 sal_Bool bTrans; 1534 Color aColor; 1535 Color aFillColor; 1536 sal_Int8 nStyle; 1537 rStrm >> cLoc >> _nWidth 1538 >> bTrans >> aColor >> aFillColor >> nStyle; 1539 aColor.SetTransparency(bTrans ? 0xff : 0); 1540 return new SvxShadowItem( Which(), &aColor, _nWidth, (SvxShadowLocation)cLoc ); 1541 } 1542 1543 // ----------------------------------------------------------------------- 1544 1545 sal_uInt16 SvxShadowItem::GetValueCount() const 1546 { 1547 return SVX_SHADOW_END; // SVX_SHADOW_BOTTOMRIGHT + 1 1548 } 1549 1550 // ----------------------------------------------------------------------- 1551 1552 XubString SvxShadowItem::GetValueTextByPos( sal_uInt16 nPos ) const 1553 { 1554 DBG_ASSERT( nPos < SVX_SHADOW_END, "enum overflow!" ); 1555 return XubString( EditResId( RID_SVXITEMS_SHADOW_BEGIN + nPos ) ); 1556 } 1557 1558 // ----------------------------------------------------------------------- 1559 1560 sal_uInt16 SvxShadowItem::GetEnumValue() const 1561 { 1562 return (sal_uInt16)GetLocation(); 1563 } 1564 1565 // ----------------------------------------------------------------------- 1566 1567 void SvxShadowItem::SetEnumValue( sal_uInt16 nVal ) 1568 { 1569 SetLocation( (const SvxShadowLocation)nVal ); 1570 } 1571 1572 // class SvxBorderLine -------------------------------------------------- 1573 1574 SvxBorderLine::SvxBorderLine( const Color *pCol, sal_uInt16 nOut, sal_uInt16 nIn, sal_uInt16 nDist ) 1575 : nOutWidth( nOut ) 1576 , nInWidth ( nIn ) 1577 , nDistance( nDist ) 1578 { 1579 if ( pCol ) 1580 aColor = *pCol; 1581 } 1582 1583 // ----------------------------------------------------------------------- 1584 1585 SvxBorderLine::SvxBorderLine( const SvxBorderLine& r ) 1586 { 1587 *this = r; 1588 } 1589 1590 // ----------------------------------------------------------------------- 1591 1592 SvxBorderLine& SvxBorderLine::operator=( const SvxBorderLine& r ) 1593 { 1594 aColor = r.aColor; 1595 nOutWidth = r.nOutWidth; 1596 nInWidth = r.nInWidth; 1597 nDistance = r.nDistance; 1598 return *this; 1599 } 1600 1601 // ----------------------------------------------------------------------- 1602 1603 void SvxBorderLine::ScaleMetrics( long nMult, long nDiv ) 1604 { 1605 nOutWidth = (sal_uInt16)Scale( nOutWidth, nMult, nDiv ); 1606 nInWidth = (sal_uInt16)Scale( nInWidth, nMult, nDiv ); 1607 nDistance = (sal_uInt16)Scale( nDistance, nMult, nDiv ); 1608 } 1609 1610 // ----------------------------------------------------------------------- 1611 1612 sal_Bool SvxBorderLine::operator==( const SvxBorderLine& rCmp ) const 1613 { 1614 return ( ( aColor == rCmp.GetColor() ) && 1615 ( nInWidth == rCmp.GetInWidth() ) && 1616 ( nOutWidth == rCmp.GetOutWidth() ) && 1617 ( nDistance == rCmp.GetDistance() ) ); 1618 } 1619 1620 // ----------------------------------------------------------------------- 1621 1622 XubString SvxBorderLine::GetValueString( SfxMapUnit eSrcUnit, 1623 SfxMapUnit eDestUnit, 1624 const IntlWrapper* pIntl, 1625 sal_Bool bMetricStr) const 1626 { 1627 #ifndef SVX_LIGHT 1628 sal_uInt16 nResId = 0; 1629 1630 if ( 0 == nDistance ) 1631 { 1632 // einfach Linie 1633 if ( DEF_LINE_WIDTH_0 == nOutWidth ) 1634 nResId = RID_SINGLE_LINE0; 1635 else if ( DEF_LINE_WIDTH_1 == nOutWidth ) 1636 nResId = RID_SINGLE_LINE1; 1637 else if ( DEF_LINE_WIDTH_2 == nOutWidth ) 1638 nResId = RID_SINGLE_LINE2; 1639 else if ( DEF_LINE_WIDTH_3 == nOutWidth ) 1640 nResId = RID_SINGLE_LINE3; 1641 else if ( DEF_LINE_WIDTH_4 == nOutWidth ) 1642 nResId = RID_SINGLE_LINE4; 1643 } 1644 else if ( DEF_LINE_WIDTH_1 == nDistance ) 1645 { 1646 // doppelte Linie, kleiner Abstand 1647 if ( DEF_LINE_WIDTH_0 == nOutWidth && DEF_LINE_WIDTH_0 == nInWidth ) 1648 nResId = RID_DOUBLE_LINE0; 1649 else if ( DEF_LINE_WIDTH_1 == nOutWidth && 1650 DEF_LINE_WIDTH_1 == nInWidth ) 1651 nResId = RID_DOUBLE_LINE2; 1652 else if ( DEF_LINE_WIDTH_1 == nOutWidth && 1653 DEF_LINE_WIDTH_2 == nInWidth ) 1654 nResId = RID_DOUBLE_LINE8; 1655 } 1656 else if ( DEF_LINE_WIDTH_2 == nDistance ) 1657 { 1658 // doppelte Linie, gro\ser Abstand 1659 if ( DEF_LINE_WIDTH_0 == nOutWidth && DEF_LINE_WIDTH_0 == nInWidth ) 1660 nResId = RID_DOUBLE_LINE1; 1661 else if ( DEF_LINE_WIDTH_2 == nOutWidth && 1662 DEF_LINE_WIDTH_2 == nInWidth ) 1663 nResId = RID_DOUBLE_LINE3; 1664 else if ( DEF_LINE_WIDTH_1 == nOutWidth && 1665 DEF_LINE_WIDTH_0 == nInWidth ) 1666 nResId = RID_DOUBLE_LINE4; 1667 else if ( DEF_LINE_WIDTH_2 == nOutWidth && 1668 DEF_LINE_WIDTH_0 == nInWidth ) 1669 nResId = RID_DOUBLE_LINE5; 1670 else if ( DEF_LINE_WIDTH_3 == nOutWidth && 1671 DEF_LINE_WIDTH_0 == nInWidth ) 1672 nResId = RID_DOUBLE_LINE6; 1673 else if ( DEF_LINE_WIDTH_2 == nOutWidth && 1674 DEF_LINE_WIDTH_1 == nInWidth ) 1675 nResId = RID_DOUBLE_LINE7; 1676 else if ( DEF_LINE_WIDTH_3 == nOutWidth && 1677 DEF_LINE_WIDTH_2 == nInWidth ) 1678 nResId = RID_DOUBLE_LINE9; 1679 else if ( DEF_LINE_WIDTH_2 == nOutWidth && 1680 DEF_LINE_WIDTH_3 == nInWidth ) 1681 nResId = RID_DOUBLE_LINE10; 1682 } 1683 String aStr; 1684 aStr += sal_Unicode('('); 1685 aStr += ::GetColorString( aColor ); 1686 aStr += cpDelim; 1687 1688 if ( nResId ) 1689 aStr += EE_RESSTR(nResId); 1690 else 1691 { 1692 String sMetric = EE_RESSTR(GetMetricId( eDestUnit )); 1693 sMetric.Insert( sal_Unicode(' '), 0 ); 1694 aStr += GetMetricText( (long)nInWidth, eSrcUnit, eDestUnit, pIntl ); 1695 if ( bMetricStr ) 1696 aStr += sMetric; 1697 aStr += cpDelim; 1698 aStr += GetMetricText( (long)nOutWidth, eSrcUnit, eDestUnit, pIntl ); 1699 if ( bMetricStr ) 1700 aStr += sMetric; 1701 aStr += cpDelim; 1702 aStr += GetMetricText( (long)nDistance, eSrcUnit, eDestUnit, pIntl ); 1703 if ( bMetricStr ) 1704 aStr += sMetric; 1705 } 1706 aStr += sal_Unicode(')'); 1707 return aStr; 1708 #else 1709 return UniString(); 1710 #endif 1711 } 1712 1713 bool SvxBorderLine::HasPriority( const SvxBorderLine& rOtherLine ) const 1714 { 1715 const sal_uInt16 nThisSize = GetOutWidth() + GetDistance() + GetInWidth(); 1716 const sal_uInt16 nOtherSize = rOtherLine.GetOutWidth() + rOtherLine.GetDistance() + rOtherLine.GetInWidth(); 1717 1718 if (nThisSize > nOtherSize) 1719 { 1720 return true; 1721 } 1722 else if (nThisSize < nOtherSize) 1723 { 1724 return false; 1725 } 1726 else 1727 { 1728 if ( rOtherLine.GetInWidth() && !GetInWidth() ) 1729 { 1730 return true; 1731 } 1732 else if ( GetInWidth() && !rOtherLine.GetInWidth() ) 1733 { 1734 return false; 1735 } 1736 else 1737 { 1738 return false; 1739 } 1740 } 1741 } 1742 1743 // class SvxBoxItem ------------------------------------------------------ 1744 1745 SvxBoxItem::SvxBoxItem( const SvxBoxItem& rCpy ) : 1746 1747 SfxPoolItem ( rCpy ), 1748 nTopDist ( rCpy.nTopDist ), 1749 nBottomDist ( rCpy.nBottomDist ), 1750 nLeftDist ( rCpy.nLeftDist ), 1751 nRightDist ( rCpy.nRightDist ) 1752 1753 { 1754 pTop = rCpy.GetTop() ? new SvxBorderLine( *rCpy.GetTop() ) : 0; 1755 pBottom = rCpy.GetBottom() ? new SvxBorderLine( *rCpy.GetBottom() ) : 0; 1756 pLeft = rCpy.GetLeft() ? new SvxBorderLine( *rCpy.GetLeft() ) : 0; 1757 pRight = rCpy.GetRight() ? new SvxBorderLine( *rCpy.GetRight() ) : 0; 1758 } 1759 1760 // ----------------------------------------------------------------------- 1761 1762 SvxBoxItem::SvxBoxItem( const sal_uInt16 nId ) : 1763 SfxPoolItem( nId ), 1764 1765 pTop ( 0 ), 1766 pBottom ( 0 ), 1767 pLeft ( 0 ), 1768 pRight ( 0 ), 1769 nTopDist ( 0 ), 1770 nBottomDist ( 0 ), 1771 nLeftDist ( 0 ), 1772 nRightDist ( 0 ) 1773 1774 { 1775 } 1776 1777 // ----------------------------------------------------------------------- 1778 1779 SvxBoxItem::~SvxBoxItem() 1780 { 1781 delete pTop; 1782 delete pBottom; 1783 delete pLeft; 1784 delete pRight; 1785 } 1786 1787 // ----------------------------------------------------------------------- 1788 1789 SvxBoxItem& SvxBoxItem::operator=( const SvxBoxItem& rBox ) 1790 { 1791 nTopDist = rBox.nTopDist; 1792 nBottomDist = rBox.nBottomDist; 1793 nLeftDist = rBox.nLeftDist; 1794 nRightDist = rBox.nRightDist; 1795 SetLine( rBox.GetTop(), BOX_LINE_TOP ); 1796 SetLine( rBox.GetBottom(), BOX_LINE_BOTTOM ); 1797 SetLine( rBox.GetLeft(), BOX_LINE_LEFT ); 1798 SetLine( rBox.GetRight(), BOX_LINE_RIGHT ); 1799 return *this; 1800 } 1801 1802 // ----------------------------------------------------------------------- 1803 1804 inline sal_Bool CmpBrdLn( const SvxBorderLine* pBrd1, const SvxBorderLine* pBrd2 ) 1805 { 1806 sal_Bool bRet; 1807 if( 0 != pBrd1 ? 0 == pBrd2 : 0 != pBrd2 ) 1808 bRet = sal_False; 1809 else 1810 if( !pBrd1 ) 1811 bRet = sal_True; 1812 else 1813 bRet = (*pBrd1 == *pBrd2); 1814 return bRet; 1815 } 1816 1817 // ----------------------------------------------------------------------- 1818 1819 int SvxBoxItem::operator==( const SfxPoolItem& rAttr ) const 1820 { 1821 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 1822 1823 return ( 1824 ( nTopDist == ( (SvxBoxItem&)rAttr ).nTopDist ) && 1825 ( nBottomDist == ( (SvxBoxItem&)rAttr ).nBottomDist ) && 1826 ( nLeftDist == ( (SvxBoxItem&)rAttr ).nLeftDist ) && 1827 ( nRightDist == ( (SvxBoxItem&)rAttr ).nRightDist ) && 1828 CmpBrdLn( pTop, ( (SvxBoxItem&)rAttr ).GetTop() ) && 1829 CmpBrdLn( pBottom, ( (SvxBoxItem&)rAttr ).GetBottom() ) && 1830 CmpBrdLn( pLeft, ( (SvxBoxItem&)rAttr ).GetLeft() ) && 1831 CmpBrdLn( pRight, ( (SvxBoxItem&)rAttr ).GetRight() ) ); 1832 } 1833 1834 // ----------------------------------------------------------------------- 1835 table::BorderLine SvxBoxItem::SvxLineToLine(const SvxBorderLine* pLine, sal_Bool bConvert) 1836 { 1837 table::BorderLine aLine; 1838 if(pLine) 1839 { 1840 aLine.Color = pLine->GetColor().GetColor() ; 1841 aLine.InnerLineWidth = sal_uInt16( bConvert ? TWIP_TO_MM100_UNSIGNED(pLine->GetInWidth() ): pLine->GetInWidth() ); 1842 aLine.OuterLineWidth = sal_uInt16( bConvert ? TWIP_TO_MM100_UNSIGNED(pLine->GetOutWidth()): pLine->GetOutWidth() ); 1843 aLine.LineDistance = sal_uInt16( bConvert ? TWIP_TO_MM100_UNSIGNED(pLine->GetDistance()): pLine->GetDistance() ); 1844 } 1845 else 1846 aLine.Color = aLine.InnerLineWidth = aLine.OuterLineWidth = aLine.LineDistance = 0; 1847 return aLine; 1848 } 1849 // ----------------------------------------------------------------------- 1850 sal_Bool SvxBoxItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1851 { 1852 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1853 table::BorderLine aRetLine; 1854 sal_uInt16 nDist = 0; 1855 sal_Bool bDistMember = sal_False; 1856 nMemberId &= ~CONVERT_TWIPS; 1857 sal_Bool bSerialize = sal_False; 1858 switch(nMemberId) 1859 { 1860 case 0: 1861 { 1862 // 4 Borders and 5 distances 1863 uno::Sequence< uno::Any > aSeq( 9 ); 1864 aSeq[0] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetLeft(), bConvert) ); 1865 aSeq[1] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetRight(), bConvert) ); 1866 aSeq[2] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetBottom(), bConvert) ); 1867 aSeq[3] = uno::makeAny( SvxBoxItem::SvxLineToLine(GetTop(), bConvert) ); 1868 aSeq[4] <<= uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED( GetDistance()) : GetDistance())); 1869 aSeq[5] <<= uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED( nTopDist ) : nTopDist )); 1870 aSeq[6] <<= uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED( nBottomDist ) : nBottomDist )); 1871 aSeq[7] <<= uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED( nLeftDist ) : nLeftDist )); 1872 aSeq[8] <<= uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED( nRightDist ) : nRightDist )); 1873 rVal = uno::makeAny( aSeq ); 1874 return sal_True; 1875 } 1876 case MID_LEFT_BORDER: 1877 bSerialize = sal_True; // intentionally no break! 1878 case LEFT_BORDER: 1879 aRetLine = SvxBoxItem::SvxLineToLine(GetLeft(), bConvert); 1880 break; 1881 case MID_RIGHT_BORDER: 1882 bSerialize = sal_True; // intentionally no break! 1883 case RIGHT_BORDER: 1884 aRetLine = SvxBoxItem::SvxLineToLine(GetRight(), bConvert); 1885 break; 1886 case MID_BOTTOM_BORDER: 1887 bSerialize = sal_True; // intentionally no break! 1888 case BOTTOM_BORDER: 1889 aRetLine = SvxBoxItem::SvxLineToLine(GetBottom(), bConvert); 1890 break; 1891 case MID_TOP_BORDER: 1892 bSerialize = sal_True; // intentionally no break! 1893 case TOP_BORDER: 1894 aRetLine = SvxBoxItem::SvxLineToLine(GetTop(), bConvert); 1895 break; 1896 case BORDER_DISTANCE: 1897 nDist = GetDistance(); 1898 bDistMember = sal_True; 1899 break; 1900 case TOP_BORDER_DISTANCE: 1901 nDist = nTopDist; 1902 bDistMember = sal_True; 1903 break; 1904 case BOTTOM_BORDER_DISTANCE: 1905 nDist = nBottomDist; 1906 bDistMember = sal_True; 1907 break; 1908 case LEFT_BORDER_DISTANCE: 1909 nDist = nLeftDist; 1910 bDistMember = sal_True; 1911 break; 1912 case RIGHT_BORDER_DISTANCE: 1913 nDist = nRightDist; 1914 bDistMember = sal_True; 1915 break; 1916 } 1917 1918 if( bDistMember ) 1919 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(nDist) : nDist); 1920 else 1921 { 1922 /* 1923 if ( bSerialize ) 1924 { 1925 ::com::sun::star::uno::Sequence < ::com::sun::star::uno::Any > aSeq(4); 1926 aSeq[0] <<= aRetLine.Color; 1927 aSeq[1] <<= aRetLine.InnerLineWidth; 1928 aSeq[2] <<= aRetLine.OuterLineWidth; 1929 aSeq[3] <<= aRetLine.LineDistance; 1930 rVal <<= aSeq; 1931 } 1932 else 1933 */ 1934 rVal <<= aRetLine; 1935 } 1936 1937 return sal_True; 1938 } 1939 1940 // ----------------------------------------------------------------------- 1941 sal_Bool SvxBoxItem::LineToSvxLine(const ::com::sun::star::table::BorderLine& rLine, SvxBorderLine& rSvxLine, sal_Bool bConvert) 1942 { 1943 rSvxLine.SetColor( Color(rLine.Color)); 1944 rSvxLine.SetInWidth( sal_uInt16( bConvert ? MM100_TO_TWIP(rLine.InnerLineWidth) : rLine.InnerLineWidth )); 1945 rSvxLine.SetOutWidth( sal_uInt16( bConvert ? MM100_TO_TWIP(rLine.OuterLineWidth) : rLine.OuterLineWidth )); 1946 rSvxLine.SetDistance( sal_uInt16( bConvert ? MM100_TO_TWIP(rLine.LineDistance ) : rLine.LineDistance )); 1947 sal_Bool bRet = rLine.InnerLineWidth > 0 || rLine.OuterLineWidth > 0; 1948 return bRet; 1949 } 1950 1951 // ----------------------------------------------------------------------- 1952 1953 sal_Bool SvxBoxItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1954 { 1955 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 1956 sal_uInt16 nLine = BOX_LINE_TOP; 1957 sal_Bool bDistMember = sal_False; 1958 nMemberId &= ~CONVERT_TWIPS; 1959 switch(nMemberId) 1960 { 1961 case 0: 1962 { 1963 uno::Sequence< uno::Any > aSeq; 1964 if (( rVal >>= aSeq ) && ( aSeq.getLength() == 9 )) 1965 { 1966 // 4 Borders and 5 distances 1967 sal_Int32 nDist = 0; 1968 SvxBorderLine aLine; 1969 table::BorderLine aBorderLine; 1970 if ( aSeq[0] >>= aBorderLine ) 1971 { 1972 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 1973 SetLine(bSet ? &aLine : 0, BOX_LINE_LEFT ); 1974 } 1975 else 1976 return sal_False; 1977 1978 if ( aSeq[1] >>= aBorderLine ) 1979 { 1980 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 1981 SetLine(bSet ? &aLine : 0, BOX_LINE_RIGHT ); 1982 } 1983 else 1984 return sal_False; 1985 1986 if ( aSeq[2] >>= aBorderLine ) 1987 { 1988 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 1989 SetLine(bSet ? &aLine : 0, BOX_LINE_BOTTOM ); 1990 } 1991 else 1992 return sal_False; 1993 1994 if ( aSeq[3] >>= aBorderLine ) 1995 { 1996 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 1997 SetLine(bSet ? &aLine : 0, BOX_LINE_TOP ); 1998 } 1999 else 2000 return sal_False; 2001 2002 sal_uInt16 nLines[4] = { BOX_LINE_TOP, BOX_LINE_BOTTOM, BOX_LINE_LEFT, BOX_LINE_RIGHT }; 2003 for ( sal_Int32 n = 4; n < 9; n++ ) 2004 { 2005 if ( aSeq[n] >>= nDist ) 2006 { 2007 if( bConvert ) 2008 nDist = MM100_TO_TWIP(nDist); 2009 if ( n == 4 ) 2010 SetDistance( sal_uInt16( nDist )); 2011 else 2012 SetDistance( sal_uInt16( nDist ), nLines[n-5] ); 2013 } 2014 else 2015 return sal_False; 2016 } 2017 2018 return sal_True; 2019 } 2020 else 2021 return sal_False; 2022 } 2023 case LEFT_BORDER_DISTANCE: 2024 bDistMember = sal_True; 2025 case LEFT_BORDER: 2026 case MID_LEFT_BORDER: 2027 nLine = BOX_LINE_LEFT; 2028 break; 2029 case RIGHT_BORDER_DISTANCE: 2030 bDistMember = sal_True; 2031 case RIGHT_BORDER: 2032 case MID_RIGHT_BORDER: 2033 nLine = BOX_LINE_RIGHT; 2034 break; 2035 case BOTTOM_BORDER_DISTANCE: 2036 bDistMember = sal_True; 2037 case BOTTOM_BORDER: 2038 case MID_BOTTOM_BORDER: 2039 nLine = BOX_LINE_BOTTOM; 2040 break; 2041 case TOP_BORDER_DISTANCE: 2042 bDistMember = sal_True; 2043 case TOP_BORDER: 2044 case MID_TOP_BORDER: 2045 nLine = BOX_LINE_TOP; 2046 break; 2047 } 2048 2049 if( bDistMember || nMemberId == BORDER_DISTANCE ) 2050 { 2051 sal_Int32 nDist = 0; 2052 if(!(rVal >>= nDist)) 2053 return sal_False; 2054 2055 if(nDist >= 0) 2056 { 2057 if( bConvert ) 2058 nDist = MM100_TO_TWIP(nDist); 2059 if( nMemberId == BORDER_DISTANCE ) 2060 SetDistance( sal_uInt16( nDist )); 2061 else 2062 SetDistance( sal_uInt16( nDist ), nLine ); 2063 } 2064 } 2065 else 2066 { 2067 SvxBorderLine aLine; 2068 if( !rVal.hasValue() ) 2069 return sal_False; 2070 2071 table::BorderLine aBorderLine; 2072 if( rVal >>= aBorderLine ) 2073 { 2074 // usual struct 2075 } 2076 else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE ) 2077 { 2078 // serialization for basic macro recording 2079 uno::Reference < script::XTypeConverter > xConverter 2080 ( ::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.script.Converter")), 2081 uno::UNO_QUERY ); 2082 uno::Sequence < uno::Any > aSeq; 2083 uno::Any aNew; 2084 try { aNew = xConverter->convertTo( rVal, ::getCppuType((const uno::Sequence < uno::Any >*)0) ); } 2085 catch (uno::Exception&) {} 2086 2087 aNew >>= aSeq; 2088 if ( aSeq.getLength() == 4 ) 2089 { 2090 sal_Int32 nVal = 0; 2091 if ( aSeq[0] >>= nVal ) 2092 aBorderLine.Color = nVal; 2093 if ( aSeq[1] >>= nVal ) 2094 aBorderLine.InnerLineWidth = (sal_Int16) nVal; 2095 if ( aSeq[2] >>= nVal ) 2096 aBorderLine.OuterLineWidth = (sal_Int16) nVal; 2097 if ( aSeq[3] >>= nVal ) 2098 aBorderLine.LineDistance = (sal_Int16) nVal; 2099 } 2100 else 2101 return sal_False; 2102 } 2103 else 2104 return sal_False; 2105 2106 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 2107 SetLine(bSet ? &aLine : 0, nLine); 2108 } 2109 2110 return sal_True; 2111 } 2112 2113 // ----------------------------------------------------------------------- 2114 2115 SfxPoolItem* SvxBoxItem::Clone( SfxItemPool* ) const 2116 { 2117 return new SvxBoxItem( *this ); 2118 } 2119 2120 //------------------------------------------------------------------------ 2121 2122 SfxItemPresentation SvxBoxItem::GetPresentation 2123 ( 2124 SfxItemPresentation ePres, 2125 SfxMapUnit eCoreUnit, 2126 SfxMapUnit ePresUnit, 2127 XubString& rText, const IntlWrapper *pIntl 2128 ) const 2129 { 2130 #ifndef SVX_LIGHT 2131 switch ( ePres ) 2132 { 2133 case SFX_ITEM_PRESENTATION_NONE: 2134 rText.Erase(); 2135 return SFX_ITEM_PRESENTATION_NONE; 2136 2137 case SFX_ITEM_PRESENTATION_NAMELESS: 2138 { 2139 rText.Erase(); 2140 2141 if ( pTop ) 2142 { 2143 rText = pTop->GetValueString( eCoreUnit, ePresUnit, pIntl ); 2144 rText += cpDelim; 2145 } 2146 if( !(pTop && pBottom && pLeft && pRight && 2147 *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight) ) 2148 { 2149 if ( pBottom ) 2150 { 2151 rText += pBottom->GetValueString( eCoreUnit, ePresUnit, pIntl ); 2152 rText += cpDelim; 2153 } 2154 if ( pLeft ) 2155 { 2156 rText += pLeft->GetValueString( eCoreUnit, ePresUnit, pIntl ); 2157 rText += cpDelim; 2158 } 2159 if ( pRight ) 2160 { 2161 rText += pRight->GetValueString( eCoreUnit, ePresUnit, pIntl ); 2162 rText += cpDelim; 2163 } 2164 } 2165 rText += GetMetricText( (long)nTopDist, eCoreUnit, ePresUnit, pIntl ); 2166 if( nTopDist != nBottomDist || nTopDist != nLeftDist || 2167 nTopDist != nRightDist ) 2168 { 2169 (((((rText += cpDelim) 2170 += GetMetricText( (long)nBottomDist, eCoreUnit, 2171 ePresUnit, pIntl )) 2172 += cpDelim) 2173 += GetMetricText( (long)nLeftDist, eCoreUnit, ePresUnit, pIntl )) 2174 += cpDelim) 2175 += GetMetricText( (long)nRightDist, eCoreUnit, 2176 ePresUnit, pIntl ); 2177 } 2178 return SFX_ITEM_PRESENTATION_NAMELESS; 2179 } 2180 case SFX_ITEM_PRESENTATION_COMPLETE: 2181 { 2182 if( !(pTop || pBottom || pLeft || pRight) ) 2183 { 2184 rText = EE_RESSTR(RID_SVXITEMS_BORDER_NONE); 2185 rText += cpDelim; 2186 } 2187 else 2188 { 2189 rText = EE_RESSTR(RID_SVXITEMS_BORDER_COMPLETE); 2190 if( pTop && pBottom && pLeft && pRight && 2191 *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight ) 2192 { 2193 rText += pTop->GetValueString( eCoreUnit, ePresUnit, pIntl, sal_True ); 2194 rText += cpDelim; 2195 } 2196 else 2197 { 2198 if ( pTop ) 2199 { 2200 rText += EE_RESSTR(RID_SVXITEMS_BORDER_TOP); 2201 rText += pTop->GetValueString( eCoreUnit, ePresUnit, pIntl, sal_True ); 2202 rText += cpDelim; 2203 } 2204 if ( pBottom ) 2205 { 2206 rText += EE_RESSTR(RID_SVXITEMS_BORDER_BOTTOM); 2207 rText += pBottom->GetValueString( eCoreUnit, ePresUnit, pIntl, sal_True ); 2208 rText += cpDelim; 2209 } 2210 if ( pLeft ) 2211 { 2212 rText += EE_RESSTR(RID_SVXITEMS_BORDER_LEFT); 2213 rText += pLeft->GetValueString( eCoreUnit, ePresUnit, pIntl, sal_True ); 2214 rText += cpDelim; 2215 } 2216 if ( pRight ) 2217 { 2218 rText += EE_RESSTR(RID_SVXITEMS_BORDER_RIGHT); 2219 rText += pRight->GetValueString( eCoreUnit, ePresUnit, pIntl, sal_True ); 2220 rText += cpDelim; 2221 } 2222 } 2223 } 2224 2225 rText += EE_RESSTR(RID_SVXITEMS_BORDER_DISTANCE); 2226 if( nTopDist == nBottomDist && nTopDist == nLeftDist && 2227 nTopDist == nRightDist ) 2228 { 2229 rText += GetMetricText( (long)nTopDist, eCoreUnit, 2230 ePresUnit, pIntl ); 2231 rText += sal_Unicode(' '); 2232 rText += EE_RESSTR(GetMetricId(ePresUnit)); 2233 } 2234 else 2235 { 2236 ((((rText += EE_RESSTR(RID_SVXITEMS_BORDER_TOP)) 2237 += GetMetricText( (long)nTopDist, eCoreUnit, 2238 ePresUnit, pIntl )) 2239 += sal_Unicode(' ')) 2240 += EE_RESSTR(GetMetricId(ePresUnit))) 2241 += cpDelim; 2242 ((((rText += EE_RESSTR(RID_SVXITEMS_BORDER_BOTTOM)) 2243 += GetMetricText( (long)nBottomDist, eCoreUnit, 2244 ePresUnit, pIntl )) 2245 += sal_Unicode(' ')) 2246 += EE_RESSTR(GetMetricId(ePresUnit))) 2247 += cpDelim; 2248 ((((rText += EE_RESSTR(RID_SVXITEMS_BORDER_LEFT)) 2249 += GetMetricText( (long)nLeftDist, eCoreUnit, 2250 ePresUnit, pIntl )) 2251 += sal_Unicode(' ')) 2252 += EE_RESSTR(GetMetricId(ePresUnit))) 2253 += cpDelim; 2254 (((rText += EE_RESSTR(RID_SVXITEMS_BORDER_RIGHT)) 2255 += GetMetricText( (long)nRightDist, eCoreUnit, 2256 ePresUnit, pIntl )) 2257 += sal_Unicode(' ')) 2258 += EE_RESSTR(GetMetricId(ePresUnit)); 2259 } 2260 return SFX_ITEM_PRESENTATION_COMPLETE; 2261 } 2262 default: ;//prevent warning 2263 } 2264 #endif // !SVX_LIGHT 2265 return SFX_ITEM_PRESENTATION_NONE; 2266 } 2267 2268 // ----------------------------------------------------------------------- 2269 2270 SvStream& SvxBoxItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const 2271 { 2272 rStrm << (sal_uInt16) GetDistance(); 2273 const SvxBorderLine* pLine[ 4 ]; // top, left, right, bottom 2274 pLine[ 0 ] = GetTop(); 2275 pLine[ 1 ] = GetLeft(); 2276 pLine[ 2 ] = GetRight(); 2277 pLine[ 3 ] = GetBottom(); 2278 2279 for( int i = 0; i < 4; i++ ) 2280 { 2281 const SvxBorderLine* l = pLine[ i ]; 2282 if( l ) 2283 { 2284 rStrm << (sal_Int8) i 2285 << l->GetColor() 2286 << (sal_uInt16) l->GetOutWidth() 2287 << (sal_uInt16) l->GetInWidth() 2288 << (sal_uInt16) l->GetDistance(); 2289 } 2290 } 2291 sal_Int8 cLine = 4; 2292 if( nItemVersion >= BOX_4DISTS_VERSION && 2293 !(nTopDist == nLeftDist && 2294 nTopDist == nRightDist && 2295 nTopDist == nBottomDist) ) 2296 { 2297 cLine |= 0x10; 2298 } 2299 2300 rStrm << cLine; 2301 2302 if( nItemVersion >= BOX_4DISTS_VERSION && (cLine & 0x10) != 0 ) 2303 { 2304 rStrm << (sal_uInt16)nTopDist 2305 << (sal_uInt16)nLeftDist 2306 << (sal_uInt16)nRightDist 2307 << (sal_uInt16)nBottomDist; 2308 } 2309 2310 return rStrm; 2311 } 2312 2313 // ----------------------------------------------------------------------- 2314 2315 sal_uInt16 SvxBoxItem::GetVersion( sal_uInt16 nFFVer ) const 2316 { 2317 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 2318 SOFFICE_FILEFORMAT_40==nFFVer || 2319 SOFFICE_FILEFORMAT_50==nFFVer, 2320 "SvxBoxItem: Gibt es ein neues Fileformat?" ); 2321 return SOFFICE_FILEFORMAT_31==nFFVer || 2322 SOFFICE_FILEFORMAT_40==nFFVer ? 0 : BOX_4DISTS_VERSION; 2323 } 2324 2325 // ----------------------------------------------------------------------- 2326 2327 int SvxBoxItem::ScaleMetrics( long nMult, long nDiv ) 2328 { 2329 if ( pTop ) pTop->ScaleMetrics( nMult, nDiv ); 2330 if ( pBottom ) pBottom->ScaleMetrics( nMult, nDiv ); 2331 if ( pLeft ) pLeft->ScaleMetrics( nMult, nDiv ); 2332 if ( pRight ) pBottom->ScaleMetrics( nMult, nDiv ); 2333 nTopDist = (sal_uInt16)Scale( nTopDist, nMult, nDiv ); 2334 nBottomDist = (sal_uInt16)Scale( nBottomDist, nMult, nDiv ); 2335 nLeftDist = (sal_uInt16)Scale( nLeftDist, nMult, nDiv ); 2336 nRightDist = (sal_uInt16)Scale( nRightDist, nMult, nDiv ); 2337 return 1; 2338 } 2339 2340 // ----------------------------------------------------------------------- 2341 2342 int SvxBoxItem::HasMetrics() const 2343 { 2344 return 1; 2345 } 2346 2347 // ----------------------------------------------------------------------- 2348 2349 SfxPoolItem* SvxBoxItem::Create( SvStream& rStrm, sal_uInt16 nIVersion ) const 2350 { 2351 sal_uInt16 nDistance; 2352 rStrm >> nDistance; 2353 SvxBoxItem* pAttr = new SvxBoxItem( Which() ); 2354 2355 sal_uInt16 aLineMap[4] = { BOX_LINE_TOP, BOX_LINE_LEFT, 2356 BOX_LINE_RIGHT, BOX_LINE_BOTTOM }; 2357 2358 sal_Int8 cLine; 2359 while( sal_True ) 2360 { 2361 rStrm >> cLine; 2362 2363 if( cLine > 3 ) 2364 break; 2365 sal_uInt16 nOutline, nInline, _nDistance; 2366 Color aColor; 2367 rStrm >> aColor >> nOutline >> nInline >> _nDistance; 2368 SvxBorderLine aBorder( &aColor, nOutline, nInline, _nDistance ); 2369 2370 pAttr->SetLine( &aBorder, aLineMap[cLine] ); 2371 } 2372 2373 if( nIVersion >= BOX_4DISTS_VERSION && (cLine&0x10) != 0 ) 2374 { 2375 for( sal_uInt16 i=0; i < 4; i++ ) 2376 { 2377 sal_uInt16 nDist; 2378 rStrm >> nDist; 2379 pAttr->SetDistance( nDist, aLineMap[i] ); 2380 } 2381 } 2382 else 2383 { 2384 pAttr->SetDistance( nDistance ); 2385 } 2386 2387 return pAttr; 2388 } 2389 2390 // ----------------------------------------------------------------------- 2391 2392 const SvxBorderLine *SvxBoxItem::GetLine( sal_uInt16 nLine ) const 2393 { 2394 const SvxBorderLine *pRet = 0; 2395 2396 switch ( nLine ) 2397 { 2398 case BOX_LINE_TOP: 2399 pRet = pTop; 2400 break; 2401 case BOX_LINE_BOTTOM: 2402 pRet = pBottom; 2403 break; 2404 case BOX_LINE_LEFT: 2405 pRet = pLeft; 2406 break; 2407 case BOX_LINE_RIGHT: 2408 pRet = pRight; 2409 break; 2410 default: 2411 DBG_ERROR( "wrong line" ); 2412 break; 2413 } 2414 2415 return pRet; 2416 } 2417 2418 // ----------------------------------------------------------------------- 2419 2420 void SvxBoxItem::SetLine( const SvxBorderLine* pNew, sal_uInt16 nLine ) 2421 { 2422 SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0; 2423 2424 switch ( nLine ) 2425 { 2426 case BOX_LINE_TOP: 2427 delete pTop; 2428 pTop = pTmp; 2429 break; 2430 case BOX_LINE_BOTTOM: 2431 delete pBottom; 2432 pBottom = pTmp; 2433 break; 2434 case BOX_LINE_LEFT: 2435 delete pLeft; 2436 pLeft = pTmp; 2437 break; 2438 case BOX_LINE_RIGHT: 2439 delete pRight; 2440 pRight = pTmp; 2441 break; 2442 default: 2443 DBG_ERROR( "wrong line" ); 2444 } 2445 } 2446 2447 // ----------------------------------------------------------------------- 2448 2449 sal_uInt16 SvxBoxItem::GetDistance() const 2450 { 2451 // The smallest distance that is not 0 will be returned. 2452 sal_uInt16 nDist = nTopDist; 2453 if( nBottomDist && (!nDist || nBottomDist < nDist) ) 2454 nDist = nBottomDist; 2455 if( nLeftDist && (!nDist || nLeftDist < nDist) ) 2456 nDist = nLeftDist; 2457 if( nRightDist && (!nDist || nRightDist < nDist) ) 2458 nDist = nRightDist; 2459 2460 return nDist; 2461 } 2462 2463 // ----------------------------------------------------------------------- 2464 2465 sal_uInt16 SvxBoxItem::GetDistance( sal_uInt16 nLine ) const 2466 { 2467 sal_uInt16 nDist = 0; 2468 switch ( nLine ) 2469 { 2470 case BOX_LINE_TOP: 2471 nDist = nTopDist; 2472 break; 2473 case BOX_LINE_BOTTOM: 2474 nDist = nBottomDist; 2475 break; 2476 case BOX_LINE_LEFT: 2477 nDist = nLeftDist; 2478 break; 2479 case BOX_LINE_RIGHT: 2480 nDist = nRightDist; 2481 break; 2482 default: 2483 DBG_ERROR( "wrong line" ); 2484 } 2485 2486 return nDist; 2487 } 2488 2489 // ----------------------------------------------------------------------- 2490 2491 void SvxBoxItem::SetDistance( sal_uInt16 nNew, sal_uInt16 nLine ) 2492 { 2493 switch ( nLine ) 2494 { 2495 case BOX_LINE_TOP: 2496 nTopDist = nNew; 2497 break; 2498 case BOX_LINE_BOTTOM: 2499 nBottomDist = nNew; 2500 break; 2501 case BOX_LINE_LEFT: 2502 nLeftDist = nNew; 2503 break; 2504 case BOX_LINE_RIGHT: 2505 nRightDist = nNew; 2506 break; 2507 default: 2508 DBG_ERROR( "wrong line" ); 2509 } 2510 } 2511 2512 // ----------------------------------------------------------------------- 2513 2514 sal_uInt16 SvxBoxItem::CalcLineSpace( sal_uInt16 nLine, sal_Bool bIgnoreLine ) const 2515 { 2516 SvxBorderLine* pTmp = 0; 2517 sal_uInt16 nDist = 0; 2518 switch ( nLine ) 2519 { 2520 case BOX_LINE_TOP: 2521 pTmp = pTop; 2522 nDist = nTopDist; 2523 break; 2524 case BOX_LINE_BOTTOM: 2525 pTmp = pBottom; 2526 nDist = nBottomDist; 2527 break; 2528 case BOX_LINE_LEFT: 2529 pTmp = pLeft; 2530 nDist = nLeftDist; 2531 break; 2532 case BOX_LINE_RIGHT: 2533 pTmp = pRight; 2534 nDist = nRightDist; 2535 break; 2536 default: 2537 DBG_ERROR( "wrong line" ); 2538 } 2539 2540 if( pTmp ) 2541 { 2542 nDist = nDist + (sal_uInt16)(pTmp->GetOutWidth()) + (sal_uInt16)(pTmp->GetInWidth()) + (sal_uInt16)(pTmp->GetDistance()); 2543 } 2544 else if( !bIgnoreLine ) 2545 nDist = 0; 2546 return nDist; 2547 } 2548 2549 // class SvxBoxInfoItem -------------------------------------------------- 2550 2551 SvxBoxInfoItem::SvxBoxInfoItem( const sal_uInt16 nId ) : 2552 SfxPoolItem( nId ), 2553 pHori ( 0 ), 2554 pVert ( 0 ), 2555 mbEnableHor( false ), 2556 mbEnableVer( false ), 2557 nDefDist( 0 ) 2558 { 2559 bDist = bMinDist = sal_False; 2560 ResetFlags(); 2561 } 2562 2563 // ----------------------------------------------------------------------- 2564 2565 SvxBoxInfoItem::SvxBoxInfoItem( const SvxBoxInfoItem& rCpy ) : 2566 SfxPoolItem( rCpy ), 2567 mbEnableHor( rCpy.mbEnableHor ), 2568 mbEnableVer( rCpy.mbEnableVer ) 2569 { 2570 pHori = rCpy.GetHori() ? new SvxBorderLine( *rCpy.GetHori() ) : 0; 2571 pVert = rCpy.GetVert() ? new SvxBorderLine( *rCpy.GetVert() ) : 0; 2572 bDist = rCpy.IsDist(); 2573 bMinDist = rCpy.IsMinDist(); 2574 nValidFlags = rCpy.nValidFlags; 2575 nDefDist = rCpy.GetDefDist(); 2576 } 2577 2578 // ----------------------------------------------------------------------- 2579 2580 SvxBoxInfoItem::~SvxBoxInfoItem() 2581 { 2582 delete pHori; 2583 delete pVert; 2584 } 2585 2586 // ----------------------------------------------------------------------- 2587 2588 SvxBoxInfoItem &SvxBoxInfoItem::operator=( const SvxBoxInfoItem& rCpy ) 2589 { 2590 delete pHori; 2591 delete pVert; 2592 pHori = rCpy.GetHori() ? new SvxBorderLine( *rCpy.GetHori() ) : 0; 2593 pVert = rCpy.GetVert() ? new SvxBorderLine( *rCpy.GetVert() ) : 0; 2594 mbEnableHor = rCpy.mbEnableHor; 2595 mbEnableVer = rCpy.mbEnableVer; 2596 bDist = rCpy.IsDist(); 2597 bMinDist = rCpy.IsMinDist(); 2598 nValidFlags = rCpy.nValidFlags; 2599 nDefDist = rCpy.GetDefDist(); 2600 return *this; 2601 } 2602 2603 // ----------------------------------------------------------------------- 2604 2605 int SvxBoxInfoItem::operator==( const SfxPoolItem& rAttr ) const 2606 { 2607 SvxBoxInfoItem& rBoxInfo = (SvxBoxInfoItem&)rAttr; 2608 2609 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 2610 2611 return ( mbEnableHor == rBoxInfo.mbEnableHor 2612 && mbEnableVer == rBoxInfo.mbEnableVer 2613 && bDist == rBoxInfo.IsDist() 2614 && bMinDist == rBoxInfo.IsMinDist() 2615 && nValidFlags == rBoxInfo.nValidFlags 2616 && nDefDist == rBoxInfo.GetDefDist() 2617 && CmpBrdLn( pHori, rBoxInfo.GetHori() ) 2618 && CmpBrdLn( pVert, rBoxInfo.GetVert() ) 2619 ); 2620 } 2621 2622 // ----------------------------------------------------------------------- 2623 2624 void SvxBoxInfoItem::SetLine( const SvxBorderLine* pNew, sal_uInt16 nLine ) 2625 { 2626 SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0; 2627 2628 if ( BOXINFO_LINE_HORI == nLine ) 2629 { 2630 delete pHori; 2631 pHori = pTmp; 2632 } 2633 else if ( BOXINFO_LINE_VERT == nLine ) 2634 { 2635 delete pVert; 2636 pVert = pTmp; 2637 } 2638 else 2639 { 2640 DBG_ERROR( "wrong line" ); 2641 } 2642 } 2643 2644 2645 // ----------------------------------------------------------------------- 2646 2647 SfxPoolItem* SvxBoxInfoItem::Clone( SfxItemPool* ) const 2648 { 2649 return new SvxBoxInfoItem( *this ); 2650 } 2651 2652 //------------------------------------------------------------------------ 2653 2654 SfxItemPresentation SvxBoxInfoItem::GetPresentation 2655 ( 2656 SfxItemPresentation /*ePres*/, 2657 SfxMapUnit /*eCoreUnit*/, 2658 SfxMapUnit /*ePresUnit*/, 2659 XubString& rText, const IntlWrapper * 2660 ) const 2661 { 2662 #ifndef SVX_LIGHT 2663 /*!!! 2664 ResMgr* pMgr = DIALOG_MGR(); 2665 if ( pHori ) 2666 { 2667 rText += pHori->GetValueString(); 2668 rText += cpDelim; 2669 } 2670 if ( pVert ) 2671 { 2672 rText += pVert->GetValueString(); 2673 rText += cpDelim; 2674 } 2675 if ( bTable ) 2676 rText += String( ResId( RID_SVXITEMS_BOXINF_TABLE_TRUE, pMgr ) ); 2677 else 2678 rText += String( ResId( RID_SVXITEMS_BOXINF_TABLE_FALSE, pMgr ) ); 2679 rText += cpDelim; 2680 if ( bDist ) 2681 rText += String( ResId( RID_SVXITEMS_BOXINF_DIST_TRUE, pMgr ) ); 2682 else 2683 rText += String( ResId( RID_SVXITEMS_BOXINF_DIST_FALSE, pMgr ) ); 2684 rText += cpDelim; 2685 if ( bMinDist ) 2686 rText += String( ResId( RID_SVXITEMS_BOXINF_MDIST_TRUE, pMgr ) ); 2687 else 2688 rText += String( ResId( RID_SVXITEMS_BOXINF_MDIST_FALSE, pMgr ) ); 2689 rText += cpDelim; 2690 rText += nDefDist; 2691 return SFX_ITEM_PRESENTATION_NAMELESS; 2692 */ 2693 rText.Erase(); 2694 #endif // !SVX_LIGHT 2695 return SFX_ITEM_PRESENTATION_NONE; 2696 } 2697 2698 // ----------------------------------------------------------------------- 2699 2700 SvStream& SvxBoxInfoItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 2701 { 2702 sal_Int8 cFlags = 0; 2703 2704 if ( IsTable() ) 2705 cFlags |= 0x01; 2706 if ( IsDist() ) 2707 cFlags |= 0x02; 2708 if ( IsMinDist() ) 2709 cFlags |= 0x04; 2710 rStrm << (sal_Int8) cFlags 2711 << (sal_uInt16) GetDefDist(); 2712 const SvxBorderLine* pLine[ 2 ]; 2713 pLine[ 0 ] = GetHori(); 2714 pLine[ 1 ] = GetVert(); 2715 2716 for( int i = 0; i < 2; i++ ) 2717 { 2718 const SvxBorderLine* l = pLine[ i ]; 2719 if( l ) 2720 { 2721 rStrm << (char) i 2722 << l->GetColor() 2723 << (short) l->GetOutWidth() 2724 << (short) l->GetInWidth() 2725 << (short) l->GetDistance(); 2726 } 2727 } 2728 rStrm << (char) 2; 2729 return rStrm; 2730 } 2731 2732 // ----------------------------------------------------------------------- 2733 2734 int SvxBoxInfoItem::ScaleMetrics( long nMult, long nDiv ) 2735 { 2736 if ( pHori ) pHori->ScaleMetrics( nMult, nDiv ); 2737 if ( pVert ) pVert->ScaleMetrics( nMult, nDiv ); 2738 nDefDist = (sal_uInt16)Scale( nDefDist, nMult, nDiv ); 2739 return 1; 2740 } 2741 2742 // ----------------------------------------------------------------------- 2743 2744 int SvxBoxInfoItem::HasMetrics() const 2745 { 2746 return 1; 2747 } 2748 2749 // ----------------------------------------------------------------------- 2750 2751 SfxPoolItem* SvxBoxInfoItem::Create( SvStream& rStrm, sal_uInt16 ) const 2752 { 2753 sal_Int8 cFlags; 2754 sal_uInt16 _nDefDist; 2755 rStrm >> cFlags >> _nDefDist; 2756 2757 SvxBoxInfoItem* pAttr = new SvxBoxInfoItem( Which() ); 2758 2759 pAttr->SetTable ( ( cFlags & 0x01 ) != 0 ); 2760 pAttr->SetDist ( ( cFlags & 0x02 ) != 0 ); 2761 pAttr->SetMinDist( ( cFlags & 0x04 ) != 0 ); 2762 pAttr->SetDefDist( _nDefDist ); 2763 2764 while( sal_True ) 2765 { 2766 sal_Int8 cLine; 2767 rStrm >> cLine; 2768 2769 if( cLine > 1 ) 2770 break; 2771 short nOutline, nInline, nDistance; 2772 Color aColor; 2773 rStrm >> aColor >> nOutline >> nInline >> nDistance; 2774 SvxBorderLine aBorder( &aColor, nOutline, nInline, nDistance ); 2775 2776 switch( cLine ) 2777 { 2778 case 0: pAttr->SetLine( &aBorder, BOXINFO_LINE_HORI ); break; 2779 case 1: pAttr->SetLine( &aBorder, BOXINFO_LINE_VERT ); break; 2780 } 2781 } 2782 return pAttr; 2783 } 2784 2785 // ----------------------------------------------------------------------- 2786 2787 void SvxBoxInfoItem::ResetFlags() 2788 { 2789 nValidFlags = 0x7F; // alles g"ultig au/ser Disable 2790 } 2791 2792 sal_Bool SvxBoxInfoItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 2793 { 2794 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 2795 table::BorderLine aRetLine; 2796 sal_Int16 nVal=0; 2797 sal_Bool bIntMember = sal_False; 2798 nMemberId &= ~CONVERT_TWIPS; 2799 sal_Bool bSerialize = sal_False; 2800 switch(nMemberId) 2801 { 2802 case 0: 2803 { 2804 // 2 BorderLines, flags, valid flags and distance 2805 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > aSeq( 5 ); 2806 aSeq[0] = ::com::sun::star::uno::makeAny( SvxBoxItem::SvxLineToLine( pHori, bConvert) ); 2807 aSeq[1] = ::com::sun::star::uno::makeAny( SvxBoxItem::SvxLineToLine( pVert, bConvert) ); 2808 if ( IsTable() ) 2809 nVal |= 0x01; 2810 if ( IsDist() ) 2811 nVal |= 0x02; 2812 if ( IsMinDist() ) 2813 nVal |= 0x04; 2814 aSeq[2] = ::com::sun::star::uno::makeAny( nVal ); 2815 nVal = nValidFlags; 2816 aSeq[3] = ::com::sun::star::uno::makeAny( nVal ); 2817 aSeq[4] = ::com::sun::star::uno::makeAny( (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(GetDefDist()) : GetDefDist()) ); 2818 rVal = ::com::sun::star::uno::makeAny( aSeq ); 2819 return sal_True; 2820 } 2821 2822 case MID_HORIZONTAL: 2823 bSerialize = sal_True; 2824 aRetLine = SvxBoxItem::SvxLineToLine( pHori, bConvert); 2825 break; 2826 case MID_VERTICAL: 2827 bSerialize = sal_True; 2828 aRetLine = SvxBoxItem::SvxLineToLine( pVert, bConvert); 2829 break; 2830 case MID_FLAGS: 2831 bIntMember = sal_True; 2832 if ( IsTable() ) 2833 nVal |= 0x01; 2834 if ( IsDist() ) 2835 nVal |= 0x02; 2836 if ( IsMinDist() ) 2837 nVal |= 0x04; 2838 rVal <<= nVal; 2839 break; 2840 case MID_VALIDFLAGS: 2841 bIntMember = sal_True; 2842 nVal = nValidFlags; 2843 rVal <<= nVal; 2844 break; 2845 case MID_DISTANCE: 2846 bIntMember = sal_True; 2847 rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100_UNSIGNED(GetDefDist()) : GetDefDist()); 2848 break; 2849 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 2850 } 2851 2852 if( !bIntMember ) 2853 { 2854 /* 2855 if ( bSerialize ) 2856 { 2857 ::com::sun::star::uno::Sequence < ::com::sun::star::uno::Any > aSeq(4); 2858 aSeq[0] <<= aRetLine.Color; 2859 aSeq[1] <<= aRetLine.InnerLineWidth; 2860 aSeq[2] <<= aRetLine.OuterLineWidth; 2861 aSeq[3] <<= aRetLine.LineDistance; 2862 rVal <<= aSeq; 2863 } 2864 else 2865 */ 2866 rVal <<= aRetLine; 2867 } 2868 2869 return sal_True; 2870 } 2871 2872 // ----------------------------------------------------------------------- 2873 2874 sal_Bool SvxBoxInfoItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 2875 { 2876 sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 2877 // sal_uInt16 nLine = BOX_LINE_TOP; 2878 // sal_Bool bDistMember = sal_False; 2879 nMemberId &= ~CONVERT_TWIPS; 2880 sal_Bool bRet; 2881 switch(nMemberId) 2882 { 2883 case 0: 2884 { 2885 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > aSeq; 2886 if (( rVal >>= aSeq ) && ( aSeq.getLength() == 5 )) 2887 { 2888 // 2 BorderLines, flags, valid flags and distance 2889 table::BorderLine aBorderLine; 2890 SvxBorderLine aLine; 2891 sal_Int16 nFlags( 0 ); 2892 sal_Int32 nVal( 0 ); 2893 if ( aSeq[0] >>= aBorderLine ) 2894 { 2895 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 2896 if ( bSet ) 2897 SetLine( &aLine, BOXINFO_LINE_HORI ); 2898 } 2899 else 2900 return sal_False; 2901 if ( aSeq[1] >>= aBorderLine ) 2902 { 2903 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 2904 if ( bSet ) 2905 SetLine( &aLine, BOXINFO_LINE_VERT ); 2906 } 2907 else 2908 return sal_False; 2909 if ( aSeq[2] >>= nFlags ) 2910 { 2911 SetTable ( ( nFlags & 0x01 ) != 0 ); 2912 SetDist ( ( nFlags & 0x02 ) != 0 ); 2913 SetMinDist( ( nFlags & 0x04 ) != 0 ); 2914 } 2915 else 2916 return sal_False; 2917 if ( aSeq[3] >>= nFlags ) 2918 nValidFlags = (sal_uInt8)nFlags; 2919 else 2920 return sal_False; 2921 if (( aSeq[4] >>= nVal ) && ( nVal >= 0 )) 2922 { 2923 if( bConvert ) 2924 nVal = MM100_TO_TWIP(nVal); 2925 SetDefDist( (sal_uInt16)nVal ); 2926 } 2927 } 2928 return sal_True; 2929 } 2930 2931 case MID_HORIZONTAL: 2932 case MID_VERTICAL: 2933 { 2934 if( !rVal.hasValue() ) 2935 return sal_False; 2936 2937 table::BorderLine aBorderLine; 2938 if( rVal >>= aBorderLine ) 2939 { 2940 // usual struct 2941 } 2942 else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE ) 2943 { 2944 // serialization for basic macro recording 2945 uno::Reference < script::XTypeConverter > xConverter 2946 ( ::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.script.Converter")), 2947 uno::UNO_QUERY ); 2948 uno::Any aNew; 2949 uno::Sequence < uno::Any > aSeq; 2950 try { aNew = xConverter->convertTo( rVal, ::getCppuType((const uno::Sequence < uno::Any >*)0) ); } 2951 catch (uno::Exception&) {} 2952 2953 if( (aNew >>= aSeq) && aSeq.getLength() == 4 ) 2954 { 2955 sal_Int32 nVal = 0; 2956 if ( aSeq[0] >>= nVal ) 2957 aBorderLine.Color = nVal; 2958 if ( aSeq[1] >>= nVal ) 2959 aBorderLine.InnerLineWidth = (sal_Int16) nVal; 2960 if ( aSeq[2] >>= nVal ) 2961 aBorderLine.OuterLineWidth = (sal_Int16) nVal; 2962 if ( aSeq[3] >>= nVal ) 2963 aBorderLine.LineDistance = (sal_Int16) nVal; 2964 } 2965 else 2966 return sal_False; 2967 } 2968 else if (rVal.getValueType() == ::getCppuType((const ::com::sun::star::uno::Sequence < sal_Int16 >*)0) ) 2969 { 2970 // serialization for basic macro recording 2971 ::com::sun::star::uno::Sequence < sal_Int16 > aSeq; 2972 rVal >>= aSeq; 2973 if ( aSeq.getLength() == 4 ) 2974 { 2975 aBorderLine.Color = aSeq[0]; 2976 aBorderLine.InnerLineWidth = aSeq[1]; 2977 aBorderLine.OuterLineWidth = aSeq[2]; 2978 aBorderLine.LineDistance = aSeq[3]; 2979 } 2980 else 2981 return sal_False; 2982 } 2983 else 2984 return sal_False; 2985 2986 SvxBorderLine aLine; 2987 sal_Bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert); 2988 if ( bSet ) 2989 SetLine( &aLine, nMemberId == MID_HORIZONTAL ? BOXINFO_LINE_HORI : BOXINFO_LINE_VERT ); 2990 break; 2991 } 2992 case MID_FLAGS: 2993 { 2994 sal_Int16 nFlags = sal_Int16(); 2995 bRet = (rVal >>= nFlags); 2996 if ( bRet ) 2997 { 2998 SetTable ( ( nFlags & 0x01 ) != 0 ); 2999 SetDist ( ( nFlags & 0x02 ) != 0 ); 3000 SetMinDist( ( nFlags & 0x04 ) != 0 ); 3001 } 3002 3003 break; 3004 } 3005 case MID_VALIDFLAGS: 3006 { 3007 sal_Int16 nFlags = sal_Int16(); 3008 bRet = (rVal >>= nFlags); 3009 if ( bRet ) 3010 nValidFlags = (sal_uInt8)nFlags; 3011 break; 3012 } 3013 case MID_DISTANCE: 3014 { 3015 sal_Int32 nVal = 0; 3016 bRet = (rVal >>= nVal); 3017 if ( bRet && nVal>=0 ) 3018 { 3019 if( bConvert ) 3020 nVal = MM100_TO_TWIP(nVal); 3021 SetDefDist( (sal_uInt16)nVal ); 3022 } 3023 break; 3024 } 3025 default: DBG_ERROR("Wrong MemberId!"); return sal_False; 3026 } 3027 3028 return sal_True; 3029 } 3030 3031 // class SvxFmtBreakItem ------------------------------------------------- 3032 3033 int SvxFmtBreakItem::operator==( const SfxPoolItem& rAttr ) const 3034 { 3035 DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "unequal types" ); 3036 3037 return GetValue() == ( (SvxFmtBreakItem&)rAttr ).GetValue(); 3038 } 3039 3040 //------------------------------------------------------------------------ 3041 3042 SfxItemPresentation SvxFmtBreakItem::GetPresentation 3043 ( 3044 SfxItemPresentation ePres, 3045 SfxMapUnit /*eCoreUnit*/, 3046 SfxMapUnit /*ePresUnit*/, 3047 XubString& rText, const IntlWrapper * 3048 ) const 3049 { 3050 #ifndef SVX_LIGHT 3051 switch ( ePres ) 3052 { 3053 case SFX_ITEM_PRESENTATION_NONE: 3054 rText.Erase(); 3055 return SFX_ITEM_PRESENTATION_NONE; 3056 3057 case SFX_ITEM_PRESENTATION_NAMELESS: 3058 case SFX_ITEM_PRESENTATION_COMPLETE: 3059 rText = GetValueTextByPos( GetValue() ); 3060 return ePres; 3061 default: ;//prevent warning 3062 } 3063 #endif // !SVX_LIGHT 3064 return SFX_ITEM_PRESENTATION_NONE; 3065 } 3066 3067 // ----------------------------------------------------------------------- 3068 3069 XubString SvxFmtBreakItem::GetValueTextByPos( sal_uInt16 nPos ) const 3070 { 3071 DBG_ASSERT( nPos < SVX_BREAK_END, "enum overflow!" ); 3072 XubString aStr( EditResId( RID_SVXITEMS_BREAK_BEGIN + nPos ) ); 3073 return aStr; 3074 } 3075 3076 // ----------------------------------------------------------------------- 3077 sal_Bool SvxFmtBreakItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const 3078 { 3079 style::BreakType eBreak = style::BreakType_NONE; 3080 switch ( (SvxBreak)GetValue() ) 3081 { 3082 case SVX_BREAK_COLUMN_BEFORE: eBreak = style::BreakType_COLUMN_BEFORE; break; 3083 case SVX_BREAK_COLUMN_AFTER: eBreak = style::BreakType_COLUMN_AFTER ; break; 3084 case SVX_BREAK_COLUMN_BOTH: eBreak = style::BreakType_COLUMN_BOTH ; break; 3085 case SVX_BREAK_PAGE_BEFORE: eBreak = style::BreakType_PAGE_BEFORE ; break; 3086 case SVX_BREAK_PAGE_AFTER: eBreak = style::BreakType_PAGE_AFTER ; break; 3087 case SVX_BREAK_PAGE_BOTH: eBreak = style::BreakType_PAGE_BOTH ; break; 3088 default: ;//prevent warning 3089 } 3090 rVal <<= eBreak; 3091 return sal_True; 3092 } 3093 // ----------------------------------------------------------------------- 3094 sal_Bool SvxFmtBreakItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) 3095 { 3096 style::BreakType nBreak; 3097 3098 if(!(rVal >>= nBreak)) 3099 { 3100 sal_Int32 nValue = 0; 3101 if(!(rVal >>= nValue)) 3102 return sal_False; 3103 3104 nBreak = (style::BreakType) nValue; 3105 } 3106 3107 SvxBreak eBreak = SVX_BREAK_NONE; 3108 switch( nBreak ) 3109 { 3110 case style::BreakType_COLUMN_BEFORE: eBreak = SVX_BREAK_COLUMN_BEFORE; break; 3111 case style::BreakType_COLUMN_AFTER: eBreak = SVX_BREAK_COLUMN_AFTER; break; 3112 case style::BreakType_COLUMN_BOTH: eBreak = SVX_BREAK_COLUMN_BOTH; break; 3113 case style::BreakType_PAGE_BEFORE: eBreak = SVX_BREAK_PAGE_BEFORE; break; 3114 case style::BreakType_PAGE_AFTER: eBreak = SVX_BREAK_PAGE_AFTER; break; 3115 case style::BreakType_PAGE_BOTH: eBreak = SVX_BREAK_PAGE_BOTH; break; 3116 default: ;//prevent warning 3117 } 3118 SetValue((sal_uInt16) eBreak); 3119 3120 return sal_True; 3121 } 3122 3123 // ----------------------------------------------------------------------- 3124 3125 SfxPoolItem* SvxFmtBreakItem::Clone( SfxItemPool* ) const 3126 { 3127 return new SvxFmtBreakItem( *this ); 3128 } 3129 3130 // ----------------------------------------------------------------------- 3131 3132 SvStream& SvxFmtBreakItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const 3133 { 3134 rStrm << (sal_Int8)GetValue(); 3135 if( FMTBREAK_NOAUTO > nItemVersion ) 3136 rStrm << (sal_Int8)0x01; 3137 return rStrm; 3138 } 3139 3140 // ----------------------------------------------------------------------- 3141 3142 sal_uInt16 SvxFmtBreakItem::GetVersion( sal_uInt16 nFFVer ) const 3143 { 3144 DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || 3145 SOFFICE_FILEFORMAT_40==nFFVer || 3146 SOFFICE_FILEFORMAT_50==nFFVer, 3147 "SvxFmtBreakItem: Gibt es ein neues Fileformat?" ); 3148 return SOFFICE_FILEFORMAT_31==nFFVer || 3149 SOFFICE_FILEFORMAT_40==nFFVer ? 0 : FMTBREAK_NOAUTO; 3150 } 3151 3152 // ----------------------------------------------------------------------- 3153 3154 SfxPoolItem* SvxFmtBreakItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const 3155 { 3156 sal_Int8 eBreak, bDummy; 3157 rStrm >> eBreak; 3158 if( FMTBREAK_NOAUTO > nVersion ) 3159 rStrm >> bDummy; 3160 return new SvxFmtBreakItem( (const SvxBreak)eBreak, Which() ); 3161 } 3162 3163 // ----------------------------------------------------------------------- 3164 3165 sal_uInt16 SvxFmtBreakItem::GetValueCount() const 3166 { 3167 return SVX_BREAK_END; // SVX_BREAK_PAGE_BOTH + 1 3168 } 3169 3170 // class SvxFmtKeepItem ------------------------------------------------- 3171 3172 SfxPoolItem* SvxFmtKeepItem::Clone( SfxItemPool* ) const 3173 { 3174 return new SvxFmtKeepItem( *this ); 3175 } 3176 3177 // ----------------------------------------------------------------------- 3178 3179 SvStream& SvxFmtKeepItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 3180 { 3181 rStrm << (sal_Int8)GetValue(); 3182 return rStrm; 3183 } 3184 3185 // ----------------------------------------------------------------------- 3186 3187 SfxPoolItem* SvxFmtKeepItem::Create( SvStream& rStrm, sal_uInt16 ) const 3188 { 3189 sal_Int8 bIsKeep; 3190 rStrm >> bIsKeep; 3191 return new SvxFmtKeepItem( sal_Bool( bIsKeep != 0 ), Which() ); 3192 } 3193 3194 //------------------------------------------------------------------------ 3195 3196 SfxItemPresentation SvxFmtKeepItem::GetPresentation 3197 ( 3198 SfxItemPresentation ePres, 3199 SfxMapUnit /*eCoreUnit*/, 3200 SfxMapUnit /*ePresUnit*/, 3201 XubString& rText, const IntlWrapper * 3202 ) const 3203 { 3204 #ifndef SVX_LIGHT 3205 switch ( ePres ) 3206 { 3207 case SFX_ITEM_PRESENTATION_NONE: 3208 rText.Erase(); 3209 return ePres; 3210 3211 case SFX_ITEM_PRESENTATION_NAMELESS: 3212 case SFX_ITEM_PRESENTATION_COMPLETE: 3213 { 3214 sal_uInt16 nId = RID_SVXITEMS_FMTKEEP_FALSE; 3215 3216 if ( GetValue() ) 3217 nId = RID_SVXITEMS_FMTKEEP_TRUE; 3218 rText = EE_RESSTR(nId); 3219 return ePres; 3220 } 3221 default: ;//prevent warning 3222 } 3223 #endif 3224 return SFX_ITEM_PRESENTATION_NONE; 3225 } 3226 3227 // class SvxLineItem ------------------------------------------------------ 3228 3229 SvxLineItem::SvxLineItem( const sal_uInt16 nId ) : 3230 3231 SfxPoolItem ( nId ), 3232 3233 pLine( NULL ) 3234 { 3235 } 3236 3237 // ----------------------------------------------------------------------- 3238 3239 SvxLineItem::SvxLineItem( const SvxLineItem& rCpy ) : 3240 3241 SfxPoolItem ( rCpy ) 3242 { 3243 pLine = rCpy.GetLine() ? new SvxBorderLine( *rCpy.GetLine() ) : 0; 3244 } 3245 3246 3247 // ----------------------------------------------------------------------- 3248 3249 SvxLineItem::~SvxLineItem() 3250 { 3251 delete pLine; 3252 } 3253 3254 // ----------------------------------------------------------------------- 3255 3256 SvxLineItem& SvxLineItem::operator=( const SvxLineItem& rLine ) 3257 { 3258 SetLine( rLine.GetLine() ); 3259 3260 return *this; 3261 } 3262 3263 // ----------------------------------------------------------------------- 3264 3265 int SvxLineItem::operator==( const SfxPoolItem& rAttr ) const 3266 { 3267 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 3268 3269 return CmpBrdLn( pLine, ((SvxLineItem&)rAttr).GetLine() ); 3270 } 3271 3272 // ----------------------------------------------------------------------- 3273 3274 SfxPoolItem* SvxLineItem::Clone( SfxItemPool* ) const 3275 { 3276 return new SvxLineItem( *this ); 3277 } 3278 3279 sal_Bool SvxLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemId ) const 3280 { 3281 sal_Bool bConvert = 0!=(nMemId&CONVERT_TWIPS); 3282 nMemId &= ~CONVERT_TWIPS; 3283 if ( nMemId == 0 ) 3284 { 3285 rVal <<= uno::makeAny( SvxBoxItem::SvxLineToLine(pLine, bConvert) ); 3286 return sal_True; 3287 } 3288 else if ( pLine ) 3289 { 3290 switch ( nMemId ) 3291 { 3292 case MID_FG_COLOR: rVal <<= sal_Int32(pLine->GetColor().GetColor()); break; 3293 case MID_OUTER_WIDTH: rVal <<= sal_Int32(pLine->GetOutWidth()); break; 3294 case MID_INNER_WIDTH: rVal <<= sal_Int32(pLine->GetInWidth( )); break; 3295 case MID_DISTANCE: rVal <<= sal_Int32(pLine->GetDistance()); break; 3296 default: 3297 DBG_ERROR( "Wrong MemberId" ); 3298 return sal_False; 3299 } 3300 } 3301 3302 return sal_True; 3303 } 3304 3305 // ----------------------------------------------------------------------- 3306 3307 sal_Bool SvxLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemId ) 3308 { 3309 sal_Bool bConvert = 0!=(nMemId&CONVERT_TWIPS); 3310 nMemId &= ~CONVERT_TWIPS; 3311 sal_Int32 nVal = 0; 3312 if ( nMemId == 0 ) 3313 { 3314 table::BorderLine aLine; 3315 if ( rVal >>= aLine ) 3316 { 3317 if ( !pLine ) 3318 pLine = new SvxBorderLine; 3319 if( !SvxBoxItem::LineToSvxLine(aLine, *pLine, bConvert) ) 3320 DELETEZ( pLine ); 3321 return sal_True; 3322 } 3323 return sal_False; 3324 } 3325 else if ( rVal >>= nVal ) 3326 { 3327 if ( !pLine ) 3328 pLine = new SvxBorderLine; 3329 3330 switch ( nMemId ) 3331 { 3332 case MID_FG_COLOR: pLine->SetColor( Color(nVal) ); break; 3333 case MID_OUTER_WIDTH: pLine->SetOutWidth((sal_uInt16)nVal); break; 3334 case MID_INNER_WIDTH: pLine->SetInWidth((sal_uInt16)nVal); break; 3335 case MID_DISTANCE: pLine->SetDistance((sal_uInt16)nVal); break; 3336 default: 3337 DBG_ERROR( "Wrong MemberId" ); 3338 return sal_False; 3339 } 3340 3341 return sal_True; 3342 } 3343 3344 return sal_False; 3345 } 3346 3347 //------------------------------------------------------------------------ 3348 3349 SfxItemPresentation SvxLineItem::GetPresentation 3350 ( 3351 SfxItemPresentation ePres, 3352 SfxMapUnit eCoreUnit, 3353 SfxMapUnit ePresUnit, 3354 XubString& rText, const IntlWrapper *pIntl 3355 ) const 3356 { 3357 #ifndef SVX_LIGHT 3358 rText.Erase(); 3359 3360 switch ( ePres ) 3361 { 3362 case SFX_ITEM_PRESENTATION_NONE: 3363 return SFX_ITEM_PRESENTATION_NONE; 3364 case SFX_ITEM_PRESENTATION_NAMELESS: 3365 case SFX_ITEM_PRESENTATION_COMPLETE: 3366 { 3367 if ( pLine ) 3368 rText = pLine->GetValueString( eCoreUnit, ePresUnit, pIntl, 3369 (SFX_ITEM_PRESENTATION_COMPLETE == ePres) ); 3370 return ePres; 3371 } 3372 default: ;//prevent warning 3373 } 3374 #endif 3375 return SFX_ITEM_PRESENTATION_NONE; 3376 } 3377 3378 // ----------------------------------------------------------------------- 3379 3380 SvStream& SvxLineItem::Store( SvStream& rStrm , sal_uInt16 /*nItemVersion*/ ) const 3381 { 3382 if( pLine ) 3383 { 3384 rStrm << pLine->GetColor() 3385 << (short)pLine->GetOutWidth() 3386 << (short)pLine->GetInWidth() 3387 << (short)pLine->GetDistance(); 3388 } 3389 else 3390 rStrm << Color() << (short)0 << (short)0 << (short)0; 3391 return rStrm; 3392 } 3393 3394 // ----------------------------------------------------------------------- 3395 3396 int SvxLineItem::ScaleMetrics( long nMult, long nDiv ) 3397 { 3398 if ( pLine ) pLine->ScaleMetrics( nMult, nDiv ); 3399 return 1; 3400 } 3401 3402 // ----------------------------------------------------------------------- 3403 3404 int SvxLineItem::HasMetrics() const 3405 { 3406 return 1; 3407 } 3408 3409 // ----------------------------------------------------------------------- 3410 3411 SfxPoolItem* SvxLineItem::Create( SvStream& rStrm, sal_uInt16 ) const 3412 { 3413 SvxLineItem* _pLine = new SvxLineItem( Which() ); 3414 short nOutline, nInline, nDistance; 3415 Color aColor; 3416 3417 rStrm >> aColor >> nOutline >> nInline >> nDistance; 3418 if( nOutline ) 3419 { 3420 SvxBorderLine aLine( &aColor, nOutline, nInline, nDistance ); 3421 _pLine->SetLine( &aLine ); 3422 } 3423 return _pLine; 3424 } 3425 3426 // ----------------------------------------------------------------------- 3427 3428 void SvxLineItem::SetLine( const SvxBorderLine* pNew ) 3429 { 3430 delete pLine; 3431 pLine = pNew ? new SvxBorderLine( *pNew ) : 0; 3432 } 3433 3434 #ifdef _MSC_VER 3435 #pragma optimize ( "", off ) 3436 #endif 3437 3438 // class SvxBrushItem ---------------------------------------------------- 3439 3440 #define LOAD_GRAPHIC ((sal_uInt16)0x0001) 3441 #define LOAD_LINK ((sal_uInt16)0x0002) 3442 #define LOAD_FILTER ((sal_uInt16)0x0004) 3443 3444 // class SvxBrushItem_Impl ----------------------------------------------- 3445 3446 class SvxBrushItem_Impl 3447 { 3448 public: 3449 GraphicObject* pGraphicObject; 3450 sal_Int8 nGraphicTransparency; //contains a percentage value which is 3451 //copied to the GraphicObject when necessary 3452 Link aDoneLink; 3453 SvStream* pStream; 3454 3455 SvxBrushItem_Impl( GraphicObject* p ) : pGraphicObject( p ), nGraphicTransparency(0), pStream(0) {} 3456 }; 3457 3458 // ----------------------------------------------------------------------- 3459 3460 void SvxBrushItem::SetDoneLink( const Link& rLink ) 3461 { 3462 pImpl->aDoneLink = rLink; 3463 } 3464 3465 // ----------------------------------------------------------------------- 3466 3467 SvxBrushItem::SvxBrushItem( sal_uInt16 _nWhich ) : 3468 3469 SfxPoolItem( _nWhich ), 3470 3471 aColor ( COL_TRANSPARENT ), 3472 pImpl ( new SvxBrushItem_Impl( 0 ) ), 3473 pStrLink ( NULL ), 3474 pStrFilter ( NULL ), 3475 eGraphicPos ( GPOS_NONE ), 3476 bLoadAgain ( sal_True ) 3477 3478 { 3479 } 3480 3481 // ----------------------------------------------------------------------- 3482 3483 SvxBrushItem::SvxBrushItem( const Color& rColor, sal_uInt16 _nWhich) : 3484 3485 SfxPoolItem( _nWhich ), 3486 3487 aColor ( rColor ), 3488 pImpl ( new SvxBrushItem_Impl( 0 ) ), 3489 pStrLink ( NULL ), 3490 pStrFilter ( NULL ), 3491 eGraphicPos ( GPOS_NONE ), 3492 bLoadAgain ( sal_True ) 3493 3494 { 3495 } 3496 3497 // ----------------------------------------------------------------------- 3498 3499 SvxBrushItem::SvxBrushItem( const Graphic& rGraphic, SvxGraphicPosition ePos, 3500 sal_uInt16 _nWhich ) : 3501 3502 SfxPoolItem( _nWhich ), 3503 3504 aColor ( COL_TRANSPARENT ), 3505 pImpl ( new SvxBrushItem_Impl( new GraphicObject( rGraphic ) ) ), 3506 pStrLink ( NULL ), 3507 pStrFilter ( NULL ), 3508 eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), 3509 bLoadAgain ( sal_True ) 3510 3511 { 3512 DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); 3513 } 3514 3515 // ----------------------------------------------------------------------- 3516 3517 SvxBrushItem::SvxBrushItem( const GraphicObject& rGraphicObj, 3518 SvxGraphicPosition ePos, sal_uInt16 _nWhich ) : 3519 3520 SfxPoolItem( _nWhich ), 3521 3522 aColor ( COL_TRANSPARENT ), 3523 pImpl ( new SvxBrushItem_Impl( new GraphicObject( rGraphicObj ) ) ), 3524 pStrLink ( NULL ), 3525 pStrFilter ( NULL ), 3526 eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), 3527 bLoadAgain ( sal_True ) 3528 3529 { 3530 DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); 3531 } 3532 3533 // ----------------------------------------------------------------------- 3534 3535 SvxBrushItem::SvxBrushItem( 3536 const String& rLink, const String& rFilter, 3537 SvxGraphicPosition ePos, sal_uInt16 _nWhich ) : 3538 3539 SfxPoolItem( _nWhich ), 3540 3541 aColor ( COL_TRANSPARENT ), 3542 pImpl ( new SvxBrushItem_Impl( NULL ) ), 3543 pStrLink ( new String( rLink ) ), 3544 pStrFilter ( new String( rFilter ) ), 3545 eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), 3546 bLoadAgain ( sal_True ) 3547 3548 { 3549 DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); 3550 } 3551 3552 // ----------------------------------------------------------------------- 3553 3554 SvxBrushItem::SvxBrushItem( SvStream& rStream, sal_uInt16 nVersion, 3555 sal_uInt16 _nWhich ) : 3556 3557 SfxPoolItem( _nWhich ), 3558 3559 aColor ( COL_TRANSPARENT ), 3560 pImpl ( new SvxBrushItem_Impl( NULL ) ), 3561 pStrLink ( NULL ), 3562 pStrFilter ( NULL ), 3563 eGraphicPos ( GPOS_NONE ) 3564 3565 { 3566 sal_Bool bTrans; 3567 Color aTempColor; 3568 Color aTempFillColor; 3569 sal_Int8 nStyle; 3570 3571 rStream >> bTrans; 3572 rStream >> aTempColor; 3573 rStream >> aTempFillColor; 3574 rStream >> nStyle; 3575 3576 switch ( nStyle ) 3577 { 3578 case 8://BRUSH_25: 3579 { 3580 sal_uInt32 nRed = aTempColor.GetRed(); 3581 sal_uInt32 nGreen = aTempColor.GetGreen(); 3582 sal_uInt32 nBlue = aTempColor.GetBlue(); 3583 nRed += (sal_uInt32)(aTempFillColor.GetRed())*2; 3584 nGreen += (sal_uInt32)(aTempFillColor.GetGreen())*2; 3585 nBlue += (sal_uInt32)(aTempFillColor.GetBlue())*2; 3586 aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) ); 3587 } 3588 break; 3589 3590 case 9://BRUSH_50: 3591 { 3592 sal_uInt32 nRed = aTempColor.GetRed(); 3593 sal_uInt32 nGreen = aTempColor.GetGreen(); 3594 sal_uInt32 nBlue = aTempColor.GetBlue(); 3595 nRed += (sal_uInt32)(aTempFillColor.GetRed()); 3596 nGreen += (sal_uInt32)(aTempFillColor.GetGreen()); 3597 nBlue += (sal_uInt32)(aTempFillColor.GetBlue()); 3598 aColor = Color( (sal_Int8)(nRed/2), (sal_Int8)(nGreen/2), (sal_Int8)(nBlue/2) ); 3599 } 3600 break; 3601 3602 case 10://BRUSH_75: 3603 { 3604 sal_uInt32 nRed = aTempColor.GetRed()*2; 3605 sal_uInt32 nGreen = aTempColor.GetGreen()*2; 3606 sal_uInt32 nBlue = aTempColor.GetBlue()*2; 3607 nRed += (sal_uInt32)(aTempFillColor.GetRed()); 3608 nGreen += (sal_uInt32)(aTempFillColor.GetGreen()); 3609 nBlue += (sal_uInt32)(aTempFillColor.GetBlue()); 3610 aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) ); 3611 } 3612 break; 3613 3614 case 0://BRUSH_NULL: 3615 aColor = Color( COL_TRANSPARENT ); 3616 break; 3617 3618 default: 3619 aColor = aTempColor; 3620 } 3621 3622 if ( nVersion >= BRUSH_GRAPHIC_VERSION ) 3623 { 3624 sal_uInt16 nDoLoad = 0; 3625 sal_Int8 nPos; 3626 3627 rStream >> nDoLoad; 3628 3629 if ( nDoLoad & LOAD_GRAPHIC ) 3630 { 3631 Graphic aGraphic; 3632 3633 rStream >> aGraphic; 3634 pImpl->pGraphicObject = new GraphicObject( aGraphic ); 3635 3636 if( SVSTREAM_FILEFORMAT_ERROR == rStream.GetError() ) 3637 { 3638 rStream.ResetError(); 3639 rStream.SetError( ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT| 3640 ERRCODE_WARNING_MASK ); 3641 } 3642 } 3643 3644 if ( nDoLoad & LOAD_LINK ) 3645 { 3646 String aRel; 3647 // UNICODE: rStream >> aRel; 3648 rStream.ReadByteString(aRel); 3649 3650 // TODO/MBA: how can we get a BaseURL here?! 3651 DBG_ERROR("No BaseURL!"); 3652 String aAbs = INetURLObject::GetAbsURL( String(), aRel ); 3653 DBG_ASSERT( aAbs.Len(), "Invalid URL!" ); 3654 pStrLink = new String( aAbs ); 3655 } 3656 3657 if ( nDoLoad & LOAD_FILTER ) 3658 { 3659 pStrFilter = new String; 3660 // UNICODE: rStream >> *pStrFilter; 3661 rStream.ReadByteString(*pStrFilter); 3662 } 3663 3664 rStream >> nPos; 3665 3666 eGraphicPos = (SvxGraphicPosition)nPos; 3667 } 3668 } 3669 3670 // ----------------------------------------------------------------------- 3671 3672 SvxBrushItem::SvxBrushItem( const SvxBrushItem& rItem ) : 3673 3674 SfxPoolItem( rItem.Which() ), 3675 3676 pImpl ( new SvxBrushItem_Impl( NULL ) ), 3677 pStrLink ( NULL ), 3678 pStrFilter ( NULL ), 3679 eGraphicPos ( GPOS_NONE ), 3680 bLoadAgain ( sal_True ) 3681 3682 { 3683 *this = rItem; 3684 } 3685 3686 // ----------------------------------------------------------------------- 3687 3688 SvxBrushItem::~SvxBrushItem() 3689 { 3690 delete pImpl->pGraphicObject; 3691 delete pImpl; 3692 delete pStrLink; 3693 delete pStrFilter; 3694 } 3695 3696 // ----------------------------------------------------------------------- 3697 3698 sal_uInt16 SvxBrushItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const 3699 { 3700 return BRUSH_GRAPHIC_VERSION; 3701 } 3702 3703 // ----------------------------------------------------------------------- 3704 inline sal_Int8 lcl_PercentToTransparency(long nPercent) 3705 { 3706 //0xff must not be returned! 3707 return sal_Int8(nPercent ? (50 + 0xfe * nPercent) / 100 : 0); 3708 } 3709 inline sal_Int8 lcl_TransparencyToPercent(sal_Int32 nTrans) 3710 { 3711 return (sal_Int8)((nTrans * 100 + 127) / 254); 3712 } 3713 3714 sal_Bool SvxBrushItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 3715 { 3716 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 3717 nMemberId &= ~CONVERT_TWIPS; 3718 switch( nMemberId) 3719 { 3720 case MID_BACK_COLOR: 3721 rVal <<= (sal_Int32)( aColor.GetColor() ); 3722 break; 3723 case MID_BACK_COLOR_R_G_B: 3724 rVal <<= (sal_Int32)( aColor.GetRGBColor() ); 3725 break; 3726 case MID_BACK_COLOR_TRANSPARENCY: 3727 rVal <<= lcl_TransparencyToPercent(aColor.GetTransparency()); 3728 break; 3729 case MID_GRAPHIC_POSITION: 3730 rVal <<= (style::GraphicLocation)(sal_Int16)eGraphicPos; 3731 break; 3732 3733 case MID_GRAPHIC: 3734 DBG_ERRORFILE( "not implemented" ); 3735 break; 3736 3737 case MID_GRAPHIC_TRANSPARENT: 3738 rVal = Bool2Any( aColor.GetTransparency() == 0xff ); 3739 break; 3740 3741 case MID_GRAPHIC_URL: 3742 { 3743 OUString sLink; 3744 if ( pStrLink ) 3745 sLink = *pStrLink; 3746 else if( pImpl->pGraphicObject ) 3747 { 3748 OUString sPrefix(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX)); 3749 String sId( pImpl->pGraphicObject->GetUniqueID(), 3750 RTL_TEXTENCODING_ASCII_US ); 3751 sLink = sPrefix; 3752 sLink += OUString(sId); 3753 } 3754 rVal <<= sLink; 3755 } 3756 break; 3757 3758 case MID_GRAPHIC_FILTER: 3759 { 3760 OUString sFilter; 3761 if ( pStrFilter ) 3762 sFilter = *pStrFilter; 3763 rVal <<= sFilter; 3764 } 3765 break; 3766 case MID_GRAPHIC_TRANSPARENCY : 3767 rVal <<= pImpl->nGraphicTransparency; 3768 break; 3769 } 3770 3771 return sal_True; 3772 } 3773 3774 // ----------------------------------------------------------------------- 3775 3776 sal_Bool SvxBrushItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 3777 { 3778 // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); 3779 nMemberId &= ~CONVERT_TWIPS; 3780 switch( nMemberId) 3781 { 3782 case MID_BACK_COLOR: 3783 case MID_BACK_COLOR_R_G_B: 3784 { 3785 sal_Int32 nCol = 0; 3786 if ( !( rVal >>= nCol ) ) 3787 return sal_False; 3788 if(MID_BACK_COLOR_R_G_B == nMemberId) 3789 { 3790 nCol = COLORDATA_RGB( nCol ); 3791 nCol += aColor.GetColor() & 0xff000000; 3792 } 3793 aColor = Color( nCol ); 3794 } 3795 break; 3796 case MID_BACK_COLOR_TRANSPARENCY: 3797 { 3798 sal_Int32 nTrans = 0; 3799 if ( !( rVal >>= nTrans ) || nTrans < 0 || nTrans > 100 ) 3800 return sal_False; 3801 aColor.SetTransparency(lcl_PercentToTransparency(nTrans)); 3802 } 3803 break; 3804 3805 case MID_GRAPHIC_POSITION: 3806 { 3807 style::GraphicLocation eLocation; 3808 if ( !( rVal>>=eLocation ) ) 3809 { 3810 sal_Int32 nValue = 0; 3811 if ( !( rVal >>= nValue ) ) 3812 return sal_False; 3813 eLocation = (style::GraphicLocation)nValue; 3814 } 3815 SetGraphicPos( (SvxGraphicPosition)(sal_uInt16)eLocation ); 3816 } 3817 break; 3818 3819 case MID_GRAPHIC: 3820 DBG_ERRORFILE( "not implemented" ); 3821 break; 3822 3823 case MID_GRAPHIC_TRANSPARENT: 3824 aColor.SetTransparency( Any2Bool( rVal ) ? 0xff : 0 ); 3825 break; 3826 3827 case MID_GRAPHIC_URL: 3828 { 3829 if ( rVal.getValueType() == ::getCppuType( (OUString*)0 ) ) 3830 { 3831 OUString sLink; 3832 rVal >>= sLink; 3833 if( 0 == sLink.compareToAscii( UNO_NAME_GRAPHOBJ_URLPKGPREFIX, 3834 sizeof(UNO_NAME_GRAPHOBJ_URLPKGPREFIX)-1 ) ) 3835 { 3836 DBG_ERROR( "package urls aren't implemented" ); 3837 } 3838 else if( 0 == sLink.compareToAscii( UNO_NAME_GRAPHOBJ_URLPREFIX, 3839 sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX)-1 ) ) 3840 { 3841 DELETEZ( pStrLink ); 3842 String sTmp( sLink ); 3843 ByteString sId( sTmp.Copy( 3844 sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX)-1), 3845 RTL_TEXTENCODING_ASCII_US ); 3846 GraphicObject *pOldGrfObj = pImpl->pGraphicObject; 3847 pImpl->pGraphicObject = new GraphicObject( sId ); 3848 ApplyGraphicTransparency_Impl(); 3849 delete pOldGrfObj; 3850 } 3851 else 3852 { 3853 SetGraphicLink(sLink); 3854 } 3855 if ( sLink.getLength() && eGraphicPos == GPOS_NONE ) 3856 eGraphicPos = GPOS_MM; 3857 else if( !sLink.getLength() ) 3858 eGraphicPos = GPOS_NONE; 3859 } 3860 } 3861 break; 3862 3863 case MID_GRAPHIC_FILTER: 3864 { 3865 if( rVal.getValueType() == ::getCppuType( (OUString*)0 ) ) 3866 { 3867 OUString sLink; 3868 rVal >>= sLink; 3869 SetGraphicFilter( sLink ); 3870 } 3871 } 3872 break; 3873 case MID_GRAPHIC_TRANSPARENCY : 3874 { 3875 sal_Int32 nTmp = 0; 3876 rVal >>= nTmp; 3877 if(nTmp >= 0 && nTmp <= 100) 3878 { 3879 pImpl->nGraphicTransparency = sal_Int8(nTmp); 3880 if(pImpl->pGraphicObject) 3881 ApplyGraphicTransparency_Impl(); 3882 } 3883 } 3884 break; 3885 } 3886 3887 return sal_True; 3888 } 3889 3890 // ----------------------------------------------------------------------- 3891 3892 SfxItemPresentation SvxBrushItem::GetPresentation 3893 ( 3894 SfxItemPresentation ePres, 3895 SfxMapUnit /*eCoreUnit*/, 3896 SfxMapUnit /*ePresUnit*/, 3897 XubString& rText, const IntlWrapper * 3898 ) const 3899 { 3900 switch ( ePres ) 3901 { 3902 case SFX_ITEM_PRESENTATION_NONE: 3903 rText.Erase(); 3904 return ePres; 3905 3906 case SFX_ITEM_PRESENTATION_NAMELESS: 3907 case SFX_ITEM_PRESENTATION_COMPLETE: 3908 { 3909 if ( GPOS_NONE == eGraphicPos ) 3910 { 3911 rText = ::GetColorString( aColor ); 3912 rText += cpDelim; 3913 sal_uInt16 nId = RID_SVXITEMS_TRANSPARENT_FALSE; 3914 3915 if ( aColor.GetTransparency() ) 3916 nId = RID_SVXITEMS_TRANSPARENT_TRUE; 3917 rText += EE_RESSTR(nId); 3918 } 3919 else 3920 { 3921 rText = EE_RESSTR(RID_SVXITEMS_GRAPHIC); 3922 } 3923 3924 return ePres; 3925 } 3926 default: ;//prevent warning 3927 } 3928 3929 return SFX_ITEM_PRESENTATION_NONE; 3930 } 3931 3932 // ----------------------------------------------------------------------- 3933 3934 SvxBrushItem& SvxBrushItem::operator=( const SvxBrushItem& rItem ) 3935 { 3936 aColor = rItem.aColor; 3937 eGraphicPos = rItem.eGraphicPos; 3938 3939 DELETEZ( pImpl->pGraphicObject ); 3940 DELETEZ( pStrLink ); 3941 DELETEZ( pStrFilter ); 3942 3943 if ( GPOS_NONE != eGraphicPos ) 3944 { 3945 if ( rItem.pStrLink ) 3946 pStrLink = new String( *rItem.pStrLink ); 3947 if ( rItem.pStrFilter ) 3948 pStrFilter = new String( *rItem.pStrFilter ); 3949 if ( rItem.pImpl->pGraphicObject ) 3950 { 3951 pImpl->pGraphicObject = new GraphicObject( *rItem.pImpl->pGraphicObject ); 3952 } 3953 } 3954 pImpl->nGraphicTransparency = rItem.pImpl->nGraphicTransparency; 3955 return *this; 3956 } 3957 3958 // ----------------------------------------------------------------------- 3959 3960 int SvxBrushItem::operator==( const SfxPoolItem& rAttr ) const 3961 { 3962 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 3963 3964 SvxBrushItem& rCmp = (SvxBrushItem&)rAttr; 3965 sal_Bool bEqual = ( aColor == rCmp.aColor && eGraphicPos == rCmp.eGraphicPos && 3966 pImpl->nGraphicTransparency == rCmp.pImpl->nGraphicTransparency); 3967 3968 if ( bEqual ) 3969 { 3970 if ( GPOS_NONE != eGraphicPos ) 3971 { 3972 if ( !rCmp.pStrLink ) 3973 bEqual = !pStrLink; 3974 else 3975 bEqual = pStrLink && ( *pStrLink == *rCmp.pStrLink ); 3976 3977 if ( bEqual ) 3978 { 3979 if ( !rCmp.pStrFilter ) 3980 bEqual = !pStrFilter; 3981 else 3982 bEqual = pStrFilter && ( *pStrFilter == *rCmp.pStrFilter ); 3983 } 3984 3985 if ( bEqual && !rCmp.pStrLink ) 3986 { 3987 if ( !rCmp.pImpl->pGraphicObject ) 3988 bEqual = !pImpl->pGraphicObject; 3989 else 3990 bEqual = pImpl->pGraphicObject && 3991 ( *pImpl->pGraphicObject == *rCmp.pImpl->pGraphicObject ); 3992 } 3993 } 3994 } 3995 3996 return bEqual; 3997 } 3998 3999 // ----------------------------------------------------------------------- 4000 4001 SfxPoolItem* SvxBrushItem::Clone( SfxItemPool* ) const 4002 { 4003 return new SvxBrushItem( *this ); 4004 } 4005 4006 // ----------------------------------------------------------------------- 4007 4008 SfxPoolItem* SvxBrushItem::Create( SvStream& rStream, sal_uInt16 nVersion ) const 4009 { 4010 return new SvxBrushItem( rStream, nVersion, Which() ); 4011 } 4012 4013 // ----------------------------------------------------------------------- 4014 4015 SvStream& SvxBrushItem::Store( SvStream& rStream , sal_uInt16 /*nItemVersion*/ ) const 4016 { 4017 rStream << (sal_Bool)sal_False; 4018 rStream << aColor; 4019 rStream << aColor; 4020 rStream << (sal_Int8)(aColor.GetTransparency() > 0 ? 0 : 1); //BRUSH_NULL : BRUSH_SOLID 4021 4022 sal_uInt16 nDoLoad = 0; 4023 4024 if ( pImpl->pGraphicObject && !pStrLink ) 4025 nDoLoad |= LOAD_GRAPHIC; 4026 if ( pStrLink ) 4027 nDoLoad |= LOAD_LINK; 4028 if ( pStrFilter ) 4029 nDoLoad |= LOAD_FILTER; 4030 rStream << nDoLoad; 4031 4032 if ( pImpl->pGraphicObject && !pStrLink ) 4033 rStream << pImpl->pGraphicObject->GetGraphic(); 4034 if ( pStrLink ) 4035 { 4036 DBG_ERROR("No BaseURL!"); 4037 // TODO/MBA: how to get a BaseURL?! 4038 String aRel = INetURLObject::GetRelURL( String(), *pStrLink ); 4039 // UNICODE: rStream << aRel; 4040 rStream.WriteByteString(aRel); 4041 } 4042 if ( pStrFilter ) 4043 { 4044 // UNICODE: rStream << *pStrFilter; 4045 rStream.WriteByteString(*pStrFilter); 4046 } 4047 rStream << (sal_Int8)eGraphicPos; 4048 return rStream; 4049 } 4050 4051 // ----------------------------------------------------------------------- 4052 // const wegcasten, da const als logisches const zu verstehen ist 4053 // wenn GetGraphic() gerufen wird, soll sich das Item darum kuemmern, 4054 // eine gelinkte Grafik zu holen. 4055 // ----------------------------------------------------------------------- 4056 4057 void SvxBrushItem::PurgeGraphic() const 4058 { 4059 PurgeMedium(); 4060 DELETEZ( pImpl->pGraphicObject ); 4061 ((SvxBrushItem*)this)->bLoadAgain = sal_True; 4062 } 4063 4064 // ----------------------------------------------------------------------- 4065 4066 void SvxBrushItem::PurgeMedium() const 4067 { 4068 DELETEZ( pImpl->pStream ); 4069 } 4070 4071 // ----------------------------------------------------------------------- 4072 const GraphicObject* SvxBrushItem::GetGraphicObject() const 4073 { 4074 if ( bLoadAgain && pStrLink && !pImpl->pGraphicObject ) 4075 // wenn Grafik schon geladen, als Cache benutzen 4076 { 4077 //JP 29.6.2001: only with "valid" names - empty names now allowed 4078 if( pStrLink->Len() ) 4079 { 4080 // currently we don't have asynchronous processing 4081 /* if( pImpl->aDoneLink.IsSet() ) 4082 { 4083 // Auf besonderen Wunsch des Writers wird der synchrone und der 4084 // asynchrone Fall was die Benachrichtigung angeht unterschiedlich 4085 // behandelt. Der Callback erfolgt nur bei asynchronem Eintreffen 4086 // der Daten 4087 4088 Link aTmp = pImpl->aDoneLink; 4089 pImpl->aDoneLink = Link(); 4090 pImpl->xMedium->DownLoad( 4091 STATIC_LINK( this, SvxBrushItem, DoneHdl_Impl ) ); 4092 pImpl->aDoneLink = aTmp; 4093 } */ 4094 4095 pImpl->pStream = utl::UcbStreamHelper::CreateStream( *pStrLink, STREAM_STD_READ ); 4096 if( pImpl->pStream && !pImpl->pStream->GetError() ) 4097 { 4098 Graphic aGraphic; 4099 int nRes; 4100 pImpl->pStream->Seek( STREAM_SEEK_TO_BEGIN ); 4101 nRes = GraphicFilter::GetGraphicFilter()-> 4102 ImportGraphic( aGraphic, *pStrLink, *pImpl->pStream, 4103 GRFILTER_FORMAT_DONTKNOW, NULL, GRFILTER_I_FLAGS_DONT_SET_LOGSIZE_FOR_JPEG ); 4104 4105 if( nRes != GRFILTER_OK ) 4106 { 4107 const_cast < SvxBrushItem*> (this)->bLoadAgain = sal_False; 4108 } 4109 else 4110 { 4111 pImpl->pGraphicObject = new GraphicObject; 4112 pImpl->pGraphicObject->SetGraphic( aGraphic ); 4113 const_cast < SvxBrushItem*> (this)->ApplyGraphicTransparency_Impl(); 4114 } 4115 } 4116 else 4117 { 4118 const_cast < SvxBrushItem*> (this)->bLoadAgain = sal_False; 4119 } 4120 4121 // currently we don't have asynchronous processing 4122 // pThis->pImpl->aDoneLink.Call( pThis ); 4123 } 4124 } 4125 4126 return pImpl->pGraphicObject; 4127 } 4128 4129 // ----------------------------------------------------------------------- 4130 4131 const Graphic* SvxBrushItem::GetGraphic() const 4132 { 4133 const GraphicObject* pGrafObj = GetGraphicObject(); 4134 return( pGrafObj ? &( pGrafObj->GetGraphic() ) : NULL ); 4135 } 4136 4137 // ----------------------------------------------------------------------- 4138 4139 void SvxBrushItem::SetGraphicPos( SvxGraphicPosition eNew ) 4140 { 4141 eGraphicPos = eNew; 4142 4143 if ( GPOS_NONE == eGraphicPos ) 4144 { 4145 DELETEZ( pImpl->pGraphicObject ); 4146 DELETEZ( pStrLink ); 4147 DELETEZ( pStrFilter ); 4148 } 4149 else 4150 { 4151 if ( !pImpl->pGraphicObject && !pStrLink ) 4152 { 4153 pImpl->pGraphicObject = new GraphicObject; // dummy anlegen 4154 } 4155 } 4156 } 4157 4158 // ----------------------------------------------------------------------- 4159 4160 void SvxBrushItem::SetGraphic( const Graphic& rNew ) 4161 { 4162 if ( !pStrLink ) 4163 { 4164 if ( pImpl->pGraphicObject ) 4165 pImpl->pGraphicObject->SetGraphic( rNew ); 4166 else 4167 pImpl->pGraphicObject = new GraphicObject( rNew ); 4168 4169 ApplyGraphicTransparency_Impl(); 4170 4171 if ( GPOS_NONE == eGraphicPos ) 4172 eGraphicPos = GPOS_MM; // None waere Brush, also Default: Mitte 4173 } 4174 else 4175 { 4176 DBG_ERROR( "SetGraphic() on linked graphic! :-/" ); 4177 } 4178 } 4179 4180 // ----------------------------------------------------------------------- 4181 4182 void SvxBrushItem::SetGraphicObject( const GraphicObject& rNewObj ) 4183 { 4184 if ( !pStrLink ) 4185 { 4186 if ( pImpl->pGraphicObject ) 4187 *pImpl->pGraphicObject = rNewObj; 4188 else 4189 pImpl->pGraphicObject = new GraphicObject( rNewObj ); 4190 4191 ApplyGraphicTransparency_Impl(); 4192 4193 if ( GPOS_NONE == eGraphicPos ) 4194 eGraphicPos = GPOS_MM; // None waere Brush, also Default: Mitte 4195 } 4196 else 4197 { 4198 DBG_ERROR( "SetGraphic() on linked graphic! :-/" ); 4199 } 4200 } 4201 4202 // ----------------------------------------------------------------------- 4203 4204 void SvxBrushItem::SetGraphicLink( const String& rNew ) 4205 { 4206 if ( !rNew.Len() ) 4207 DELETEZ( pStrLink ); 4208 else 4209 { 4210 if ( pStrLink ) 4211 *pStrLink = rNew; 4212 else 4213 pStrLink = new String( rNew ); 4214 4215 DELETEZ( pImpl->pGraphicObject ); 4216 } 4217 } 4218 4219 // ----------------------------------------------------------------------- 4220 4221 void SvxBrushItem::SetGraphicFilter( const String& rNew ) 4222 { 4223 if ( !rNew.Len() ) 4224 DELETEZ( pStrFilter ); 4225 else 4226 { 4227 if ( pStrFilter ) 4228 *pStrFilter = rNew; 4229 else 4230 pStrFilter = new String( rNew ); 4231 } 4232 } 4233 4234 //static 4235 SvxGraphicPosition SvxBrushItem::WallpaperStyle2GraphicPos( WallpaperStyle eStyle ) 4236 { 4237 SvxGraphicPosition eResult; 4238 // der Switch ist nicht der schnellste, dafuer aber am sichersten 4239 switch( eStyle ) 4240 { 4241 case WALLPAPER_NULL: eResult = GPOS_NONE; break; 4242 case WALLPAPER_TILE: eResult = GPOS_TILED; break; 4243 case WALLPAPER_CENTER: eResult = GPOS_MM; break; 4244 case WALLPAPER_SCALE: eResult = GPOS_AREA; break; 4245 case WALLPAPER_TOPLEFT: eResult = GPOS_LT; break; 4246 case WALLPAPER_TOP: eResult = GPOS_MT; break; 4247 case WALLPAPER_TOPRIGHT: eResult = GPOS_RT; break; 4248 case WALLPAPER_LEFT: eResult = GPOS_LM; break; 4249 case WALLPAPER_RIGHT: eResult = GPOS_RM; break; 4250 case WALLPAPER_BOTTOMLEFT: eResult = GPOS_LB; break; 4251 case WALLPAPER_BOTTOM: eResult = GPOS_MB; break; 4252 case WALLPAPER_BOTTOMRIGHT: eResult = GPOS_RB; break; 4253 default: eResult = GPOS_NONE; 4254 } 4255 return eResult; 4256 }; 4257 4258 //static 4259 WallpaperStyle SvxBrushItem::GraphicPos2WallpaperStyle( SvxGraphicPosition ePos ) 4260 { 4261 WallpaperStyle eResult; 4262 switch( ePos ) 4263 { 4264 case GPOS_NONE: eResult = WALLPAPER_NULL; break; 4265 case GPOS_TILED: eResult = WALLPAPER_TILE; break; 4266 case GPOS_MM: eResult = WALLPAPER_CENTER; break; 4267 case GPOS_AREA: eResult = WALLPAPER_SCALE; break; 4268 case GPOS_LT: eResult = WALLPAPER_TOPLEFT; break; 4269 case GPOS_MT: eResult = WALLPAPER_TOP; break; 4270 case GPOS_RT: eResult = WALLPAPER_TOPRIGHT; break; 4271 case GPOS_LM: eResult = WALLPAPER_LEFT; break; 4272 case GPOS_RM: eResult = WALLPAPER_RIGHT; break; 4273 case GPOS_LB: eResult = WALLPAPER_BOTTOMLEFT; break; 4274 case GPOS_MB: eResult = WALLPAPER_BOTTOM; break; 4275 case GPOS_RB: eResult = WALLPAPER_BOTTOMRIGHT; break; 4276 default: eResult = WALLPAPER_NULL; 4277 } 4278 return eResult; 4279 } 4280 4281 4282 SvxBrushItem::SvxBrushItem( const CntWallpaperItem& rItem, sal_uInt16 _nWhich ) : 4283 SfxPoolItem( _nWhich ), 4284 pImpl( new SvxBrushItem_Impl( 0 ) ), 4285 pStrLink(0), 4286 pStrFilter(0), 4287 bLoadAgain( sal_True ) 4288 { 4289 aColor = rItem.GetColor(); 4290 4291 if( rItem.GetBitmapURL().Len() ) 4292 { 4293 pStrLink = new String( rItem.GetBitmapURL() ); 4294 SetGraphicPos( WallpaperStyle2GraphicPos((WallpaperStyle)rItem.GetStyle() ) ); 4295 } 4296 } 4297 4298 CntWallpaperItem* SvxBrushItem::CreateCntWallpaperItem() const 4299 { 4300 CntWallpaperItem* pItem = new CntWallpaperItem( 0 ); 4301 pItem->SetColor( aColor.GetColor() ); 4302 pItem->SetStyle( (sal_uInt16)GraphicPos2WallpaperStyle( GetGraphicPos() ) ); 4303 sal_Bool bLink = (pStrLink != 0); 4304 if( bLink ) 4305 { 4306 String aURL = *pStrLink; 4307 pItem->SetBitmapURL( aURL ); 4308 } 4309 if( pImpl->pGraphicObject ) 4310 { 4311 DBG_ERRORFILE( "Don't know what to do with a graphic" ); 4312 } 4313 // pItem->SetGraphic( *pImpl->pGraphic, bLink ); 4314 4315 return pItem; 4316 } 4317 4318 #ifdef _MSC_VER 4319 #pragma optimize ( "", on ) 4320 #endif 4321 /* -----------------------------16.08.2002 09:18------------------------------ 4322 4323 ---------------------------------------------------------------------------*/ 4324 void SvxBrushItem::ApplyGraphicTransparency_Impl() 4325 { 4326 DBG_ASSERT(pImpl->pGraphicObject, "no GraphicObject available" ); 4327 if(pImpl->pGraphicObject) 4328 { 4329 GraphicAttr aAttr(pImpl->pGraphicObject->GetAttr()); 4330 aAttr.SetTransparency(lcl_PercentToTransparency( 4331 pImpl->nGraphicTransparency)); 4332 pImpl->pGraphicObject->SetAttr(aAttr); 4333 } 4334 } 4335 // class SvxFrameDirectionItem ---------------------------------------------- 4336 4337 SvxFrameDirectionItem::SvxFrameDirectionItem( sal_uInt16 _nWhich ) 4338 : SfxUInt16Item( _nWhich, (sal_uInt16)FRMDIR_HORI_LEFT_TOP ) 4339 { 4340 } 4341 4342 SvxFrameDirectionItem::SvxFrameDirectionItem( SvxFrameDirection nValue , 4343 sal_uInt16 _nWhich ) 4344 : SfxUInt16Item( _nWhich, (sal_uInt16)nValue ) 4345 { 4346 } 4347 4348 SvxFrameDirectionItem::~SvxFrameDirectionItem() 4349 { 4350 } 4351 4352 int SvxFrameDirectionItem::operator==( const SfxPoolItem& rCmp ) const 4353 { 4354 DBG_ASSERT( SfxPoolItem::operator==(rCmp), "unequal types" ); 4355 4356 return GetValue() == ((SvxFrameDirectionItem&)rCmp).GetValue(); 4357 } 4358 4359 SfxPoolItem* SvxFrameDirectionItem::Clone( SfxItemPool * ) const 4360 { 4361 return new SvxFrameDirectionItem( *this ); 4362 } 4363 4364 SfxPoolItem* SvxFrameDirectionItem::Create( SvStream & rStrm, sal_uInt16 /*nVer*/ ) const 4365 { 4366 sal_uInt16 nValue; 4367 rStrm >> nValue; 4368 return new SvxFrameDirectionItem( (SvxFrameDirection)nValue, Which() ); 4369 } 4370 4371 SvStream& SvxFrameDirectionItem::Store( SvStream & rStrm, sal_uInt16 /*nIVer*/ ) const 4372 { 4373 sal_uInt16 nValue = GetValue(); 4374 rStrm << nValue; 4375 return rStrm; 4376 } 4377 4378 sal_uInt16 SvxFrameDirectionItem::GetVersion( sal_uInt16 nFVer ) const 4379 { 4380 return SOFFICE_FILEFORMAT_50 > nFVer ? USHRT_MAX : 0; 4381 } 4382 4383 SfxItemPresentation SvxFrameDirectionItem::GetPresentation( 4384 SfxItemPresentation ePres, 4385 SfxMapUnit /*eCoreUnit*/, 4386 SfxMapUnit /*ePresUnit*/, 4387 XubString& rText, const IntlWrapper *) const 4388 { 4389 SfxItemPresentation eRet = ePres; 4390 switch( ePres ) 4391 { 4392 case SFX_ITEM_PRESENTATION_NONE: 4393 rText.Erase(); 4394 break; 4395 4396 case SFX_ITEM_PRESENTATION_NAMELESS: 4397 case SFX_ITEM_PRESENTATION_COMPLETE: 4398 rText = EE_RESSTR( RID_SVXITEMS_FRMDIR_BEGIN + GetValue() ); 4399 break; 4400 4401 default: 4402 eRet = SFX_ITEM_PRESENTATION_NONE; 4403 } 4404 return eRet; 4405 } 4406 4407 sal_Bool SvxFrameDirectionItem::PutValue( const com::sun::star::uno::Any& rVal, 4408 sal_uInt8 ) 4409 { 4410 sal_Int16 nVal = sal_Int16(); 4411 sal_Bool bRet = ( rVal >>= nVal ); 4412 if( bRet ) 4413 { 4414 // translate WritingDirection2 constants into SvxFrameDirection 4415 switch( nVal ) 4416 { 4417 case text::WritingMode2::LR_TB: 4418 SetValue( FRMDIR_HORI_LEFT_TOP ); 4419 break; 4420 case text::WritingMode2::RL_TB: 4421 SetValue( FRMDIR_HORI_RIGHT_TOP ); 4422 break; 4423 case text::WritingMode2::TB_RL: 4424 SetValue( FRMDIR_VERT_TOP_RIGHT ); 4425 break; 4426 case text::WritingMode2::TB_LR: 4427 SetValue( FRMDIR_VERT_TOP_LEFT ); 4428 break; 4429 case text::WritingMode2::PAGE: 4430 SetValue( FRMDIR_ENVIRONMENT ); 4431 break; 4432 default: 4433 bRet = sal_False; 4434 break; 4435 } 4436 } 4437 4438 return bRet; 4439 } 4440 4441 sal_Bool SvxFrameDirectionItem::QueryValue( com::sun::star::uno::Any& rVal, 4442 sal_uInt8 ) const 4443 { 4444 // translate SvxFrameDirection into WritingDirection2 4445 sal_Int16 nVal; 4446 sal_Bool bRet = sal_True; 4447 switch( GetValue() ) 4448 { 4449 case FRMDIR_HORI_LEFT_TOP: 4450 nVal = text::WritingMode2::LR_TB; 4451 break; 4452 case FRMDIR_HORI_RIGHT_TOP: 4453 nVal = text::WritingMode2::RL_TB; 4454 break; 4455 case FRMDIR_VERT_TOP_RIGHT: 4456 nVal = text::WritingMode2::TB_RL; 4457 break; 4458 case FRMDIR_VERT_TOP_LEFT: 4459 nVal = text::WritingMode2::TB_LR; 4460 break; 4461 case FRMDIR_ENVIRONMENT: 4462 nVal = text::WritingMode2::PAGE; 4463 break; 4464 default: 4465 DBG_ERROR("Unknown SvxFrameDirection value!"); 4466 bRet = sal_False; 4467 break; 4468 } 4469 4470 // return value + error state 4471 if( bRet ) 4472 { 4473 rVal <<= nVal; 4474 } 4475 return bRet; 4476 } 4477 4478