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_sc.hxx" 26 27 28 29 // INCLUDE --------------------------------------------------------------- 30 31 32 #include <com/sun/star/util/CellProtection.hpp> 33 #include <com/sun/star/util/XProtectable.hpp> 34 #include <com/sun/star/text/XText.hpp> 35 #include <com/sun/star/beans/XPropertySet.hpp> 36 37 #include "scitems.hxx" 38 #include <editeng/eeitem.hxx> 39 40 #include <editeng/boxitem.hxx> 41 #include <editeng/editdata.hxx> 42 #include <editeng/editeng.hxx> 43 #include <editeng/editobj.hxx> 44 #include <editeng/flditem.hxx> 45 46 #include "attrib.hxx" 47 #include "global.hxx" 48 #include "editutil.hxx" 49 #include "sc.hrc" 50 #include "globstr.hrc" 51 52 #include "textuno.hxx" // ScHeaderFooterContentObj 53 54 using namespace com::sun::star; 55 56 //------------------------------------------------------------------------ 57 58 TYPEINIT1(ScMergeAttr, SfxPoolItem); 59 TYPEINIT1_AUTOFACTORY(ScProtectionAttr, SfxPoolItem); 60 TYPEINIT1(ScRangeItem, SfxPoolItem); 61 TYPEINIT1(ScTableListItem, SfxPoolItem); 62 TYPEINIT1(ScPageHFItem, SfxPoolItem); 63 TYPEINIT1(ScViewObjectModeItem, SfxEnumItem); 64 TYPEINIT1(ScDoubleItem, SfxPoolItem); 65 TYPEINIT1(ScPageScaleToItem, SfxPoolItem); 66 67 //------------------------------------------------------------------------ 68 69 // 70 // allgemeine Hilfsfunktionen 71 // 72 73 sal_Bool ScHasPriority( const SvxBorderLine* pThis, const SvxBorderLine* pOther ) 74 { 75 // DBG_ASSERT( pThis || pOther, "LineAttr == 0" ); 76 77 if (!pThis) 78 return sal_False; 79 if (!pOther) 80 return sal_True; 81 82 sal_uInt16 nThisSize = pThis->GetOutWidth() + pThis->GetDistance() + pThis->GetInWidth(); 83 sal_uInt16 nOtherSize = pOther->GetOutWidth() + pOther->GetDistance() + pOther->GetInWidth(); 84 85 if (nThisSize > nOtherSize) 86 return sal_True; 87 else if (nThisSize < nOtherSize) 88 return sal_False; 89 else 90 { 91 if ( pOther->GetInWidth() && !pThis->GetInWidth() ) 92 return sal_True; 93 else if ( pThis->GetInWidth() && !pOther->GetInWidth() ) 94 return sal_False; 95 else 96 { 97 return sal_True; //! ??? 98 } 99 } 100 } 101 102 103 // 104 // Item - Implementierungen 105 // 106 107 //------------------------------------------------------------------------ 108 // Merge 109 //------------------------------------------------------------------------ 110 111 ScMergeAttr::ScMergeAttr(): 112 SfxPoolItem(ATTR_MERGE), 113 nColMerge(0), 114 nRowMerge(0) 115 {} 116 117 //------------------------------------------------------------------------ 118 119 ScMergeAttr::ScMergeAttr( SCsCOL nCol, SCsROW nRow): 120 SfxPoolItem(ATTR_MERGE), 121 nColMerge(nCol), 122 nRowMerge(nRow) 123 {} 124 125 //------------------------------------------------------------------------ 126 127 ScMergeAttr::ScMergeAttr(const ScMergeAttr& rItem): 128 SfxPoolItem(ATTR_MERGE) 129 { 130 nColMerge = rItem.nColMerge; 131 nRowMerge = rItem.nRowMerge; 132 } 133 134 ScMergeAttr::~ScMergeAttr() 135 { 136 } 137 138 //------------------------------------------------------------------------ 139 140 String ScMergeAttr::GetValueText() const 141 { 142 String aString( '(' ); 143 aString += String::CreateFromInt32( nColMerge ); 144 aString += ','; 145 aString += String::CreateFromInt32( nRowMerge ); 146 aString += ')'; 147 return aString; 148 } 149 150 //------------------------------------------------------------------------ 151 152 int ScMergeAttr::operator==( const SfxPoolItem& rItem ) const 153 { 154 DBG_ASSERT( Which() != rItem.Which() || Type() == rItem.Type(), "which ==, type !=" ); 155 return (Which() == rItem.Which()) 156 && (nColMerge == ((ScMergeAttr&)rItem).nColMerge) 157 && (nRowMerge == ((ScMergeAttr&)rItem).nRowMerge); 158 } 159 160 //------------------------------------------------------------------------ 161 162 SfxPoolItem* ScMergeAttr::Clone( SfxItemPool * ) const 163 { 164 return new ScMergeAttr(*this); 165 } 166 167 //------------------------------------------------------------------------ 168 169 SfxPoolItem* ScMergeAttr::Create( SvStream& rStream, sal_uInt16 /* nVer */ ) const 170 { 171 sal_Int16 nCol; 172 sal_Int16 nRow; 173 rStream >> nCol; 174 rStream >> nRow; 175 return new ScMergeAttr(static_cast<SCCOL>(nCol),static_cast<SCROW>(nRow)); 176 } 177 178 //------------------------------------------------------------------------ 179 // MergeFlag 180 //------------------------------------------------------------------------ 181 182 ScMergeFlagAttr::ScMergeFlagAttr(): 183 SfxInt16Item(ATTR_MERGE_FLAG, 0) 184 { 185 } 186 187 //------------------------------------------------------------------------ 188 189 ScMergeFlagAttr::ScMergeFlagAttr(sal_Int16 nFlags): 190 SfxInt16Item(ATTR_MERGE_FLAG, nFlags) 191 { 192 } 193 194 ScMergeFlagAttr::~ScMergeFlagAttr() 195 { 196 } 197 198 //------------------------------------------------------------------------ 199 // Protection 200 //------------------------------------------------------------------------ 201 202 ScProtectionAttr::ScProtectionAttr(): 203 SfxPoolItem(ATTR_PROTECTION), 204 bProtection(sal_True), 205 bHideFormula(sal_False), 206 bHideCell(sal_False), 207 bHidePrint(sal_False) 208 { 209 } 210 211 //------------------------------------------------------------------------ 212 213 ScProtectionAttr::ScProtectionAttr( sal_Bool bProtect, sal_Bool bHFormula, 214 sal_Bool bHCell, sal_Bool bHPrint): 215 SfxPoolItem(ATTR_PROTECTION), 216 bProtection(bProtect), 217 bHideFormula(bHFormula), 218 bHideCell(bHCell), 219 bHidePrint(bHPrint) 220 { 221 } 222 223 //------------------------------------------------------------------------ 224 225 ScProtectionAttr::ScProtectionAttr(const ScProtectionAttr& rItem): 226 SfxPoolItem(ATTR_PROTECTION) 227 { 228 bProtection = rItem.bProtection; 229 bHideFormula = rItem.bHideFormula; 230 bHideCell = rItem.bHideCell; 231 bHidePrint = rItem.bHidePrint; 232 } 233 234 ScProtectionAttr::~ScProtectionAttr() 235 { 236 } 237 238 //------------------------------------------------------------------------ 239 240 sal_Bool ScProtectionAttr::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 241 { 242 nMemberId &= ~CONVERT_TWIPS; 243 switch ( nMemberId ) 244 { 245 case 0 : 246 { 247 util::CellProtection aProtection; 248 aProtection.IsLocked = bProtection; 249 aProtection.IsFormulaHidden = bHideFormula; 250 aProtection.IsHidden = bHideCell; 251 aProtection.IsPrintHidden = bHidePrint; 252 rVal <<= aProtection; 253 break; 254 } 255 case MID_1 : 256 rVal <<= (sal_Bool ) bProtection; break; 257 case MID_2 : 258 rVal <<= (sal_Bool ) bHideFormula; break; 259 case MID_3 : 260 rVal <<= (sal_Bool ) bHideCell; break; 261 case MID_4 : 262 rVal <<= (sal_Bool ) bHidePrint; break; 263 default: 264 DBG_ERROR("Wrong MemberID!"); 265 return sal_False; 266 } 267 268 return sal_True; 269 } 270 271 sal_Bool ScProtectionAttr::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 272 { 273 sal_Bool bRet = sal_False; 274 sal_Bool bVal = sal_Bool(); 275 nMemberId &= ~CONVERT_TWIPS; 276 switch ( nMemberId ) 277 { 278 case 0 : 279 { 280 util::CellProtection aProtection; 281 if ( rVal >>= aProtection ) 282 { 283 bProtection = aProtection.IsLocked; 284 bHideFormula = aProtection.IsFormulaHidden; 285 bHideCell = aProtection.IsHidden; 286 bHidePrint = aProtection.IsPrintHidden; 287 bRet = sal_True; 288 } 289 else 290 { 291 DBG_ERROR("exception - wrong argument"); 292 } 293 break; 294 } 295 case MID_1 : 296 bRet = (rVal >>= bVal); if (bRet) bProtection=bVal; break; 297 case MID_2 : 298 bRet = (rVal >>= bVal); if (bRet) bHideFormula=bVal; break; 299 case MID_3 : 300 bRet = (rVal >>= bVal); if (bRet) bHideCell=bVal; break; 301 case MID_4 : 302 bRet = (rVal >>= bVal); if (bRet) bHidePrint=bVal; break; 303 default: 304 DBG_ERROR("Wrong MemberID!"); 305 } 306 307 return bRet; 308 } 309 310 //------------------------------------------------------------------------ 311 312 String ScProtectionAttr::GetValueText() const 313 { 314 String aValue; 315 String aStrYes ( ScGlobal::GetRscString(STR_YES) ); 316 String aStrNo ( ScGlobal::GetRscString(STR_NO) ); 317 sal_Unicode cDelim = ','; 318 319 aValue = '('; 320 aValue += (bProtection ? aStrYes : aStrNo); aValue += cDelim; 321 aValue += (bHideFormula ? aStrYes : aStrNo); aValue += cDelim; 322 aValue += (bHideCell ? aStrYes : aStrNo); aValue += cDelim; 323 aValue += (bHidePrint ? aStrYes : aStrNo); 324 aValue += ')'; 325 326 return aValue; 327 } 328 329 //------------------------------------------------------------------------ 330 331 SfxItemPresentation ScProtectionAttr::GetPresentation 332 ( 333 SfxItemPresentation ePres, 334 SfxMapUnit /* eCoreMetric */, 335 SfxMapUnit /* ePresMetric */, 336 String& rText, 337 const IntlWrapper* /* pIntl */ 338 ) const 339 { 340 String aStrYes ( ScGlobal::GetRscString(STR_YES) ); 341 String aStrNo ( ScGlobal::GetRscString(STR_NO) ); 342 String aStrSep = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM( ": " )); 343 String aStrDelim = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM( ", " )); 344 345 switch ( ePres ) 346 { 347 case SFX_ITEM_PRESENTATION_NONE: 348 rText.Erase(); 349 break; 350 351 case SFX_ITEM_PRESENTATION_NAMELESS: 352 rText = GetValueText(); 353 break; 354 355 case SFX_ITEM_PRESENTATION_COMPLETE: 356 rText = ScGlobal::GetRscString(STR_PROTECTION); rText += aStrSep; 357 rText += (bProtection ? aStrYes : aStrNo); rText += aStrDelim; 358 rText += ScGlobal::GetRscString(STR_FORMULAS); rText += aStrSep; 359 rText += (!bHideFormula ? aStrYes : aStrNo); rText += aStrDelim; 360 rText += ScGlobal::GetRscString(STR_HIDE); rText += aStrSep; 361 rText += (bHideCell ? aStrYes : aStrNo); rText += aStrDelim; 362 rText += ScGlobal::GetRscString(STR_PRINT); rText += aStrSep; 363 rText += (!bHidePrint ? aStrYes : aStrNo); 364 break; 365 366 default: 367 ePres = SFX_ITEM_PRESENTATION_NONE; 368 } 369 370 return ePres; 371 } 372 373 //------------------------------------------------------------------------ 374 375 int ScProtectionAttr::operator==( const SfxPoolItem& rItem ) const 376 { 377 DBG_ASSERT( Which() != rItem.Which() || Type() == rItem.Type(), "which ==, type !=" ); 378 return (Which() == rItem.Which()) 379 && (bProtection == ((ScProtectionAttr&)rItem).bProtection) 380 && (bHideFormula == ((ScProtectionAttr&)rItem).bHideFormula) 381 && (bHideCell == ((ScProtectionAttr&)rItem).bHideCell) 382 && (bHidePrint == ((ScProtectionAttr&)rItem).bHidePrint); 383 } 384 385 //------------------------------------------------------------------------ 386 387 SfxPoolItem* ScProtectionAttr::Clone( SfxItemPool * ) const 388 { 389 return new ScProtectionAttr(*this); 390 } 391 392 //------------------------------------------------------------------------ 393 394 SfxPoolItem* ScProtectionAttr::Create( SvStream& rStream, sal_uInt16 /* n */ ) const 395 { 396 sal_Bool bProtect; 397 sal_Bool bHFormula; 398 sal_Bool bHCell; 399 sal_Bool bHPrint; 400 401 rStream >> bProtect; 402 rStream >> bHFormula; 403 rStream >> bHCell; 404 rStream >> bHPrint; 405 406 return new ScProtectionAttr(bProtect,bHFormula,bHCell,bHPrint); 407 } 408 409 //------------------------------------------------------------------------ 410 411 sal_Bool ScProtectionAttr::SetProtection( sal_Bool bProtect) 412 { 413 bProtection = bProtect; 414 return sal_True; 415 } 416 417 //------------------------------------------------------------------------ 418 419 sal_Bool ScProtectionAttr::SetHideFormula( sal_Bool bHFormula) 420 { 421 bHideFormula = bHFormula; 422 return sal_True; 423 } 424 425 //------------------------------------------------------------------------ 426 427 sal_Bool ScProtectionAttr::SetHideCell( sal_Bool bHCell) 428 { 429 bHideCell = bHCell; 430 return sal_True; 431 } 432 433 //------------------------------------------------------------------------ 434 435 sal_Bool ScProtectionAttr::SetHidePrint( sal_Bool bHPrint) 436 { 437 bHidePrint = bHPrint; 438 return sal_True; 439 } 440 441 // ----------------------------------------------------------------------- 442 // ScRangeItem - Tabellenbereich 443 // ----------------------------------------------------------------------- 444 445 int ScRangeItem::operator==( const SfxPoolItem& rAttr ) const 446 { 447 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 448 449 return ( aRange == ( (ScRangeItem&)rAttr ).aRange ); 450 } 451 452 // ----------------------------------------------------------------------- 453 454 SfxPoolItem* ScRangeItem::Clone( SfxItemPool* ) const 455 { 456 return new ScRangeItem( *this ); 457 } 458 459 //------------------------------------------------------------------------ 460 461 SfxItemPresentation ScRangeItem::GetPresentation 462 ( 463 SfxItemPresentation ePres, 464 SfxMapUnit /* eCoreUnit */, 465 SfxMapUnit /* ePresUnit */, 466 String& rText, 467 const IntlWrapper* /* pIntl */ 468 ) const 469 { 470 rText.Erase(); 471 472 switch ( ePres ) 473 { 474 case SFX_ITEM_PRESENTATION_COMPLETE: 475 rText = ScGlobal::GetRscString(STR_AREA); 476 rText.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ": " )); 477 // break;// Durchfallen !!! 478 479 case SFX_ITEM_PRESENTATION_NAMELESS: 480 { 481 String aText; 482 /* Always use OOo:A1 format */ 483 aRange.Format( aText ); 484 rText += aText; 485 } 486 break; 487 488 default: 489 { 490 // added to avoid warnings 491 } 492 } 493 494 return ePres; 495 } 496 497 // ----------------------------------------------------------------------- 498 // ScTableListItem - Liste von Tabellen(-nummern) 499 // ----------------------------------------------------------------------- 500 501 ScTableListItem::ScTableListItem( const ScTableListItem& rCpy ) 502 : SfxPoolItem ( rCpy.Which() ), 503 nCount ( rCpy.nCount ) 504 { 505 if ( nCount > 0 ) 506 { 507 pTabArr = new SCTAB [nCount]; 508 509 for ( sal_uInt16 i=0; i<nCount; i++ ) 510 pTabArr[i] = rCpy.pTabArr[i]; 511 } 512 else 513 pTabArr = NULL; 514 } 515 516 // ----------------------------------------------------------------------- 517 518 //UNUSED2008-05 ScTableListItem::ScTableListItem( const sal_uInt16 nWhichP, const List& rList ) 519 //UNUSED2008-05 : SfxPoolItem ( nWhichP ), 520 //UNUSED2008-05 nCount ( 0 ), 521 //UNUSED2008-05 pTabArr ( NULL ) 522 //UNUSED2008-05 { 523 //UNUSED2008-05 SetTableList( rList ); 524 //UNUSED2008-05 } 525 526 // ----------------------------------------------------------------------- 527 528 ScTableListItem::~ScTableListItem() 529 { 530 delete [] pTabArr; 531 } 532 533 // ----------------------------------------------------------------------- 534 535 ScTableListItem& ScTableListItem::operator=( const ScTableListItem& rCpy ) 536 { 537 delete [] pTabArr; 538 539 if ( rCpy.nCount > 0 ) 540 { 541 pTabArr = new SCTAB [rCpy.nCount]; 542 for ( sal_uInt16 i=0; i<rCpy.nCount; i++ ) 543 pTabArr[i] = rCpy.pTabArr[i]; 544 } 545 else 546 pTabArr = NULL; 547 548 nCount = rCpy.nCount; 549 550 return *this; 551 } 552 553 // ----------------------------------------------------------------------- 554 555 int ScTableListItem::operator==( const SfxPoolItem& rAttr ) const 556 { 557 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); 558 559 ScTableListItem& rCmp = (ScTableListItem&)rAttr; 560 sal_Bool bEqual = (nCount == rCmp.nCount); 561 562 if ( nCount > 0 ) 563 { 564 sal_uInt16 i=0; 565 566 bEqual = ( pTabArr && rCmp.pTabArr ); 567 568 while ( bEqual && i<nCount ) 569 { 570 bEqual = ( pTabArr[i] == rCmp.pTabArr[i] ); 571 i++; 572 } 573 } 574 return bEqual; 575 } 576 577 // ----------------------------------------------------------------------- 578 579 SfxPoolItem* ScTableListItem::Clone( SfxItemPool* ) const 580 { 581 return new ScTableListItem( *this ); 582 } 583 584 //------------------------------------------------------------------------ 585 586 SfxItemPresentation ScTableListItem::GetPresentation 587 ( 588 SfxItemPresentation ePres, 589 SfxMapUnit /* eCoreUnit */, 590 SfxMapUnit /* ePresUnit */, 591 String& rText, 592 const IntlWrapper* /* pIntl */ 593 ) const 594 { 595 const sal_Unicode cDelim = ','; 596 597 switch ( ePres ) 598 { 599 case SFX_ITEM_PRESENTATION_NONE: 600 rText.Erase(); 601 return ePres; 602 603 case SFX_ITEM_PRESENTATION_NAMELESS: 604 { 605 rText = '('; 606 if ( nCount>0 && pTabArr ) 607 for ( sal_uInt16 i=0; i<nCount; i++ ) 608 { 609 rText += String::CreateFromInt32( pTabArr[i] ); 610 if ( i<(nCount-1) ) 611 rText += cDelim; 612 } 613 rText += ')'; 614 } 615 return ePres; 616 617 case SFX_ITEM_PRESENTATION_COMPLETE: 618 rText.Erase(); 619 return SFX_ITEM_PRESENTATION_NONE; 620 621 default: 622 { 623 // added to avoid warnings 624 } 625 } 626 627 return SFX_ITEM_PRESENTATION_NONE; 628 } 629 630 // ----------------------------------------------------------------------- 631 632 //UNUSED2009-05 sal_Bool ScTableListItem::GetTableList( List& aList ) const 633 //UNUSED2009-05 { 634 //UNUSED2009-05 for ( sal_uInt16 i=0; i<nCount; i++ ) 635 //UNUSED2009-05 aList.Insert( new SCTAB( pTabArr[i] ) ); 636 //UNUSED2009-05 637 //UNUSED2009-05 return ( nCount > 0 ); 638 //UNUSED2009-05 } 639 640 // ----------------------------------------------------------------------- 641 642 //UNUSED2009-05 void ScTableListItem::SetTableList( const List& rList ) 643 //UNUSED2009-05 { 644 //UNUSED2009-05 nCount = (sal_uInt16)rList.Count(); 645 //UNUSED2009-05 646 //UNUSED2009-05 delete [] pTabArr; 647 //UNUSED2009-05 648 //UNUSED2009-05 if ( nCount > 0 ) 649 //UNUSED2009-05 { 650 //UNUSED2009-05 pTabArr = new SCTAB [nCount]; 651 //UNUSED2009-05 652 //UNUSED2009-05 for ( sal_uInt16 i=0; i<nCount; i++ ) 653 //UNUSED2009-05 pTabArr[i] = *( (SCTAB*)rList.GetObject( i ) ); 654 //UNUSED2009-05 } 655 //UNUSED2009-05 else 656 //UNUSED2009-05 pTabArr = NULL; 657 //UNUSED2009-05 } 658 659 660 // ----------------------------------------------------------------------- 661 // ScPageHFItem - Daten der Kopf-/Fusszeilen 662 // ----------------------------------------------------------------------- 663 664 ScPageHFItem::ScPageHFItem( sal_uInt16 nWhichP ) 665 : SfxPoolItem ( nWhichP ), 666 pLeftArea ( NULL ), 667 pCenterArea ( NULL ), 668 pRightArea ( NULL ) 669 { 670 } 671 672 //------------------------------------------------------------------------ 673 674 ScPageHFItem::ScPageHFItem( const ScPageHFItem& rItem ) 675 : SfxPoolItem ( rItem ), 676 pLeftArea ( NULL ), 677 pCenterArea ( NULL ), 678 pRightArea ( NULL ) 679 { 680 if ( rItem.pLeftArea ) 681 pLeftArea = rItem.pLeftArea->Clone(); 682 if ( rItem.pCenterArea ) 683 pCenterArea = rItem.pCenterArea->Clone(); 684 if ( rItem.pRightArea ) 685 pRightArea = rItem.pRightArea->Clone(); 686 } 687 688 //------------------------------------------------------------------------ 689 690 ScPageHFItem::~ScPageHFItem() 691 { 692 delete pLeftArea; 693 delete pCenterArea; 694 delete pRightArea; 695 } 696 697 //------------------------------------------------------------------------ 698 699 sal_Bool ScPageHFItem::QueryValue( uno::Any& rVal, sal_uInt8 /* nMemberId */ ) const 700 { 701 uno::Reference<sheet::XHeaderFooterContent> xContent = 702 new ScHeaderFooterContentObj( pLeftArea, pCenterArea, pRightArea ); 703 704 rVal <<= xContent; 705 return sal_True; 706 } 707 708 sal_Bool ScPageHFItem::PutValue( const uno::Any& rVal, sal_uInt8 /* nMemberId */ ) 709 { 710 sal_Bool bRet = sal_False; 711 uno::Reference<sheet::XHeaderFooterContent> xContent; 712 if ( rVal >>= xContent ) 713 { 714 if ( xContent.is() ) 715 { 716 ScHeaderFooterContentObj* pImp = 717 ScHeaderFooterContentObj::getImplementation( xContent ); 718 if (pImp) 719 { 720 const EditTextObject* pImpLeft = pImp->GetLeftEditObject(); 721 delete pLeftArea; 722 pLeftArea = pImpLeft ? pImpLeft->Clone() : NULL; 723 724 const EditTextObject* pImpCenter = pImp->GetCenterEditObject(); 725 delete pCenterArea; 726 pCenterArea = pImpCenter ? pImpCenter->Clone() : NULL; 727 728 const EditTextObject* pImpRight = pImp->GetRightEditObject(); 729 delete pRightArea; 730 pRightArea = pImpRight ? pImpRight->Clone() : NULL; 731 732 if ( !pLeftArea || !pCenterArea || !pRightArea ) 733 { 734 // keine Texte auf NULL stehen lassen 735 ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), sal_True ); 736 if (!pLeftArea) 737 pLeftArea = aEngine.CreateTextObject(); 738 if (!pCenterArea) 739 pCenterArea = aEngine.CreateTextObject(); 740 if (!pRightArea) 741 pRightArea = aEngine.CreateTextObject(); 742 } 743 744 bRet = sal_True; 745 } 746 } 747 } 748 749 if (!bRet) 750 { 751 DBG_ERROR("exception - wrong argument"); 752 } 753 754 return bRet; 755 } 756 757 //------------------------------------------------------------------------ 758 759 String ScPageHFItem::GetValueText() const 760 { 761 return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScPageHFItem")); 762 } 763 764 //------------------------------------------------------------------------ 765 766 int ScPageHFItem::operator==( const SfxPoolItem& rItem ) const 767 { 768 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" ); 769 770 const ScPageHFItem& r = (const ScPageHFItem&)rItem; 771 772 return ScGlobal::EETextObjEqual(pLeftArea, r.pLeftArea) 773 && ScGlobal::EETextObjEqual(pCenterArea, r.pCenterArea) 774 && ScGlobal::EETextObjEqual(pRightArea, r.pRightArea); 775 } 776 777 //------------------------------------------------------------------------ 778 779 SfxPoolItem* ScPageHFItem::Clone( SfxItemPool* ) const 780 { 781 return new ScPageHFItem( *this ); 782 } 783 784 //------------------------------------------------------------------------ 785 786 void lcl_SetSpace( String& rStr, const ESelection& rSel ) 787 { 788 // Text durch ein Leerzeichen ersetzen, damit Positionen stimmen: 789 790 xub_StrLen nLen = rSel.nEndPos-rSel.nStartPos; 791 rStr.Erase( rSel.nStartPos, nLen-1 ); 792 rStr.SetChar( rSel.nStartPos, ' ' ); 793 } 794 795 sal_Bool lcl_ConvertFields(EditEngine& rEng, const String* pCommands) 796 { 797 sal_Bool bChange = sal_False; 798 sal_uInt32 nParCnt = rEng.GetParagraphCount(); 799 for (sal_uInt32 nPar = 0; nPar<nParCnt; nPar++) 800 { 801 String aStr = rEng.GetText( nPar ); 802 xub_StrLen nPos; 803 804 while ((nPos = aStr.Search(pCommands[0])) != STRING_NOTFOUND) 805 { 806 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[0].Len() ); 807 rEng.QuickInsertField( SvxFieldItem(SvxPageField(), EE_FEATURE_FIELD), aSel ); 808 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 809 } 810 while ((nPos = aStr.Search(pCommands[1])) != STRING_NOTFOUND) 811 { 812 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[1].Len() ); 813 rEng.QuickInsertField( SvxFieldItem(SvxPagesField(), EE_FEATURE_FIELD), aSel ); 814 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 815 } 816 while ((nPos = aStr.Search(pCommands[2])) != STRING_NOTFOUND) 817 { 818 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[2].Len() ); 819 rEng.QuickInsertField( SvxFieldItem(SvxDateField(Date(),SVXDATETYPE_VAR), EE_FEATURE_FIELD), aSel ); 820 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 821 } 822 while ((nPos = aStr.Search(pCommands[3])) != STRING_NOTFOUND) 823 { 824 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[3].Len() ); 825 rEng.QuickInsertField( SvxFieldItem(SvxTimeField(), EE_FEATURE_FIELD ), aSel ); 826 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 827 } 828 while ((nPos = aStr.Search(pCommands[4])) != STRING_NOTFOUND) 829 { 830 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[4].Len() ); 831 rEng.QuickInsertField( SvxFieldItem(SvxFileField(), EE_FEATURE_FIELD), aSel ); 832 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 833 } 834 while ((nPos = aStr.Search(pCommands[5])) != STRING_NOTFOUND) 835 { 836 ESelection aSel( nPar,nPos, nPar,nPos+pCommands[5].Len() ); 837 rEng.QuickInsertField( SvxFieldItem(SvxTableField(), EE_FEATURE_FIELD), aSel ); 838 lcl_SetSpace(aStr, aSel ); bChange = sal_True; 839 } 840 } 841 return bChange; 842 } 843 844 #define SC_FIELD_COUNT 6 845 846 SfxPoolItem* ScPageHFItem::Create( SvStream& rStream, sal_uInt16 nVer ) const 847 { 848 EditTextObject* pLeft = EditTextObject::Create(rStream); 849 EditTextObject* pCenter = EditTextObject::Create(rStream); 850 EditTextObject* pRight = EditTextObject::Create(rStream); 851 852 DBG_ASSERT( pLeft && pCenter && pRight, "Error reading ScPageHFItem" ); 853 854 if ( pLeft == NULL || pLeft->GetParagraphCount() == 0 || 855 pCenter == NULL || pCenter->GetParagraphCount() == 0 || 856 pRight == NULL || pRight->GetParagraphCount() == 0 ) 857 { 858 // If successfully loaded, each object contains at least one paragraph. 859 // Excel import in 5.1 created broken TextObjects (#67442#) that are 860 // corrected here to avoid saving wrong files again (#90487#). 861 862 ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), sal_True ); 863 if ( pLeft == NULL || pLeft->GetParagraphCount() == 0 ) 864 { 865 delete pLeft; 866 pLeft = aEngine.CreateTextObject(); 867 } 868 if ( pCenter == NULL || pCenter->GetParagraphCount() == 0 ) 869 { 870 delete pCenter; 871 pCenter = aEngine.CreateTextObject(); 872 } 873 if ( pRight == NULL || pRight->GetParagraphCount() == 0 ) 874 { 875 delete pRight; 876 pRight = aEngine.CreateTextObject(); 877 } 878 } 879 880 if ( nVer < 1 ) // alte Feldbefehle umsetzen 881 { 882 sal_uInt16 i; 883 const String& rDel = ScGlobal::GetRscString( STR_HFCMD_DELIMITER ); 884 String aCommands[SC_FIELD_COUNT]; 885 for (i=0; i<SC_FIELD_COUNT; i++) 886 aCommands[i] = rDel; 887 aCommands[0] += ScGlobal::GetRscString(STR_HFCMD_PAGE); 888 aCommands[1] += ScGlobal::GetRscString(STR_HFCMD_PAGES); 889 aCommands[2] += ScGlobal::GetRscString(STR_HFCMD_DATE); 890 aCommands[3] += ScGlobal::GetRscString(STR_HFCMD_TIME); 891 aCommands[4] += ScGlobal::GetRscString(STR_HFCMD_FILE); 892 aCommands[5] += ScGlobal::GetRscString(STR_HFCMD_TABLE); 893 for (i=0; i<SC_FIELD_COUNT; i++) 894 aCommands[i] += rDel; 895 896 ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), sal_True ); 897 aEngine.SetText(*pLeft); 898 if (lcl_ConvertFields(aEngine,aCommands)) 899 { 900 delete pLeft; 901 pLeft = aEngine.CreateTextObject(); 902 } 903 aEngine.SetText(*pCenter); 904 if (lcl_ConvertFields(aEngine,aCommands)) 905 { 906 delete pCenter; 907 pCenter = aEngine.CreateTextObject(); 908 } 909 aEngine.SetText(*pRight); 910 if (lcl_ConvertFields(aEngine,aCommands)) 911 { 912 delete pRight; 913 pRight = aEngine.CreateTextObject(); 914 } 915 } 916 else if ( nVer < 2 ) 917 { // nichts tun, SvxFileField nicht gegen SvxExtFileField austauschen 918 } 919 920 ScPageHFItem* pItem = new ScPageHFItem( Which() ); 921 pItem->SetArea( pLeft, SC_HF_LEFTAREA ); 922 pItem->SetArea( pCenter, SC_HF_CENTERAREA ); 923 pItem->SetArea( pRight, SC_HF_RIGHTAREA ); 924 925 return pItem; 926 } 927 928 //------------------------------------------------------------------------ 929 930 //UNUSED2009-05 class ScFieldChangerEditEngine : public ScEditEngineDefaulter 931 //UNUSED2009-05 { 932 //UNUSED2009-05 TypeId aExtFileId; 933 //UNUSED2009-05 sal_uInt16 nConvPara; 934 //UNUSED2009-05 xub_StrLen nConvPos; 935 //UNUSED2009-05 sal_Bool bConvert; 936 //UNUSED2009-05 937 //UNUSED2009-05 public: 938 //UNUSED2009-05 ScFieldChangerEditEngine( SfxItemPool* pEnginePool, sal_Bool bDeleteEnginePool ); 939 //UNUSED2009-05 virtual ~ScFieldChangerEditEngine() {} 940 //UNUSED2009-05 941 //UNUSED2009-05 virtual String CalcFieldValue( const SvxFieldItem& rField, sal_uInt16 nPara, 942 //UNUSED2009-05 sal_uInt16 nPos, Color*& rTxtColor, 943 //UNUSED2009-05 Color*& rFldColor ); 944 //UNUSED2009-05 945 //UNUSED2009-05 sal_Bool ConvertFields(); 946 //UNUSED2009-05 }; 947 //UNUSED2009-05 948 //UNUSED2009-05 ScFieldChangerEditEngine::ScFieldChangerEditEngine( SfxItemPool* pEnginePoolP, 949 //UNUSED2009-05 sal_Bool bDeleteEnginePoolP ) : 950 //UNUSED2009-05 ScEditEngineDefaulter( pEnginePoolP, bDeleteEnginePoolP ), 951 //UNUSED2009-05 aExtFileId( TYPE( SvxExtFileField ) ), 952 //UNUSED2009-05 nConvPara( 0 ), 953 //UNUSED2009-05 nConvPos( 0 ), 954 //UNUSED2009-05 bConvert( sal_False ) 955 //UNUSED2009-05 { 956 //UNUSED2009-05 } 957 //UNUSED2009-05 958 //UNUSED2009-05 String ScFieldChangerEditEngine::CalcFieldValue( const SvxFieldItem& rField, 959 //UNUSED2009-05 sal_uInt16 nPara, sal_uInt16 nPos, Color*& /* rTxtColor */, Color*& /* rFldColor */ ) 960 //UNUSED2009-05 { 961 //UNUSED2009-05 const SvxFieldData* pFieldData = rField.GetField(); 962 //UNUSED2009-05 if ( pFieldData && pFieldData->Type() == aExtFileId ) 963 //UNUSED2009-05 { 964 //UNUSED2009-05 bConvert = sal_True; 965 //UNUSED2009-05 nConvPara = nPara; 966 //UNUSED2009-05 nConvPos = nPos; 967 //UNUSED2009-05 } 968 //UNUSED2009-05 return EMPTY_STRING; 969 //UNUSED2009-05 } 970 //UNUSED2009-05 971 //UNUSED2009-05 sal_Bool ScFieldChangerEditEngine::ConvertFields() 972 //UNUSED2009-05 { 973 //UNUSED2009-05 sal_Bool bConverted = sal_False; 974 //UNUSED2009-05 do 975 //UNUSED2009-05 { 976 //UNUSED2009-05 bConvert = sal_False; 977 //UNUSED2009-05 UpdateFields(); 978 //UNUSED2009-05 if ( bConvert ) 979 //UNUSED2009-05 { 980 //UNUSED2009-05 ESelection aSel( nConvPara, nConvPos, nConvPara, nConvPos+1 ); 981 //UNUSED2009-05 QuickInsertField( SvxFieldItem( SvxFileField(), EE_FEATURE_FIELD), aSel ); 982 //UNUSED2009-05 bConverted = sal_True; 983 //UNUSED2009-05 } 984 //UNUSED2009-05 } while ( bConvert ); 985 //UNUSED2009-05 return bConverted; 986 //UNUSED2009-05 } 987 988 void ScPageHFItem::SetLeftArea( const EditTextObject& rNew ) 989 { 990 delete pLeftArea; 991 pLeftArea = rNew.Clone(); 992 } 993 994 //------------------------------------------------------------------------ 995 996 void ScPageHFItem::SetCenterArea( const EditTextObject& rNew ) 997 { 998 delete pCenterArea; 999 pCenterArea = rNew.Clone(); 1000 } 1001 1002 //------------------------------------------------------------------------ 1003 1004 void ScPageHFItem::SetRightArea( const EditTextObject& rNew ) 1005 { 1006 delete pRightArea; 1007 pRightArea = rNew.Clone(); 1008 } 1009 1010 void ScPageHFItem::SetArea( EditTextObject *pNew, int nArea ) 1011 { 1012 switch ( nArea ) 1013 { 1014 case SC_HF_LEFTAREA: delete pLeftArea; pLeftArea = pNew; break; 1015 case SC_HF_CENTERAREA: delete pCenterArea; pCenterArea = pNew; break; 1016 case SC_HF_RIGHTAREA: delete pRightArea; pRightArea = pNew; break; 1017 default: 1018 DBG_ERROR( "New Area?" ); 1019 } 1020 } 1021 1022 //----------------------------------------------------------------------- 1023 // ScViewObjectModeItem - Darstellungsmodus von ViewObjekten 1024 //----------------------------------------------------------------------- 1025 1026 ScViewObjectModeItem::ScViewObjectModeItem( sal_uInt16 nWhichP ) 1027 : SfxEnumItem( nWhichP, VOBJ_MODE_SHOW ) 1028 { 1029 } 1030 1031 //------------------------------------------------------------------------ 1032 1033 ScViewObjectModeItem::ScViewObjectModeItem( sal_uInt16 nWhichP, ScVObjMode eMode ) 1034 : SfxEnumItem( nWhichP, sal::static_int_cast<sal_uInt16>(eMode) ) 1035 { 1036 } 1037 1038 //------------------------------------------------------------------------ 1039 1040 ScViewObjectModeItem::~ScViewObjectModeItem() 1041 { 1042 } 1043 1044 //------------------------------------------------------------------------ 1045 1046 SfxItemPresentation ScViewObjectModeItem::GetPresentation 1047 ( 1048 SfxItemPresentation ePres, 1049 SfxMapUnit /* eCoreUnit */, 1050 SfxMapUnit /* ePresUnit */, 1051 String& rText, 1052 const IntlWrapper* /* pIntl */ 1053 ) const 1054 { 1055 String aDel = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(": ")); 1056 rText.Erase(); 1057 1058 switch ( ePres ) 1059 { 1060 case SFX_ITEM_PRESENTATION_COMPLETE: 1061 switch( Which() ) 1062 { 1063 case SID_SCATTR_PAGE_CHARTS: 1064 rText = ScGlobal::GetRscString(STR_VOBJ_CHART); 1065 rText += aDel; 1066 break; 1067 1068 case SID_SCATTR_PAGE_OBJECTS: 1069 rText = ScGlobal::GetRscString(STR_VOBJ_OBJECT); 1070 rText += aDel; 1071 break; 1072 1073 case SID_SCATTR_PAGE_DRAWINGS: 1074 rText = ScGlobal::GetRscString(STR_VOBJ_DRAWINGS); 1075 rText += aDel; 1076 break; 1077 1078 default: 1079 ePres = SFX_ITEM_PRESENTATION_NAMELESS;//das geht immer! 1080 break; 1081 } 1082 // break; // DURCHFALLEN!!! 1083 1084 case SFX_ITEM_PRESENTATION_NAMELESS: 1085 rText += ScGlobal::GetRscString(STR_VOBJ_MODE_SHOW+GetValue()); 1086 break; 1087 1088 default: 1089 { 1090 // added to avoid warnings 1091 } 1092 } 1093 1094 return ePres; 1095 } 1096 1097 //------------------------------------------------------------------------ 1098 1099 String ScViewObjectModeItem::GetValueText( sal_uInt16 nVal ) const 1100 { 1101 DBG_ASSERT( nVal <= VOBJ_MODE_HIDE, "enum overflow!" ); 1102 1103 return ScGlobal::GetRscString( STR_VOBJ_MODE_SHOW + (nVal % 2)); 1104 } 1105 1106 //------------------------------------------------------------------------ 1107 1108 sal_uInt16 ScViewObjectModeItem::GetValueCount() const 1109 { 1110 return 2; 1111 } 1112 1113 //------------------------------------------------------------------------ 1114 1115 SfxPoolItem* ScViewObjectModeItem::Clone( SfxItemPool* ) const 1116 { 1117 return new ScViewObjectModeItem( *this ); 1118 } 1119 1120 //------------------------------------------------------------------------ 1121 1122 sal_uInt16 ScViewObjectModeItem::GetVersion( sal_uInt16 /* nFileVersion */ ) const 1123 { 1124 return 1; 1125 } 1126 1127 //------------------------------------------------------------------------ 1128 1129 SfxPoolItem* ScViewObjectModeItem::Create( 1130 SvStream& rStream, 1131 sal_uInt16 nVersion ) const 1132 { 1133 if ( nVersion == 0 ) 1134 { 1135 // alte Version mit AllEnumItem -> mit Mode "Show" erzeugen 1136 return new ScViewObjectModeItem( Which() ); 1137 } 1138 else 1139 { 1140 sal_uInt16 nVal; 1141 rStream >> nVal; 1142 1143 //#i80528# adapt to new range eventually 1144 if((sal_uInt16)VOBJ_MODE_HIDE < nVal) nVal = (sal_uInt16)VOBJ_MODE_SHOW; 1145 1146 return new ScViewObjectModeItem( Which(), (ScVObjMode)nVal); 1147 } 1148 } 1149 1150 // ----------------------------------------------------------------------- 1151 // double 1152 // ----------------------------------------------------------------------- 1153 1154 ScDoubleItem::ScDoubleItem( sal_uInt16 nWhichP, double nVal ) 1155 : SfxPoolItem ( nWhichP ), 1156 nValue ( nVal ) 1157 { 1158 } 1159 1160 //------------------------------------------------------------------------ 1161 1162 ScDoubleItem::ScDoubleItem( const ScDoubleItem& rItem ) 1163 : SfxPoolItem ( rItem ) 1164 { 1165 nValue = rItem.nValue; 1166 } 1167 1168 //------------------------------------------------------------------------ 1169 1170 String ScDoubleItem::GetValueText() const 1171 { 1172 return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScDoubleItem")); 1173 } 1174 1175 //------------------------------------------------------------------------ 1176 1177 int ScDoubleItem::operator==( const SfxPoolItem& rItem ) const 1178 { 1179 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" ); 1180 const ScDoubleItem& _rItem = (const ScDoubleItem&)rItem; 1181 return int(nValue == _rItem.nValue); 1182 //int(nValue == ((const ScDoubleItem&)rItem).nValue); 1183 } 1184 1185 //------------------------------------------------------------------------ 1186 1187 SfxPoolItem* ScDoubleItem::Clone( SfxItemPool* ) const 1188 { 1189 return new ScDoubleItem( *this ); 1190 } 1191 1192 //------------------------------------------------------------------------ 1193 1194 SfxPoolItem* ScDoubleItem::Create( SvStream& rStream, sal_uInt16 /* nVer */ ) const 1195 { 1196 double nTmp=0; 1197 rStream >> nTmp; 1198 1199 ScDoubleItem* pItem = new ScDoubleItem( Which(), nTmp ); 1200 1201 return pItem; 1202 } 1203 1204 //------------------------------------------------------------------------ 1205 1206 ScDoubleItem::~ScDoubleItem() 1207 { 1208 } 1209 1210 1211 // ============================================================================ 1212 1213 ScPageScaleToItem::ScPageScaleToItem() : 1214 SfxPoolItem( ATTR_PAGE_SCALETO ), 1215 mnWidth( 0 ), 1216 mnHeight( 0 ) 1217 { 1218 } 1219 1220 ScPageScaleToItem::ScPageScaleToItem( sal_uInt16 nWidth, sal_uInt16 nHeight ) : 1221 SfxPoolItem( ATTR_PAGE_SCALETO ), 1222 mnWidth( nWidth ), 1223 mnHeight( nHeight ) 1224 { 1225 } 1226 1227 ScPageScaleToItem::~ScPageScaleToItem() 1228 { 1229 } 1230 1231 ScPageScaleToItem* ScPageScaleToItem::Clone( SfxItemPool* ) const 1232 { 1233 return new ScPageScaleToItem( *this ); 1234 } 1235 1236 int ScPageScaleToItem::operator==( const SfxPoolItem& rCmp ) const 1237 { 1238 DBG_ASSERT( SfxPoolItem::operator==( rCmp ), "ScPageScaleToItem::operator== - unequal wid or type" ); 1239 const ScPageScaleToItem& rPageCmp = static_cast< const ScPageScaleToItem& >( rCmp ); 1240 return ((mnWidth == rPageCmp.mnWidth) && (mnHeight == rPageCmp.mnHeight)) ? 1 : 0; 1241 } 1242 1243 namespace { 1244 void lclAppendScalePageCount( String& rText, sal_uInt16 nPages ) 1245 { 1246 rText.AppendAscii( ": " ); 1247 if( nPages ) 1248 { 1249 String aPages( ScGlobal::GetRscString( STR_SCATTR_PAGE_SCALE_PAGES ) ); 1250 aPages.SearchAndReplaceAscii( "%1", String::CreateFromInt32( nPages ) ); 1251 rText.Append( aPages ); 1252 } 1253 else 1254 rText.Append( ScGlobal::GetRscString( STR_SCATTR_PAGE_SCALE_AUTO ) ); 1255 } 1256 } // namespace 1257 1258 SfxItemPresentation ScPageScaleToItem::GetPresentation( 1259 SfxItemPresentation ePres, SfxMapUnit, SfxMapUnit, XubString& rText, const IntlWrapper* ) const 1260 { 1261 rText.Erase(); 1262 if( !IsValid() || (ePres == SFX_ITEM_PRESENTATION_NONE) ) 1263 return SFX_ITEM_PRESENTATION_NONE; 1264 1265 String aName( ScGlobal::GetRscString( STR_SCATTR_PAGE_SCALETO ) ); 1266 String aValue( ScGlobal::GetRscString( STR_SCATTR_PAGE_SCALE_WIDTH ) ); 1267 lclAppendScalePageCount( aValue, mnWidth ); 1268 aValue.AppendAscii( ", " ).Append( ScGlobal::GetRscString( STR_SCATTR_PAGE_SCALE_HEIGHT ) ); 1269 lclAppendScalePageCount( aValue, mnHeight ); 1270 1271 switch( ePres ) 1272 { 1273 case SFX_ITEM_PRESENTATION_NONE: 1274 break; 1275 1276 case SFX_ITEM_PRESENTATION_NAMEONLY: 1277 rText = aName; 1278 break; 1279 1280 case SFX_ITEM_PRESENTATION_NAMELESS: 1281 rText = aValue; 1282 break; 1283 1284 case SFX_ITEM_PRESENTATION_COMPLETE: 1285 rText.Assign( aName ).AppendAscii( " (" ).Append( aValue ).Append( ')' ); 1286 break; 1287 1288 default: 1289 DBG_ERRORFILE( "ScPageScaleToItem::GetPresentation - unknown presentation mode" ); 1290 ePres = SFX_ITEM_PRESENTATION_NONE; 1291 } 1292 return ePres; 1293 } 1294 1295 sal_Bool ScPageScaleToItem::QueryValue( uno::Any& rAny, sal_uInt8 nMemberId ) const 1296 { 1297 sal_Bool bRet = sal_True; 1298 switch( nMemberId ) 1299 { 1300 case SC_MID_PAGE_SCALETO_WIDTH: rAny <<= mnWidth; break; 1301 case SC_MID_PAGE_SCALETO_HEIGHT: rAny <<= mnHeight; break; 1302 default: 1303 DBG_ERRORFILE( "ScPageScaleToItem::QueryValue - unknown member ID" ); 1304 bRet = sal_False; 1305 } 1306 return bRet; 1307 } 1308 1309 sal_Bool ScPageScaleToItem::PutValue( const uno::Any& rAny, sal_uInt8 nMemberId ) 1310 { 1311 sal_Bool bRet = sal_False; 1312 switch( nMemberId ) 1313 { 1314 case SC_MID_PAGE_SCALETO_WIDTH: bRet = rAny >>= mnWidth; break; 1315 case SC_MID_PAGE_SCALETO_HEIGHT: bRet = rAny >>= mnHeight; break; 1316 default: 1317 DBG_ERRORFILE( "ScPageScaleToItem::PutValue - unknown member ID" ); 1318 } 1319 return bRet; 1320 } 1321 1322 // ============================================================================ 1323 1324 1325