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_sd.hxx" 26 27 #include <algorithm> 28 29 #include <comphelper/classids.hxx> 30 31 #include <vcl/svapp.hxx> 32 #include "eetext.hxx" 33 #include <editeng/eeitem.hxx> 34 #include <svx/svdoutl.hxx> 35 #include <editeng/editdata.hxx> 36 #include <svx/pageitem.hxx> 37 #include <editeng/lrspitem.hxx> 38 #include <editeng/bulitem.hxx> 39 #include <svx/svdpagv.hxx> 40 #include <editeng/fhgtitem.hxx> 41 #include <editeng/outlobj.hxx> 42 #include <svx/svdoole2.hxx> 43 #include <svx/svdograf.hxx> 44 #include <svx/svdopage.hxx> 45 #include <svx/svdopage.hxx> 46 #include <sfx2/printer.hxx> 47 #include <basic/basmgr.hxx> 48 #include <editeng/pbinitem.hxx> 49 #include <svx/svdundo.hxx> 50 #include <svl/smplhint.hxx> 51 #include <editeng/adjitem.hxx> 52 #include <editeng/editobj.hxx> 53 #ifndef _SVX_SRIPTTYPEITEM_HXX 54 #include <editeng/scripttypeitem.hxx> 55 #endif 56 #include <svx/unopage.hxx> 57 #include <editeng/flditem.hxx> 58 #include <svx/sdr/contact/displayinfo.hxx> 59 #include <svx/svditer.hxx> 60 61 #include <editeng/adjitem.hxx> 62 63 #include "../ui/inc/DrawDocShell.hxx" 64 #include "Outliner.hxx" 65 #include "app.hrc" 66 #include "misc.hxx" 67 #include "eetext.hxx" 68 #include "drawdoc.hxx" 69 #include "sdpage.hxx" 70 #include "pglink.hxx" 71 #include "sdresid.hxx" 72 #include "stlsheet.hxx" 73 #include "glob.hrc" 74 #include "glob.hxx" 75 #include "helpids.h" 76 #include "anminfo.hxx" 77 #include "undo/undomanager.hxx" 78 #include "undo/undoobjects.hxx" 79 #include <svx/sdr/contact/displayinfo.hxx> 80 #include <svx/sdr/contact/viewobjectcontact.hxx> 81 #include <svx/sdr/contact/viewcontact.hxx> 82 #include <svx/sdr/contact/objectcontact.hxx> 83 #include <svx/unoapi.hxx> 84 85 #include <set> 86 87 using namespace ::sd; 88 using namespace ::com::sun::star; 89 90 TYPEINIT2( SdPage, FmFormPage, SdrObjUserCall ); 91 92 /************************************************************************* 93 |* 94 |* Ctor 95 |* 96 \************************************************************************/ 97 98 SdPage::SdPage(SdDrawDocument& rNewDoc, StarBASIC* pBasic, sal_Bool bMasterPage) 99 : FmFormPage(rNewDoc, pBasic, bMasterPage) 100 , SdrObjUserCall() 101 , mePageKind(PK_STANDARD) 102 , meAutoLayout(AUTOLAYOUT_NONE) 103 , mbSelected(sal_False) 104 , mePresChange(PRESCHANGE_MANUAL) 105 , mnTime(1) 106 , mbSoundOn(sal_False) 107 , mbExcluded(sal_False) 108 , mbLoopSound(sal_False) 109 , mbStopSound(sal_False) 110 , mbScaleObjects(sal_True) 111 , mbBackgroundFullSize( sal_False ) 112 , meCharSet(gsl_getSystemTextEncoding()) 113 , mnPaperBin(PAPERBIN_PRINTER_SETTINGS) 114 , mpPageLink(NULL) 115 , mpItems(NULL) 116 , mnTransitionType(0) 117 , mnTransitionSubtype(0) 118 , mbTransitionDirection(sal_True) 119 , mnTransitionFadeColor(0) 120 , mfTransitionDuration(2.0) 121 , mbIsPrecious(true) 122 { 123 // Der Layoutname der Seite wird von SVDRAW benutzt, um die Praesentations- 124 // vorlagen der Gliederungsobjekte zu ermitteln. Darum enthaelt er bereits 125 // den Bezeichner fuer die Gliederung (STR_LAYOUT_OUTLINE). 126 maLayoutName = String(SdResId(STR_LAYOUT_DEFAULT_NAME)); 127 maLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR )); 128 maLayoutName += String(SdResId(STR_LAYOUT_OUTLINE)); 129 130 Size aPageSize(GetSize()); 131 132 if (aPageSize.Width() > aPageSize.Height()) 133 { 134 meOrientation = ORIENTATION_LANDSCAPE; 135 } 136 else 137 { 138 meOrientation = ORIENTATION_PORTRAIT; 139 } 140 } 141 142 /************************************************************************* 143 |* 144 |* Dtor 145 |* 146 \************************************************************************/ 147 148 SdPage::~SdPage() 149 { 150 DisconnectLink(); 151 152 EndListenOutlineText(); 153 154 if( mpItems ) 155 delete mpItems; 156 } 157 158 struct OrdNumSorter 159 { 160 bool operator()( SdrObject* p1, SdrObject* p2 ) 161 { 162 return p1->GetOrdNum() < p2->GetOrdNum(); 163 } 164 }; 165 166 /** returns the nIndex'th object from the given PresObjKind, index starts with 1 */ 167 SdrObject* SdPage::GetPresObj(PresObjKind eObjKind, int nIndex, bool bFuzzySearch /* = false */ ) 168 { 169 // first sort all matching shapes with z-order 170 std::vector< SdrObject* > aMatches; 171 172 SdrObject* pObj = 0; 173 while( (pObj = maPresentationShapeList.getNextShape(pObj)) != 0 ) 174 { 175 SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj); 176 if( pInfo ) 177 { 178 bool bFound = false; 179 if( pInfo->mePresObjKind == eObjKind ) 180 { 181 bFound = true; 182 } 183 else if( bFuzzySearch && (eObjKind == PRESOBJ_OUTLINE) ) 184 { 185 switch( pInfo->mePresObjKind ) 186 { 187 case PRESOBJ_GRAPHIC: 188 case PRESOBJ_OBJECT: 189 case PRESOBJ_CHART: 190 case PRESOBJ_ORGCHART: 191 case PRESOBJ_TABLE: 192 case PRESOBJ_CALC: 193 case PRESOBJ_IMAGE: 194 case PRESOBJ_MEDIA: 195 bFound = sal_True; 196 break; 197 default: 198 break; 199 } 200 } 201 if( bFound ) 202 { 203 aMatches.push_back( pObj ); 204 } 205 } 206 } 207 208 if( aMatches.size() > 1 ) 209 { 210 OrdNumSorter aSortHelper; 211 std::sort( aMatches.begin(), aMatches.end(), aSortHelper ); 212 } 213 214 if( nIndex > 0 ) 215 nIndex--; 216 217 if( (nIndex >= 0) && ( aMatches.size() > static_cast<unsigned int>(nIndex)) ) 218 return aMatches[nIndex]; 219 220 return 0; 221 } 222 223 /** create background properties */ 224 void SdPage::EnsureMasterPageDefaultBackground() 225 { 226 if(mbMaster) 227 { 228 // no hard attributes on MasterPage attributes 229 getSdrPageProperties().ClearItem(); 230 SfxStyleSheet* pSheetForPresObj = GetStyleSheetForMasterPageBackground(); 231 232 if(pSheetForPresObj) 233 { 234 // set StyleSheet for background fill attributes 235 getSdrPageProperties().SetStyleSheet(pSheetForPresObj); 236 } 237 else 238 { 239 // no style found, assert and set at least XFILL_NONE 240 OSL_ENSURE(false, "No Style for MasterPageBackground fill found (!)"); 241 getSdrPageProperties().PutItem(XFillStyleItem(XFILL_NONE)); 242 } 243 } 244 } 245 246 /** creates a presentation object with the given PresObjKind on this page. A user call will be set 247 */ 248 SdrObject* SdPage::CreatePresObj(PresObjKind eObjKind, sal_Bool bVertical, const Rectangle& rRect, sal_Bool /* bInsert */ ) 249 { 250 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 251 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted(); 252 253 SdrObject* pSdrObj = NULL; 254 255 bool bForceText = false; // forces the shape text to be set even if its empty 256 bool bEmptyPresObj = true; 257 258 switch( eObjKind ) 259 { 260 case PRESOBJ_TITLE: 261 { 262 pSdrObj = new SdrRectObj(OBJ_TITLETEXT); 263 264 if (mbMaster) 265 { 266 pSdrObj->SetNotVisibleAsMaster(sal_True); 267 } 268 } 269 break; 270 271 case PRESOBJ_OUTLINE: 272 { 273 pSdrObj = new SdrRectObj(OBJ_OUTLINETEXT); 274 275 if (mbMaster) 276 { 277 pSdrObj->SetNotVisibleAsMaster(sal_True); 278 } 279 } 280 break; 281 282 case PRESOBJ_NOTES: 283 { 284 pSdrObj = new SdrRectObj(OBJ_TEXT); 285 286 if (mbMaster) 287 { 288 pSdrObj->SetNotVisibleAsMaster(sal_True); 289 } 290 } 291 break; 292 293 case PRESOBJ_TEXT: 294 { 295 pSdrObj = new SdrRectObj(OBJ_TEXT); 296 } 297 break; 298 299 case PRESOBJ_GRAPHIC: 300 { 301 BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_GRAPHIC ) ); 302 Graphic aGraphic( aBmpEx ); 303 OutputDevice &aOutDev = *Application::GetDefaultDevice(); 304 aOutDev.Push(); 305 306 aOutDev.SetMapMode( aGraphic.GetPrefMapMode() ); 307 Size aSizePix = aOutDev.LogicToPixel( aGraphic.GetPrefSize() ); 308 aOutDev.SetMapMode(MAP_100TH_MM); 309 310 Size aSize = aOutDev.PixelToLogic(aSizePix); 311 Point aPnt (0, 0); 312 Rectangle aRect (aPnt, aSize); 313 pSdrObj = new SdrGrafObj(aGraphic, aRect); 314 aOutDev.Pop(); 315 } 316 break; 317 318 case PRESOBJ_MEDIA: 319 case PRESOBJ_OBJECT: 320 { 321 pSdrObj = new SdrOle2Obj(); 322 BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_OBJECT ) ); 323 Graphic aGraphic( aBmpEx ); 324 ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); 325 } 326 break; 327 328 case PRESOBJ_CHART: 329 { 330 pSdrObj = new SdrOle2Obj(); 331 ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarChart" ))); 332 BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_CHART ) ); 333 Graphic aGraphic( aBmpEx ); 334 ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); 335 } 336 break; 337 338 case PRESOBJ_ORGCHART: 339 { 340 pSdrObj = new SdrOle2Obj(); 341 ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarOrg" ))); 342 BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_ORGCHART ) ); 343 Graphic aGraphic( aBmpEx ); 344 ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); 345 } 346 347 case PRESOBJ_TABLE: 348 case PRESOBJ_CALC: 349 { 350 pSdrObj = new SdrOle2Obj(); 351 ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarCalc" ))); 352 BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_TABLE ) ); 353 Graphic aGraphic( aBmpEx ); 354 ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); 355 } 356 break; 357 358 case PRESOBJ_HANDOUT: 359 { 360 //Erste Standardseite am SdrPageObj vermerken 361 // #i105146# We want no content to be displayed for PK_HANDOUT, 362 // so just never set a page as content 363 pSdrObj = new SdrPageObj(0); 364 // pSdrObj->SetResizeProtect(sal_True); 365 } 366 break; 367 368 case PRESOBJ_PAGE: 369 { 370 //Notizseite am SdrPageObj vermerken 371 sal_uInt16 nDestPageNum(GetPageNum()); 372 373 if(nDestPageNum) 374 { 375 // decrement only when != 0, else we get a 0xffff 376 nDestPageNum -= 1; 377 } 378 379 if(nDestPageNum < pModel->GetPageCount()) 380 { 381 pSdrObj = new SdrPageObj(pModel->GetPage(nDestPageNum)); 382 } 383 else 384 { 385 pSdrObj = new SdrPageObj(); 386 } 387 388 pSdrObj->SetResizeProtect(sal_True); 389 } 390 break; 391 392 case PRESOBJ_HEADER: 393 case PRESOBJ_FOOTER: 394 case PRESOBJ_DATETIME: 395 case PRESOBJ_SLIDENUMBER: 396 { 397 pSdrObj = new SdrRectObj(OBJ_TEXT); 398 bEmptyPresObj = false; 399 bForceText = true; 400 } 401 break; 402 default: 403 break; 404 } 405 406 if (pSdrObj) 407 { 408 pSdrObj->SetEmptyPresObj(bEmptyPresObj); 409 pSdrObj->SetLogicRect(rRect); 410 411 InsertObject(pSdrObj); 412 413 if ( pSdrObj->ISA(SdrTextObj) ) 414 { 415 // #96243# Tell the object EARLY that it is vertical to have the 416 // defaults for AutoGrowWidth/Height reversed 417 if(bVertical) 418 ((SdrTextObj*)pSdrObj)->SetVerticalWriting(sal_True); 419 420 SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); 421 if( bVertical ) 422 aTempAttr.Put( SdrTextMinFrameWidthItem( rRect.GetSize().Width() ) ); 423 else 424 aTempAttr.Put( SdrTextMinFrameHeightItem( rRect.GetSize().Height() ) ); 425 426 if (mbMaster) 427 { 428 // Bei Praesentationsobjekten auf der MasterPage soll die 429 // Groesse vom Benutzwer frei waehlbar sein 430 431 // #96243# potential problem: This action was still NOT 432 // adapted for vertical text. This sure needs to be done. 433 if(bVertical) 434 aTempAttr.Put(SdrTextAutoGrowWidthItem(sal_False)); 435 else 436 aTempAttr.Put(SdrTextAutoGrowHeightItem(sal_False)); 437 } 438 439 // check if we need another vertical adjustement than the default 440 SdrTextVertAdjust eV = SDRTEXTVERTADJUST_TOP; 441 442 if( (eObjKind == PRESOBJ_FOOTER) && (mePageKind != PK_STANDARD) ) 443 { 444 eV = SDRTEXTVERTADJUST_BOTTOM; 445 } 446 else if( (eObjKind == PRESOBJ_SLIDENUMBER) && (mePageKind != PK_STANDARD) ) 447 { 448 eV = SDRTEXTVERTADJUST_BOTTOM; 449 } 450 451 if( eV != SDRTEXTVERTADJUST_TOP ) 452 aTempAttr.Put(SdrTextVertAdjustItem(eV)); 453 454 pSdrObj->SetMergedItemSet(aTempAttr); 455 456 pSdrObj->SetLogicRect(rRect); 457 } 458 459 String aString = GetPresObjText(eObjKind); 460 if( (aString.Len() || bForceText) && pSdrObj->ISA(SdrTextObj) ) 461 { 462 SdrOutliner* pOutliner = ( (SdDrawDocument*) GetModel() )->GetInternalOutliner(); 463 464 sal_uInt16 nOutlMode = pOutliner->GetMode(); 465 pOutliner->Init( OUTLINERMODE_TEXTOBJECT ); 466 pOutliner->SetStyleSheet( 0, NULL ); 467 pOutliner->SetVertical( bVertical ); 468 469 String aEmptyStr; 470 SetObjText( (SdrTextObj*) pSdrObj, (SdrOutliner*)pOutliner, eObjKind, aString ); 471 472 pOutliner->Init( nOutlMode ); 473 pOutliner->SetStyleSheet( 0, NULL ); 474 } 475 476 if( (eObjKind == PRESOBJ_HEADER) || (eObjKind == PRESOBJ_FOOTER) || (eObjKind == PRESOBJ_SLIDENUMBER) || (eObjKind == PRESOBJ_DATETIME) ) 477 { 478 SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); 479 aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT ) ); 480 aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CTL ) ); 481 aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CJK ) ); 482 483 SvxAdjust eH = SVX_ADJUST_LEFT; 484 485 if( (eObjKind == PRESOBJ_DATETIME) && (mePageKind != PK_STANDARD ) ) 486 { 487 eH = SVX_ADJUST_RIGHT; 488 } 489 else if( (eObjKind == PRESOBJ_FOOTER) && (mePageKind == PK_STANDARD ) ) 490 { 491 eH = SVX_ADJUST_CENTER; 492 } 493 else if( eObjKind == PRESOBJ_SLIDENUMBER ) 494 { 495 eH = SVX_ADJUST_RIGHT; 496 } 497 498 if( eH != SVX_ADJUST_LEFT ) 499 aTempAttr.Put(SvxAdjustItem(eH, EE_PARA_JUST )); 500 501 pSdrObj->SetMergedItemSet(aTempAttr); 502 } 503 504 if (mbMaster) 505 { 506 SdrLayerAdmin& rLayerAdmin = pModel->GetLayerAdmin(); 507 508 // Hintergrundobjekte der MasterPage 509 pSdrObj->SetLayer( rLayerAdmin. 510 GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False) ); 511 } 512 513 // Objekt am StyleSheet anmelden 514 // #95114# Set style only when one was found (as in 5.2) 515 // pSdrObj->NbcSetStyleSheet( GetStyleSheetForPresObj(eObjKind), sal_False ); 516 if( mePageKind != PK_HANDOUT ) 517 { 518 SfxStyleSheet* pSheetForPresObj = GetStyleSheetForPresObj(eObjKind); 519 if(pSheetForPresObj) 520 pSdrObj->SetStyleSheet(pSheetForPresObj, sal_False); 521 } 522 523 if (eObjKind == PRESOBJ_OUTLINE) 524 { 525 for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++) 526 { 527 String aName(maLayoutName); 528 aName += sal_Unicode( ' ' ); 529 aName += String::CreateFromInt32( nLevel ); 530 SfxStyleSheet* pSheet = (SfxStyleSheet*)pModel->GetStyleSheetPool()->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); 531 DBG_ASSERT(pSheet, "Vorlage fuer Gliederungsobjekt nicht gefunden"); 532 if (pSheet) 533 pSdrObj->StartListening(*pSheet); 534 } 535 } 536 537 if ( eObjKind == PRESOBJ_OBJECT || 538 eObjKind == PRESOBJ_CHART || 539 eObjKind == PRESOBJ_ORGCHART || 540 eObjKind == PRESOBJ_CALC || 541 eObjKind == PRESOBJ_GRAPHIC ) 542 { 543 SfxItemSet aSet( ((SdDrawDocument*) pModel)->GetPool() ); 544 aSet.Put( SdrTextContourFrameItem( sal_True ) ); 545 aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, EE_PARA_JUST ) ); 546 547 pSdrObj->SetMergedItemSet(aSet); 548 } 549 550 if( bUndo ) 551 { 552 pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoNewObject(*pSdrObj)); 553 } 554 555 if( bUndo ) 556 { 557 pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pSdrObj ) ); 558 pUndoManager->AddUndoAction( new UndoObjectUserCall(*pSdrObj) ); 559 } 560 561 InsertPresObj(pSdrObj, eObjKind); 562 pSdrObj->SetUserCall(this); 563 564 pSdrObj->RecalcBoundRect(); 565 } 566 567 return(pSdrObj); 568 } 569 570 /************************************************************************* 571 |* 572 |* Es werden Praesentationsobjekte auf der Page erzeugt. 573 |* Alle Praesentationsobjekte erhalten einen UserCall auf die Page. 574 |* 575 \************************************************************************/ 576 577 SfxStyleSheet* SdPage::GetStyleSheetForMasterPageBackground() const 578 { 579 String aName(GetLayoutName()); 580 String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); 581 sal_uInt16 nPos = aName.Search(aSep); 582 583 if (nPos != STRING_NOTFOUND) 584 { 585 nPos = nPos + aSep.Len(); 586 aName.Erase(nPos); 587 } 588 589 aName += String(SdResId(STR_LAYOUT_BACKGROUND)); 590 591 SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); 592 SfxStyleSheetBase* pResult = pStShPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); 593 return (SfxStyleSheet*)pResult; 594 } 595 596 SfxStyleSheet* SdPage::GetStyleSheetForPresObj(PresObjKind eObjKind) const 597 { 598 String aName(GetLayoutName()); 599 String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); 600 sal_uInt16 nPos = aName.Search(aSep); 601 if (nPos != STRING_NOTFOUND) 602 { 603 nPos = nPos + aSep.Len(); 604 aName.Erase(nPos); 605 } 606 607 switch (eObjKind) 608 { 609 case PRESOBJ_OUTLINE: 610 { 611 aName = GetLayoutName(); 612 aName += sal_Unicode( ' ' ); 613 aName += String::CreateFromInt32( 1 ); 614 } 615 break; 616 617 case PRESOBJ_TITLE: 618 aName += String(SdResId(STR_LAYOUT_TITLE)); 619 break; 620 621 case PRESOBJ_NOTES: 622 aName += String(SdResId(STR_LAYOUT_NOTES)); 623 break; 624 625 case PRESOBJ_TEXT: 626 aName += String(SdResId(STR_LAYOUT_SUBTITLE)); 627 break; 628 629 case PRESOBJ_HEADER: 630 case PRESOBJ_FOOTER: 631 case PRESOBJ_DATETIME: 632 case PRESOBJ_SLIDENUMBER: 633 aName += String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS)); 634 break; 635 636 default: 637 break; 638 } 639 640 SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); 641 SfxStyleSheetBase* pResult = pStShPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); 642 return (SfxStyleSheet*)pResult; 643 } 644 645 /** returns the presentation style with the given helpid from this masterpage or this 646 slides masterpage */ 647 SdStyleSheet* SdPage::getPresentationStyle( sal_uInt32 nHelpId ) const 648 { 649 String aStyleName( pPage->GetLayoutName() ); 650 const String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); 651 aStyleName.Erase(aStyleName.Search(aSep) + aSep.Len()); 652 653 sal_uInt16 nNameId; 654 switch( nHelpId ) 655 { 656 case HID_PSEUDOSHEET_TITLE: nNameId = STR_LAYOUT_TITLE; break; 657 case HID_PSEUDOSHEET_SUBTITLE: nNameId = STR_LAYOUT_SUBTITLE; break; 658 case HID_PSEUDOSHEET_OUTLINE1: 659 case HID_PSEUDOSHEET_OUTLINE2: 660 case HID_PSEUDOSHEET_OUTLINE3: 661 case HID_PSEUDOSHEET_OUTLINE4: 662 case HID_PSEUDOSHEET_OUTLINE5: 663 case HID_PSEUDOSHEET_OUTLINE6: 664 case HID_PSEUDOSHEET_OUTLINE7: 665 case HID_PSEUDOSHEET_OUTLINE8: 666 case HID_PSEUDOSHEET_OUTLINE9: nNameId = STR_LAYOUT_OUTLINE; break; 667 case HID_PSEUDOSHEET_BACKGROUNDOBJECTS: nNameId = STR_LAYOUT_BACKGROUNDOBJECTS; break; 668 case HID_PSEUDOSHEET_BACKGROUND: nNameId = STR_LAYOUT_BACKGROUND; break; 669 case HID_PSEUDOSHEET_NOTES: nNameId = STR_LAYOUT_NOTES; break; 670 671 default: 672 DBG_ERROR( "SdPage::getPresentationStyle(), illegal argument!" ); 673 return 0; 674 } 675 aStyleName.Append( String( SdResId( nNameId ) ) ); 676 if( nNameId == STR_LAYOUT_OUTLINE ) 677 { 678 aStyleName.Append( sal_Unicode( ' ' )); 679 aStyleName.Append( String::CreateFromInt32( sal_Int32( nHelpId - HID_PSEUDOSHEET_OUTLINE ))); 680 } 681 682 SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); 683 SfxStyleSheetBase* pResult = pStShPool->Find(aStyleName, SD_STYLE_FAMILY_MASTERPAGE); 684 return dynamic_cast<SdStyleSheet*>(pResult); 685 } 686 687 /************************************************************************* 688 |* 689 |* Das Praesentationsobjekt rObj hat sich geaendert und wird nicht mehr 690 |* durch das Praesentationsobjekt der MasterPage referenziert. 691 |* Der UserCall wird geloescht. 692 |* 693 \************************************************************************/ 694 695 void SdPage::Changed(const SdrObject& rObj, SdrUserCallType eType, const Rectangle& ) 696 { 697 if (!maLockAutoLayoutArrangement.isLocked()) 698 { 699 switch (eType) 700 { 701 case SDRUSERCALL_MOVEONLY: 702 case SDRUSERCALL_RESIZE: 703 { 704 if( pModel->isLocked() ) 705 break; 706 707 SdrObject* pObj = (SdrObject*) &rObj; 708 709 if (pObj) 710 { 711 if (!mbMaster) 712 { 713 if( pObj->GetUserCall() ) 714 { 715 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 716 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted(); 717 /* 718 DBG_ASSERT( bUndo || (pUndoManager && pUndoManager->IsDoing()), 719 "SdPage::Changed(), model change without undo!?" ); 720 */ 721 if( bUndo ) 722 pUndoManager->AddUndoAction( new UndoObjectUserCall(*pObj) ); 723 724 // Objekt was resized by user and does not listen to its slide anymore 725 pObj->SetUserCall(0); 726 } 727 } 728 else if (pModel) 729 { 730 // MasterPage-Objekt wurde veraendert, daher 731 // Objekte auf allen Seiten anpassen 732 sal_uInt16 nPageCount = ((SdDrawDocument*) pModel)->GetSdPageCount(mePageKind); 733 734 for (sal_uInt16 i = 0; i < nPageCount; i++) 735 { 736 SdPage* pLoopPage = ((SdDrawDocument*) pModel)->GetSdPage(i, mePageKind); 737 738 if (pLoopPage && this == &(pLoopPage->TRG_GetMasterPage())) 739 { 740 // Seite hoert auf diese MasterPage, daher 741 // AutoLayout anpassen 742 pLoopPage->SetAutoLayout(pLoopPage->GetAutoLayout()); 743 } 744 } 745 } 746 } 747 } 748 break; 749 750 case SDRUSERCALL_DELETE: 751 case SDRUSERCALL_REMOVED: 752 default: 753 break; 754 } 755 } 756 } 757 758 /************************************************************************* 759 |* 760 |* Erzeugt auf einer MasterPage Hintergrund, Titel- und Layout-Bereich 761 |* 762 \************************************************************************/ 763 764 void SdPage::CreateTitleAndLayout(sal_Bool bInit, sal_Bool bCreate ) 765 { 766 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 767 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted(); 768 769 SdPage* pMasterPage = this; 770 771 if (!mbMaster) 772 { 773 pMasterPage = (SdPage*)(&(TRG_GetMasterPage())); 774 } 775 776 if (!pMasterPage) 777 { 778 return; 779 } 780 781 /************************************************************************** 782 * Hintergrund, Titel- und Layout-Bereich werden angelegt 783 **************************************************************************/ 784 if( mePageKind == PK_STANDARD ) 785 { 786 pMasterPage->EnsureMasterPageDefaultBackground(); 787 } 788 789 if( ( (SdDrawDocument*) GetModel() )->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ) 790 { 791 if( mePageKind == PK_HANDOUT && bInit ) 792 { 793 // handout template 794 795 // delete all available handout presentation objects 796 SdrObject *pObj=NULL; 797 while( (pObj = pMasterPage->GetPresObj(PRESOBJ_HANDOUT)) != 0 ) 798 { 799 pMasterPage->RemoveObject(pObj->GetOrdNum()); 800 801 if( bUndo ) 802 { 803 pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); 804 } 805 else 806 { 807 SdrObject::Free( pObj ); // memory leak i120050 808 } 809 } 810 811 std::vector< Rectangle > aAreas; 812 CalculateHandoutAreas( *static_cast< SdDrawDocument* >(GetModel() ), pMasterPage->GetAutoLayout(), false, aAreas ); 813 814 const bool bSkip = pMasterPage->GetAutoLayout() == AUTOLAYOUT_HANDOUT3; 815 std::vector< Rectangle >::iterator iter( aAreas.begin() ); 816 817 while( iter != aAreas.end() ) 818 { 819 SdrPageObj* pPageObj = static_cast<SdrPageObj*>(pMasterPage->CreatePresObj(PRESOBJ_HANDOUT, sal_False, (*iter++), sal_True) ); 820 // #i105146# We want no content to be displayed for PK_HANDOUT, 821 // so just never set a page as content 822 pPageObj->SetReferencedPage(0L); 823 824 if( bSkip && iter != aAreas.end() ) 825 iter++; 826 } 827 } 828 829 if( mePageKind != PK_HANDOUT ) 830 { 831 SdrObject* pMasterTitle = pMasterPage->GetPresObj( PRESOBJ_TITLE ); 832 if( pMasterTitle == NULL ) 833 pMasterPage->CreateDefaultPresObj(PRESOBJ_TITLE, true); 834 835 SdrObject* pMasterOutline = pMasterPage->GetPresObj( mePageKind==PK_NOTES ? PRESOBJ_NOTES : PRESOBJ_OUTLINE ); 836 if( pMasterOutline == NULL ) 837 pMasterPage->CreateDefaultPresObj( mePageKind == PK_STANDARD ? PRESOBJ_OUTLINE : PRESOBJ_NOTES, true ); 838 } 839 840 // create header&footer objects 841 842 if( bCreate ) 843 { 844 if( mePageKind != PK_STANDARD ) 845 { 846 SdrObject* pHeader = pMasterPage->GetPresObj( PRESOBJ_HEADER ); 847 if( pHeader == NULL ) 848 pMasterPage->CreateDefaultPresObj( PRESOBJ_HEADER, true ); 849 } 850 851 SdrObject* pDate = pMasterPage->GetPresObj( PRESOBJ_DATETIME ); 852 if( pDate == NULL ) 853 pMasterPage->CreateDefaultPresObj( PRESOBJ_DATETIME, true ); 854 855 SdrObject* pFooter = pMasterPage->GetPresObj( PRESOBJ_FOOTER ); 856 if( pFooter == NULL ) 857 pMasterPage->CreateDefaultPresObj( PRESOBJ_FOOTER, true ); 858 859 SdrObject* pNumber = pMasterPage->GetPresObj( PRESOBJ_SLIDENUMBER ); 860 if( pNumber == NULL ) 861 pMasterPage->CreateDefaultPresObj( PRESOBJ_SLIDENUMBER, true ); 862 } 863 } 864 } 865 866 SdrObject* SdPage::CreateDefaultPresObj(PresObjKind eObjKind, bool bInsert) 867 { 868 if( eObjKind == PRESOBJ_TITLE ) 869 { 870 Rectangle aTitleRect( GetTitleRect() ); 871 return CreatePresObj(PRESOBJ_TITLE, sal_False, aTitleRect, bInsert); 872 } 873 else if( eObjKind == PRESOBJ_OUTLINE ) 874 { 875 Rectangle aLayoutRect( GetLayoutRect() ); 876 return CreatePresObj( PRESOBJ_OUTLINE, sal_False, aLayoutRect, bInsert); 877 } 878 else if( eObjKind == PRESOBJ_NOTES ) 879 { 880 Rectangle aLayoutRect( GetLayoutRect() ); 881 return CreatePresObj( PRESOBJ_NOTES, sal_False, aLayoutRect, bInsert); 882 } 883 else if( (eObjKind == PRESOBJ_FOOTER) || (eObjKind == PRESOBJ_DATETIME) || (eObjKind == PRESOBJ_SLIDENUMBER) || (eObjKind == PRESOBJ_HEADER ) ) 884 { 885 // create footer objects for standard master page 886 if( mePageKind == PK_STANDARD ) 887 { 888 const long nLftBorder = GetLftBorder(); 889 const long nUppBorder = GetUppBorder(); 890 891 Point aTitlePos ( nLftBorder, nUppBorder ); 892 Size aPageSize ( GetSize() ); 893 aPageSize.Width() -= nLftBorder + GetRgtBorder(); 894 aPageSize.Height() -= nUppBorder + GetLwrBorder(); 895 896 const int Y = long(nUppBorder + aPageSize.Height() * 0.911); 897 const int W1 = long(aPageSize.Width() * 0.233); 898 const int W2 = long(aPageSize.Width() * 0.317); 899 const int H = long(aPageSize.Height() * 0.069); 900 901 if( eObjKind == PRESOBJ_DATETIME ) 902 { 903 Point aPos( long(nLftBorder+(aPageSize.Width()*0.05)), Y ); 904 Size aSize( W1, H ); 905 Rectangle aRect( aPos, aSize ); 906 return CreatePresObj( PRESOBJ_DATETIME, sal_False, aRect, bInsert ); 907 } 908 else if( eObjKind == PRESOBJ_FOOTER ) 909 { 910 Point aPos( long(nLftBorder+ aPageSize.Width() * 0.342), Y ); 911 Size aSize( W2, H ); 912 Rectangle aRect( aPos, aSize ); 913 return CreatePresObj( PRESOBJ_FOOTER, sal_False, aRect, bInsert ); 914 } 915 else if( eObjKind == PRESOBJ_SLIDENUMBER ) 916 { 917 Point aPos( long(nLftBorder+(aPageSize.Width()*0.717)), Y ); 918 Size aSize( W1, H ); 919 Rectangle aRect( aPos, aSize ); 920 return CreatePresObj( PRESOBJ_SLIDENUMBER, sal_False, aRect, bInsert ); 921 } 922 else 923 { 924 DBG_ERROR( "SdPage::CreateDefaultPresObj() - can't create a header placeholder for a slide master" ); 925 return NULL; 926 } 927 } 928 else 929 { 930 // create header&footer objects for handout and notes master 931 Point aTitlePos ( GetLftBorder(), GetUppBorder() ); 932 Size aPageSize ( GetSize() ); 933 aPageSize.Width() -= GetLftBorder() + GetRgtBorder(); 934 aPageSize.Height() -= GetUppBorder() + GetLwrBorder(); 935 936 937 const int NOTES_HEADER_FOOTER_WIDTH = long(aPageSize.Width() * 0.434); 938 const int NOTES_HEADER_FOOTER_HEIGHT = long(aPageSize.Height() * 0.05); 939 940 Size aSize( NOTES_HEADER_FOOTER_WIDTH, NOTES_HEADER_FOOTER_HEIGHT ); 941 942 const int X1 = GetLftBorder(); 943 const int X2 = GetLftBorder() + long(aPageSize.Width() - NOTES_HEADER_FOOTER_WIDTH); 944 const int Y1 = GetUppBorder(); 945 const int Y2 = GetUppBorder() + long(aPageSize.Height() - NOTES_HEADER_FOOTER_HEIGHT ); 946 947 if( eObjKind == PRESOBJ_HEADER ) 948 { 949 Point aPos( X1, Y1 ); 950 Rectangle aRect( aPos, aSize ); 951 return CreatePresObj( PRESOBJ_HEADER, sal_False, aRect, bInsert ); 952 } 953 else if( eObjKind == PRESOBJ_DATETIME ) 954 { 955 Point aPos( X2, Y1 ); 956 Rectangle aRect( aPos, aSize ); 957 return CreatePresObj( PRESOBJ_DATETIME, sal_False, aRect, bInsert ); 958 } 959 else if( eObjKind == PRESOBJ_FOOTER ) 960 { 961 Point aPos( X1, Y2 ); 962 Rectangle aRect( aPos, aSize ); 963 return CreatePresObj( PRESOBJ_FOOTER, sal_False, aRect, bInsert ); 964 } 965 else if( eObjKind == PRESOBJ_SLIDENUMBER ) 966 { 967 Point aPos( X2, Y2 ); 968 Rectangle aRect( aPos, aSize ); 969 return CreatePresObj( PRESOBJ_SLIDENUMBER, sal_False, aRect, bInsert ); 970 } 971 972 DBG_ERROR("SdPage::CreateDefaultPresObj() - this should not happen!"); 973 return NULL; 974 } 975 } 976 else 977 { 978 DBG_ERROR("SdPage::CreateDefaultPresObj() - unknown PRESOBJ kind" ); 979 return NULL; 980 } 981 } 982 983 /************************************************************************* 984 |* 985 |* Titelbereich zurueckgeben 986 |* 987 \************************************************************************/ 988 989 Rectangle SdPage::GetTitleRect() const 990 { 991 Rectangle aTitleRect; 992 993 if (mePageKind != PK_HANDOUT) 994 { 995 /****************************************************************** 996 * Standard- oder Notiz-Seite: Titelbereich 997 ******************************************************************/ 998 Point aTitlePos ( GetLftBorder(), GetUppBorder() ); 999 Size aTitleSize ( GetSize() ); 1000 aTitleSize.Width() -= GetLftBorder() + GetRgtBorder(); 1001 aTitleSize.Height() -= GetUppBorder() + GetLwrBorder(); 1002 1003 if (mePageKind == PK_STANDARD) 1004 { 1005 aTitlePos.X() += long( aTitleSize.Width() * 0.05 ); 1006 aTitlePos.Y() += long( aTitleSize.Height() * 0.0399 ); 1007 aTitleSize.Width() = long( aTitleSize.Width() * 0.9 ); 1008 aTitleSize.Height() = long( aTitleSize.Height() * 0.167 ); 1009 } 1010 else if (mePageKind == PK_NOTES) 1011 { 1012 Point aPos = aTitlePos; 1013 aPos.Y() += long( aTitleSize.Height() * 0.076 ); 1014 1015 // Hoehe beschraenken 1016 aTitleSize.Height() = (long) (aTitleSize.Height() * 0.375); 1017 1018 Size aPartArea = aTitleSize; 1019 Size aSize; 1020 sal_uInt16 nDestPageNum(GetPageNum()); 1021 SdrPage* pRefPage = 0L; 1022 1023 if(nDestPageNum) 1024 { 1025 // only decrement if != 0, else we get 0xffff 1026 nDestPageNum -= 1; 1027 } 1028 1029 if(nDestPageNum < pModel->GetPageCount()) 1030 { 1031 pRefPage = pModel->GetPage(nDestPageNum); 1032 } 1033 1034 if ( pRefPage ) 1035 { 1036 // tatsaechliche Seitengroesse in das Handout-Rechteck skalieren 1037 double fH = (double) aPartArea.Width() / pRefPage->GetWdt(); 1038 double fV = (double) aPartArea.Height() / pRefPage->GetHgt(); 1039 1040 if ( fH > fV ) 1041 fH = fV; 1042 aSize.Width() = (long) (fH * pRefPage->GetWdt()); 1043 aSize.Height() = (long) (fH * pRefPage->GetHgt()); 1044 1045 aPos.X() += (aPartArea.Width() - aSize.Width()) / 2; 1046 aPos.Y() += (aPartArea.Height()- aSize.Height())/ 2; 1047 } 1048 1049 aTitlePos = aPos; 1050 aTitleSize = aSize; 1051 } 1052 1053 aTitleRect.SetPos(aTitlePos); 1054 aTitleRect.SetSize(aTitleSize); 1055 } 1056 1057 return aTitleRect; 1058 } 1059 1060 1061 /************************************************************************* 1062 |* 1063 |* Gliederungsbereich zurueckgeben 1064 |* 1065 \************************************************************************/ 1066 1067 Rectangle SdPage::GetLayoutRect() const 1068 { 1069 Rectangle aLayoutRect; 1070 1071 if (mePageKind != PK_HANDOUT) 1072 { 1073 Point aLayoutPos ( GetLftBorder(), GetUppBorder() ); 1074 Size aLayoutSize ( GetSize() ); 1075 aLayoutSize.Width() -= GetLftBorder() + GetRgtBorder(); 1076 aLayoutSize.Height() -= GetUppBorder() + GetLwrBorder(); 1077 1078 if (mePageKind == PK_STANDARD) 1079 { 1080 aLayoutPos.X() += long( aLayoutSize.Width() * 0.05 ); 1081 aLayoutPos.Y() += long( aLayoutSize.Height() * 0.234 ); 1082 aLayoutSize.Width() = long( aLayoutSize.Width() * 0.9 ); 1083 aLayoutSize.Height() = long( aLayoutSize.Height() * 0.66 ); 1084 aLayoutRect.SetPos(aLayoutPos); 1085 aLayoutRect.SetSize(aLayoutSize); 1086 } 1087 else if (mePageKind == PK_NOTES) 1088 { 1089 aLayoutPos.X() += long( aLayoutSize.Width() * 0.1 ); 1090 aLayoutPos.Y() += long( aLayoutSize.Height() * 0.475 ); 1091 aLayoutSize.Width() = long( aLayoutSize.Width() * 0.8 ); 1092 aLayoutSize.Height() = long( aLayoutSize.Height() * 0.45 ); 1093 aLayoutRect.SetPos(aLayoutPos); 1094 aLayoutRect.SetSize(aLayoutSize); 1095 } 1096 } 1097 1098 return aLayoutRect; 1099 } 1100 1101 1102 /************************************************************************** 1103 |* 1104 |* Diese Methode weist ein AutoLayout zu 1105 |* 1106 \*************************************************************************/ 1107 1108 const int MAX_PRESOBJS = 7; // maximum number of presentation objects per layout 1109 const int VERTICAL = 0x8000; 1110 1111 struct LayoutDescriptor 1112 { 1113 int mnLayout; 1114 PresObjKind meKind[MAX_PRESOBJS]; 1115 bool mbVertical[MAX_PRESOBJS]; 1116 1117 LayoutDescriptor( int nLayout, int k0 = 0, int k1 = 0, int k2 = 0, int k3 = 0, int k4 = 0, int k5 = 0, int k6 = 0 ); 1118 }; 1119 1120 LayoutDescriptor::LayoutDescriptor( int nLayout, int k0, int k1, int k2, int k3, int k4, int k5, int k6 ) 1121 : mnLayout( nLayout ) 1122 { 1123 meKind[0] = static_cast<PresObjKind>(k0 & (~VERTICAL)); mbVertical[0] = (k0 & VERTICAL) == VERTICAL; 1124 meKind[1] = static_cast<PresObjKind>(k1 & (~VERTICAL)); mbVertical[1] = (k1 & VERTICAL) == VERTICAL; 1125 meKind[2] = static_cast<PresObjKind>(k2 & (~VERTICAL)); mbVertical[2] = (k2 & VERTICAL) == VERTICAL; 1126 meKind[3] = static_cast<PresObjKind>(k3 & (~VERTICAL)); mbVertical[3] = (k3 & VERTICAL) == VERTICAL; 1127 meKind[4] = static_cast<PresObjKind>(k4 & (~VERTICAL)); mbVertical[4] = (k4 & VERTICAL) == VERTICAL; 1128 meKind[5] = static_cast<PresObjKind>(k5 & (~VERTICAL)); mbVertical[5] = (k5 & VERTICAL) == VERTICAL; 1129 meKind[6] = static_cast<PresObjKind>(k6 & (~VERTICAL)); mbVertical[6] = (k6 & VERTICAL) == VERTICAL; 1130 } 1131 1132 static const LayoutDescriptor& GetLayoutDescriptor( AutoLayout eLayout ) 1133 { 1134 static LayoutDescriptor aLayouts[AUTOLAYOUT__END-AUTOLAYOUT__START] = 1135 { 1136 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_TEXT ), // AUTOLAYOUT_TITLE 1137 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_ENUM 1138 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CHART 1139 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2TEXT 1140 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTCHART 1141 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_ORG 1142 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTCLbIP 1143 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CHARTTEXT 1144 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TAB 1145 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CLIPTEXT 1146 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOBJ 1147 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OBJECT ), // AUTOLAYOUT_OBJ 1148 LayoutDescriptor( 2, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXT2OBJ 1149 LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOBJ 1150 LayoutDescriptor( 4, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_OBJOVERTEXT 1151 LayoutDescriptor( 3, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2OBJTEXT 1152 LayoutDescriptor( 5, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2OBJOVERTEXT 1153 LayoutDescriptor( 4, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOVEROBJ 1154 LayoutDescriptor( 6, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_4OBJ 1155 PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), 1156 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_NONE ), // AUTOLAYOUT_ONLY_TITLE 1157 LayoutDescriptor( 0, PRESOBJ_NONE ), // AUTOLAYOUT_NONE 1158 LayoutDescriptor( 0, PRESOBJ_PAGE, PRESOBJ_NOTES ), // AUTOLAYOUT_NOTES 1159 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT1 1160 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT2 1161 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT3 1162 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT4 1163 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT6 1164 LayoutDescriptor( 7, PRESOBJ_TITLE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL, PRESOBJ_OUTLINE ),// AUTOLAYOUT_VERTICAL_TITLE_TEXT_CHART 1165 LayoutDescriptor( 8, PRESOBJ_TITLE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_VERTICAL_TITLE_VERTICAL_OUTLINE 1166 LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE 1167 LayoutDescriptor( 9, PRESOBJ_TITLE, PRESOBJ_OUTLINE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE_CLIPART 1168 LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT9 1169 LayoutDescriptor( 10, PRESOBJ_TEXT, PRESOBJ_NONE ), // AUTOLAYOUT_ONLY_TEXT 1170 LayoutDescriptor( 6, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_4CLIPART 1171 PRESOBJ_GRAPHIC, PRESOBJ_GRAPHIC ), 1172 LayoutDescriptor( 11, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_6CLIPART 1173 PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ) 1174 }; 1175 1176 if( (eLayout < AUTOLAYOUT__START) || (eLayout >= AUTOLAYOUT__END) ) 1177 eLayout = AUTOLAYOUT_NONE; 1178 1179 return aLayouts[ eLayout - AUTOLAYOUT__START ]; 1180 } 1181 1182 static void CalcAutoLayoutRectangles( SdPage& rPage, int nLayout, Rectangle* rRectangle ) 1183 { 1184 Rectangle aTitleRect; 1185 Rectangle aLayoutRect; 1186 1187 if( rPage.GetPageKind() != PK_HANDOUT ) 1188 { 1189 SdPage& rMasterPage = static_cast<SdPage&>(rPage.TRG_GetMasterPage()); 1190 SdrObject* pMasterTitle = rMasterPage.GetPresObj( PRESOBJ_TITLE ); 1191 SdrObject* pMasterSubTitle = rMasterPage.GetPresObj( PRESOBJ_TEXT ); 1192 SdrObject* pMasterOutline = rMasterPage.GetPresObj( rPage.GetPageKind()==PK_NOTES ? PRESOBJ_NOTES : PRESOBJ_OUTLINE ); 1193 1194 if( pMasterTitle ) 1195 aTitleRect = pMasterTitle->GetLogicRect(); 1196 1197 if (aTitleRect.IsEmpty() ) 1198 aTitleRect = rPage.GetTitleRect(); 1199 if( pMasterSubTitle ) 1200 aLayoutRect = pMasterSubTitle->GetLogicRect(); 1201 else if( pMasterOutline ) 1202 aLayoutRect = pMasterOutline->GetLogicRect(); 1203 1204 if (aLayoutRect.IsEmpty() ) 1205 aLayoutRect = rPage.GetLayoutRect(); 1206 } 1207 1208 rRectangle[0] = aTitleRect; 1209 1210 int i; 1211 for( i = 1; i < MAX_PRESOBJS; i++ ) 1212 rRectangle[i] = aLayoutRect; 1213 1214 Size aTitleSize( aTitleRect.GetSize() ); 1215 Point aTitlePos( aTitleRect.TopLeft() ); 1216 Size aLayoutSize( aLayoutRect.GetSize() ); 1217 Point aLayoutPos( aLayoutRect.TopLeft() ); 1218 Size aTempSize; 1219 Point aTempPnt; 1220 1221 sal_Bool bRightToLeft = ( rPage.GetModel() && static_cast< SdDrawDocument* >( rPage.GetModel() )->GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB ); 1222 1223 switch( nLayout ) 1224 { 1225 case 0: // default layout using only the title and layout area 1226 break; // do nothing 1227 case 1: // title, 2 shapes 1228 case 9: // title, 2 vertical shapes 1229 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1230 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1231 1232 aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); 1233 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1234 1235 if( bRightToLeft && (nLayout != 9) ) 1236 ::std::swap< Rectangle >( rRectangle[1], rRectangle[2] ); 1237 break; 1238 case 2: // title, shape, 2 shapes 1239 aTempPnt = aLayoutPos; 1240 aTempSize = aLayoutSize; 1241 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1242 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1243 aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); 1244 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1245 1246 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1247 rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); 1248 1249 aLayoutPos = aTempPnt; 1250 aLayoutSize = aTempSize; 1251 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1252 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1253 1254 if( bRightToLeft ) 1255 { 1256 ::std::swap< long >( rRectangle[1].Left(), rRectangle[2].Left() ); 1257 rRectangle[3].Left() = rRectangle[2].Left(); 1258 } 1259 break; 1260 case 3: // title, 2 shapes, shape 1261 aTempPnt = aLayoutPos; 1262 aTempSize = aLayoutSize; 1263 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1264 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1265 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1266 1267 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1268 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1269 1270 aLayoutPos = aTempPnt; 1271 aLayoutSize = aTempSize; 1272 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1273 aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); 1274 rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); 1275 1276 if( bRightToLeft ) 1277 { 1278 ::std::swap< long >( rRectangle[1].Left(), rRectangle[2].Left() ); 1279 rRectangle[3].Left() = rRectangle[2].Left(); 1280 } 1281 break; 1282 case 4: // title, shape above shape 1283 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1284 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1285 1286 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1287 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1288 break; 1289 1290 case 5: // title, 2 shapes above shape 1291 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1292 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1293 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1294 1295 aTempPnt = aLayoutPos; 1296 aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); 1297 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1298 1299 aLayoutPos.X() = aTempPnt.X(); 1300 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1301 aLayoutSize.Width() = long (aLayoutSize.Width() / 0.488); 1302 rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); 1303 break; 1304 case 6: // title, 4 shapes 1305 { 1306 sal_uLong nX = long (aLayoutPos.X()); 1307 1308 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1309 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); 1310 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1311 1312 aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); 1313 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1314 1315 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1316 rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); 1317 1318 aLayoutPos.X() = nX; 1319 rRectangle[4] = Rectangle (aLayoutPos, aLayoutSize); 1320 break; 1321 } 1322 case 7: // vertical title, shape above shape 1323 { 1324 Size aSize( rRectangle[0].GetSize().Height(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); 1325 rRectangle[0].SetSize( aSize ); 1326 rRectangle[0].SetPos( aTitleRect.TopRight() - Point( aSize.Width(), 0 ) ); 1327 1328 Size aPageSize ( rPage.GetSize() ); 1329 aPageSize.Height() -= rPage.GetUppBorder() + rPage.GetLwrBorder(); 1330 aSize.Height() = long ( rRectangle[0].GetSize().Height() * 0.47 ); 1331 aSize.Width() = long( aPageSize.Width() * 0.7 ); 1332 rRectangle[1].SetPos( aTitleRect.TopLeft() ); 1333 rRectangle[1].SetSize( aSize ); 1334 1335 aSize.Height() = rRectangle[0].GetSize().Height(); 1336 Point aPos( aTitleRect.TopLeft() ); 1337 aPos.Y() += long ( aSize.Height() * 0.53 ); 1338 rRectangle[2].SetPos( aPos ); 1339 aSize.Height() = long ( rRectangle[0].GetSize().Height() * 0.47 ); 1340 rRectangle[2].SetSize( aSize ); 1341 break; 1342 } 1343 case 8: // vertical title, shape 1344 { 1345 Size aSize( rRectangle[0].GetSize().Height(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); 1346 rRectangle[0].SetSize( aSize ); 1347 rRectangle[0].SetPos( aTitleRect.TopRight() - Point( aSize.Width(), 0 ) ); 1348 1349 Size aPageSize ( rPage.GetSize() ); 1350 aPageSize.Height() -= rPage.GetUppBorder() + rPage.GetLwrBorder(); 1351 aSize.Height() = rRectangle[0].GetSize().Height(); 1352 aSize.Width() = long( aPageSize.Width() * 0.7 ); 1353 rRectangle[1].SetPos( aTitleRect.TopLeft() ); 1354 rRectangle[1].SetSize( aSize ); 1355 break; 1356 } 1357 case 10: // onlytext 1358 { 1359 Size aSize( rRectangle[0].GetSize().Width(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); 1360 rRectangle[0].SetSize( aSize ); 1361 rRectangle[0].SetPos( aTitlePos); 1362 break; 1363 } 1364 case 11: // title, 6 shapes 1365 { 1366 sal_uLong nX = long (aLayoutPos.X()); 1367 1368 aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); 1369 aLayoutSize.Width() = long (aLayoutSize.Width() * 0.322); 1370 rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); 1371 1372 aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); 1373 rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); 1374 1375 aLayoutPos.X() = long (nX + aLayoutSize.Width() * 2 * 1.05); 1376 rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); 1377 1378 aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); 1379 rRectangle[4] = Rectangle (aLayoutPos, aLayoutSize); 1380 1381 aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); 1382 rRectangle[5] = Rectangle (aLayoutPos, aLayoutSize); 1383 1384 aLayoutPos.X() = nX; 1385 rRectangle[6] = Rectangle (aLayoutPos, aLayoutSize); 1386 1387 break; 1388 } 1389 1390 } 1391 } 1392 1393 1394 void findAutoLayoutShapesImpl( SdPage& rPage, const LayoutDescriptor& rDescriptor, std::vector< SdrObject* >& rShapes, bool bInit, bool bSwitchLayout ) 1395 { 1396 int i; 1397 1398 // init list of indexes for each presentation shape kind 1399 // this is used to find subsequent shapes with the same presentation shape kind 1400 int PresObjIndex[PRESOBJ_MAX]; 1401 for( i = 0; i < PRESOBJ_MAX; i++ ) PresObjIndex[i] = 1; 1402 1403 bool bMissing = false; 1404 1405 // for each entry in the layoutdescriptor, arrange a presentation shape 1406 for (i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PRESOBJ_NONE); i++) 1407 { 1408 PresObjKind eKind = rDescriptor.meKind[i]; 1409 SdrObject* pObj = 0; 1410 while( (pObj = rPage.GetPresObj( eKind, PresObjIndex[eKind], true )) != 0 ) 1411 { 1412 PresObjIndex[eKind]++; // on next search for eKind, find next shape with same eKind 1413 1414 if( !bSwitchLayout || !pObj->IsEmptyPresObj() ) 1415 { 1416 rShapes[i] = pObj; 1417 break; 1418 } 1419 } 1420 1421 if( !pObj ) 1422 bMissing = true; 1423 } 1424 1425 if( bMissing && bInit ) 1426 { 1427 // for each entry in the layoutdescriptor, look for an alternative shape 1428 for (i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PRESOBJ_NONE); i++) 1429 { 1430 if( rShapes[i] ) 1431 continue; 1432 1433 PresObjKind eKind = rDescriptor.meKind[i]; 1434 1435 SdrObject* pObj = 0; 1436 bool bFound = false; 1437 1438 const int nShapeCount = rPage.GetObjCount(); 1439 int nShapeIndex = 0; 1440 while((nShapeIndex < nShapeCount) && !bFound ) 1441 { 1442 pObj = rPage.GetObj(nShapeIndex++); 1443 1444 if( pObj->IsEmptyPresObj() ) 1445 continue; 1446 1447 if( pObj->GetObjInventor() != SdrInventor ) 1448 continue; 1449 1450 // do not reuse shapes that are already part of the layout 1451 if( std::find( rShapes.begin(), rShapes.end(), pObj ) != rShapes.end() ) 1452 continue; 1453 1454 bool bPresStyle = pObj->GetStyleSheet() && (pObj->GetStyleSheet()->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE); 1455 SdrObjKind eSdrObjKind = static_cast< SdrObjKind >( pObj->GetObjIdentifier() ); 1456 1457 switch( eKind ) 1458 { 1459 case PRESOBJ_TITLE: 1460 bFound = eSdrObjKind == OBJ_TITLETEXT; 1461 break; 1462 case PRESOBJ_TABLE: 1463 bFound = eSdrObjKind == OBJ_TABLE; 1464 break; 1465 case PRESOBJ_MEDIA: 1466 bFound = eSdrObjKind == OBJ_MEDIA; 1467 break; 1468 case PRESOBJ_OUTLINE: 1469 bFound = (eSdrObjKind == OBJ_OUTLINETEXT) || 1470 ((eSdrObjKind == OBJ_TEXT) && bPresStyle) || 1471 (eSdrObjKind == OBJ_TABLE) || (eSdrObjKind == OBJ_MEDIA) || (eSdrObjKind == OBJ_GRAF) || (eSdrObjKind == OBJ_OLE2); 1472 break; 1473 case PRESOBJ_GRAPHIC: 1474 bFound = eSdrObjKind == OBJ_GRAF; 1475 break; 1476 case PRESOBJ_OBJECT: 1477 if( eSdrObjKind == OBJ_OLE2 ) 1478 { 1479 SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj ); 1480 if( pOle2 ) 1481 { 1482 if( pOle2->IsEmpty() ) 1483 bFound = true; 1484 else if( rPage.GetModel() ) 1485 { 1486 SdrModel* pSdrModel = rPage.GetModel(); 1487 ::comphelper::IEmbeddedHelper *pPersist = pSdrModel->GetPersist(); 1488 if( pPersist ) 1489 { 1490 uno::Reference < embed::XEmbeddedObject > xObject = pPersist->getEmbeddedObjectContainer(). 1491 GetEmbeddedObject( static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ); 1492 1493 // TODO CL->KA: Why is this not working anymore? 1494 if( xObject.is() ) 1495 { 1496 SvGlobalName aClassId( xObject->getClassID() ); 1497 1498 const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID ); 1499 const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID ); 1500 const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID ); 1501 1502 if( aPluginClassId != aClassId && aAppletClassId != aClassId && aIFrameClassId != aClassId ) 1503 { 1504 bFound = true; 1505 } 1506 } 1507 } 1508 } 1509 } 1510 } 1511 break; 1512 case PRESOBJ_CHART: 1513 case PRESOBJ_CALC: 1514 if( eSdrObjKind == OBJ_OLE2 ) 1515 { 1516 SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj ); 1517 if( pOle2 ) 1518 { 1519 if( 1520 ((eKind == PRESOBJ_CHART) && 1521 ( pOle2->GetProgName().EqualsAscii( "StarChart" ) || pOle2->IsChart() ) ) 1522 || 1523 ((eKind == PRESOBJ_CALC) && 1524 ( pOle2->GetProgName().EqualsAscii( "StarCalc" ) || pOle2->IsCalc() ) ) ) 1525 { 1526 bFound = true; 1527 } 1528 } 1529 break; 1530 } 1531 else if( eSdrObjKind == OBJ_TABLE ) 1532 { 1533 bFound = true; 1534 } 1535 break; 1536 case PRESOBJ_PAGE: 1537 case PRESOBJ_HANDOUT: 1538 bFound = eSdrObjKind == OBJ_PAGE; 1539 break; 1540 case PRESOBJ_NOTES: 1541 case PRESOBJ_TEXT: 1542 bFound = (bPresStyle && (eSdrObjKind == OBJ_TEXT)) || (eSdrObjKind == OBJ_OUTLINETEXT); 1543 break; 1544 default: 1545 break; 1546 } 1547 } 1548 1549 if( bFound ) 1550 rShapes[i] = pObj; 1551 } 1552 } 1553 } 1554 1555 void SdPage::SetAutoLayout(AutoLayout eLayout, sal_Bool bInit, sal_Bool bCreate ) 1556 { 1557 sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement ); 1558 1559 const bool bSwitchLayout = eLayout != GetAutoLayout(); 1560 1561 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 1562 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted(); 1563 1564 meAutoLayout = eLayout; 1565 1566 // if needed, creates and initialises the presentation shapes on this slides master page 1567 CreateTitleAndLayout(bInit, bCreate); 1568 1569 if((meAutoLayout == AUTOLAYOUT_NONE && maPresentationShapeList.isEmpty()) || mbMaster) 1570 { 1571 // MasterPage or no layout and no presentation shapes available, noting to do 1572 return; 1573 } 1574 1575 Rectangle aRectangle[MAX_PRESOBJS]; 1576 const LayoutDescriptor& aDescriptor = GetLayoutDescriptor( meAutoLayout ); 1577 CalcAutoLayoutRectangles( *this, aDescriptor.mnLayout, aRectangle ); 1578 1579 std::set< SdrObject* > aUsedPresentationObjects; 1580 1581 1582 std::vector< SdrObject* > aLayoutShapes(PRESOBJ_MAX, 0); 1583 findAutoLayoutShapesImpl( *this, aDescriptor, aLayoutShapes, bInit, bSwitchLayout ); 1584 1585 int i; 1586 1587 // for each entry in the layoutdescriptor, arrange a presentation shape 1588 for (i = 0; (i < MAX_PRESOBJS) && (aDescriptor.meKind[i] != PRESOBJ_NONE); i++) 1589 { 1590 PresObjKind eKind = aDescriptor.meKind[i]; 1591 SdrObject* pObj = InsertAutoLayoutShape( aLayoutShapes[i], eKind, aDescriptor.mbVertical[i], aRectangle[i], bInit ); 1592 if( pObj ) 1593 aUsedPresentationObjects.insert(pObj); // remember that we used this empty shape 1594 } 1595 1596 // now delete all empty presentation objects that are no longer used by the new layout 1597 if( bInit ) 1598 { 1599 SdrObject* pObj = maPresentationShapeList.getNextShape(0); 1600 1601 while( pObj ) 1602 { 1603 SdrObject* pNext = maPresentationShapeList.getNextShape(pObj); 1604 if( aUsedPresentationObjects.count(pObj) == 0 ) 1605 { 1606 1607 if( pObj->IsEmptyPresObj() ) 1608 { 1609 if( bUndo ) 1610 pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); 1611 1612 RemoveObject( pObj->GetOrdNum() ); 1613 1614 if( !bUndo ) 1615 SdrObject::Free( pObj ); 1616 } 1617 /* #i108541# keep non empty pres obj as pres obj even if they are not part of the current layout 1618 else 1619 { 1620 if( bUndo ) 1621 { 1622 pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pObj ) ); 1623 if( pObj->GetUserCall() ) 1624 pUndoManager->AddUndoAction( new UndoObjectUserCall( *pObj ) ); 1625 } 1626 maPresentationShapeList.removeShape( *pObj ); 1627 pObj->SetUserCall(0); 1628 } 1629 */ 1630 } 1631 pObj = pNext; 1632 } 1633 } 1634 } 1635 1636 /************************************************************************* 1637 |* 1638 |* Objekt einfuegen 1639 |* 1640 \************************************************************************/ 1641 1642 void SdPage::NbcInsertObject(SdrObject* pObj, sal_uLong nPos, const SdrInsertReason* pReason) 1643 { 1644 FmFormPage::NbcInsertObject(pObj, nPos, pReason); 1645 1646 ((SdDrawDocument*) pModel)->InsertObject(pObj, this); 1647 1648 SdrLayerID nId = pObj->GetLayer(); 1649 if( mbMaster ) 1650 { 1651 if( nId == 0 ) 1652 pObj->NbcSetLayer( 2 ); // wrong layer. corrected to BackgroundObj layer 1653 } 1654 else 1655 { 1656 if( nId == 2 ) 1657 pObj->NbcSetLayer( 0 ); // wrong layer. corrected to layout layer 1658 } 1659 } 1660 1661 /************************************************************************* 1662 |* 1663 |* Objekt loeschen 1664 |* 1665 \************************************************************************/ 1666 1667 SdrObject* SdPage::RemoveObject(sal_uLong nObjNum) 1668 { 1669 onRemoveObject(GetObj( nObjNum )); 1670 return FmFormPage::RemoveObject(nObjNum); 1671 } 1672 1673 /************************************************************************* 1674 |* 1675 |* Objekt loeschen, ohne Broadcast 1676 |* 1677 \************************************************************************/ 1678 1679 SdrObject* SdPage::NbcRemoveObject(sal_uLong nObjNum) 1680 { 1681 onRemoveObject(GetObj( nObjNum )); 1682 return FmFormPage::NbcRemoveObject(nObjNum); 1683 } 1684 1685 // #95876# Also overload ReplaceObject methods to realize when 1686 // objects are removed with this mechanism instead of RemoveObject 1687 SdrObject* SdPage::NbcReplaceObject(SdrObject* pNewObj, sal_uLong nObjNum) 1688 { 1689 onRemoveObject(GetObj( nObjNum )); 1690 return FmFormPage::NbcReplaceObject(pNewObj, nObjNum); 1691 } 1692 1693 // #95876# Also overload ReplaceObject methods to realize when 1694 // objects are removed with this mechanism instead of RemoveObject 1695 SdrObject* SdPage::ReplaceObject(SdrObject* pNewObj, sal_uLong nObjNum) 1696 { 1697 onRemoveObject(GetObj( nObjNum )); 1698 return FmFormPage::ReplaceObject(pNewObj, nObjNum); 1699 } 1700 1701 // ------------------------------------------------------------------------- 1702 1703 // called after a shape is removed or replaced from this slide 1704 1705 void SdPage::onRemoveObject( SdrObject* pObject ) 1706 { 1707 if( pObject ) 1708 { 1709 RemovePresObj(pObject); 1710 1711 if( pModel ) 1712 static_cast<SdDrawDocument*>(pModel)->RemoveObject(pObject, this); 1713 1714 removeAnimations( pObject ); 1715 } 1716 } 1717 1718 /************************************************************************* 1719 |* 1720 |* 1721 |* 1722 \************************************************************************/ 1723 1724 void SdPage::SetSize(const Size& aSize) 1725 { 1726 Size aOldSize = GetSize(); 1727 1728 if (aSize != aOldSize) 1729 { 1730 FmFormPage::SetSize(aSize); 1731 1732 if (aOldSize.Height() == 10 && aOldSize.Width() == 10) 1733 { 1734 // Die Seite bekommt erstmalig eine gueltige Groesse gesetzt, 1735 // daher wird nun die Orientation initialisiert 1736 if (aSize.Width() > aSize.Height()) 1737 { 1738 meOrientation = ORIENTATION_LANDSCAPE; 1739 } 1740 else 1741 { 1742 meOrientation = ORIENTATION_PORTRAIT; 1743 } 1744 } 1745 } 1746 } 1747 1748 1749 /************************************************************************* 1750 |* 1751 |* 1752 |* 1753 \************************************************************************/ 1754 1755 void SdPage::SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 nLwr) 1756 { 1757 if (nLft != GetLftBorder() || nUpp != GetUppBorder() || 1758 nRgt != GetRgtBorder() || nLwr != GetLwrBorder() ) 1759 { 1760 FmFormPage::SetBorder(nLft, nUpp, nRgt, nLwr); 1761 } 1762 } 1763 1764 1765 /************************************************************************* 1766 |* 1767 |* 1768 |* 1769 \************************************************************************/ 1770 1771 void SdPage::SetLftBorder(sal_Int32 nBorder) 1772 { 1773 if (nBorder != GetLftBorder() ) 1774 { 1775 FmFormPage::SetLftBorder(nBorder); 1776 } 1777 } 1778 1779 1780 /************************************************************************* 1781 |* 1782 |* 1783 |* 1784 \************************************************************************/ 1785 1786 void SdPage::SetRgtBorder(sal_Int32 nBorder) 1787 { 1788 if (nBorder != GetRgtBorder() ) 1789 { 1790 FmFormPage::SetRgtBorder(nBorder); 1791 } 1792 } 1793 1794 1795 /************************************************************************* 1796 |* 1797 |* 1798 |* 1799 \************************************************************************/ 1800 1801 void SdPage::SetUppBorder(sal_Int32 nBorder) 1802 { 1803 if (nBorder != GetUppBorder() ) 1804 { 1805 FmFormPage::SetUppBorder(nBorder); 1806 } 1807 } 1808 1809 1810 /************************************************************************* 1811 |* 1812 |* 1813 |* 1814 \************************************************************************/ 1815 1816 void SdPage::SetLwrBorder(sal_Int32 nBorder) 1817 { 1818 if (nBorder != GetLwrBorder() ) 1819 { 1820 FmFormPage::SetLwrBorder(nBorder); 1821 } 1822 } 1823 1824 /************************************************************************* 1825 |* 1826 |* Setzt BackgroundFullSize und ruft dann AdjustBackground auf 1827 |* 1828 \************************************************************************/ 1829 1830 void SdPage::SetBackgroundFullSize( sal_Bool bIn ) 1831 { 1832 if( bIn != mbBackgroundFullSize ) 1833 { 1834 mbBackgroundFullSize = bIn; 1835 } 1836 } 1837 1838 /************************************************************************* 1839 |* 1840 |* Alle Objekte an neue Seitengroesse anpassen 1841 |* 1842 |* bScaleAllObj: Alle Objekte werden in die neue Flaeche innerhalb der 1843 |* Seitenraender skaliert. Dabei werden die Position, Groesse und bei 1844 |* Praesentationsobjekten auf der MasterPage auch die Schrifthoehe der 1845 |* Praesentationsvorlagen skaliert. 1846 |* 1847 \************************************************************************/ 1848 1849 void SdPage::ScaleObjects(const Size& rNewPageSize, const Rectangle& rNewBorderRect, sal_Bool bScaleAllObj) 1850 { 1851 sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement ); 1852 1853 mbScaleObjects = bScaleAllObj; 1854 SdrObject* pObj = NULL; 1855 Point aRefPnt(0, 0); 1856 Size aNewPageSize(rNewPageSize); 1857 sal_Int32 nLeft = rNewBorderRect.Left(); 1858 sal_Int32 nRight = rNewBorderRect.Right(); 1859 sal_Int32 nUpper = rNewBorderRect.Top(); 1860 sal_Int32 nLower = rNewBorderRect.Bottom(); 1861 1862 // Negative Werte stehen fuer nicht zu aendernde Werte 1863 // -> aktuelle Werte verwenden 1864 if (aNewPageSize.Width() < 0) 1865 { 1866 aNewPageSize.Width() = GetWdt(); 1867 } 1868 if (aNewPageSize.Height() < 0) 1869 { 1870 aNewPageSize.Height() = GetHgt(); 1871 } 1872 if (nLeft < 0) 1873 { 1874 nLeft = GetLftBorder(); 1875 } 1876 if (nRight < 0) 1877 { 1878 nRight = GetRgtBorder(); 1879 } 1880 if (nUpper < 0) 1881 { 1882 nUpper = GetUppBorder(); 1883 } 1884 if (nLower < 0) 1885 { 1886 nLower = GetLwrBorder(); 1887 } 1888 1889 Point aBackgroundPos(nLeft, nUpper); 1890 Size aBackgroundSize(aNewPageSize); 1891 Rectangle aBorderRect (aBackgroundPos, aBackgroundSize); 1892 1893 if (mbScaleObjects) 1894 { 1895 aBackgroundSize.Width() -= nLeft + nRight; 1896 aBackgroundSize.Height() -= nUpper + nLower; 1897 aBorderRect.SetSize(aBackgroundSize); 1898 aNewPageSize = aBackgroundSize; 1899 } 1900 1901 long nOldWidth = GetWdt() - GetLftBorder() - GetRgtBorder(); 1902 long nOldHeight = GetHgt() - GetUppBorder() - GetLwrBorder(); 1903 1904 Fraction aFractX = Fraction(aNewPageSize.Width(), nOldWidth); 1905 Fraction aFractY = Fraction(aNewPageSize.Height(), nOldHeight); 1906 1907 sal_uLong nObjCnt = (mbScaleObjects ? GetObjCount() : 0); 1908 1909 for (sal_uLong nObj = 0; nObj < nObjCnt; nObj++) 1910 { 1911 sal_Bool bIsPresObjOnMaster = sal_False; 1912 1913 // Alle Objekte 1914 pObj = GetObj(nObj); 1915 1916 if (mbMaster && IsPresObj(pObj)) 1917 { 1918 // Es ist ein Praesentationsobjekt auf der MasterPage 1919 bIsPresObjOnMaster = sal_True; 1920 } 1921 1922 if (pObj) 1923 { 1924 // #88084# remember aTopLeft as original TopLeft 1925 Point aTopLeft(pObj->GetCurrentBoundRect().TopLeft()); 1926 1927 if (!pObj->IsEdgeObj()) 1928 { 1929 /************************************************************** 1930 * Objekt skalieren 1931 **************************************************************/ 1932 if (mbScaleObjects) 1933 { 1934 // #88084# use aTopLeft as original TopLeft 1935 aRefPnt = aTopLeft; 1936 } 1937 1938 pObj->Resize(aRefPnt, aFractX, aFractY); 1939 1940 if (mbScaleObjects) 1941 { 1942 SdrObjKind eObjKind = (SdrObjKind) pObj->GetObjIdentifier(); 1943 1944 if (bIsPresObjOnMaster) 1945 { 1946 /********************************************************** 1947 * Praesentationsvorlage: Texthoehe anpassen 1948 **********************************************************/ 1949 sal_uInt16 nIndexTitle = 0; 1950 sal_uInt16 nIndexOutline = 0; 1951 sal_uInt16 nIndexNotes = 0; 1952 1953 if (pObj == GetPresObj(PRESOBJ_TITLE, nIndexTitle)) 1954 { 1955 SfxStyleSheet* pTitleSheet = GetStyleSheetForPresObj(PRESOBJ_TITLE); 1956 1957 if (pTitleSheet) 1958 { 1959 SfxItemSet& rSet = pTitleSheet->GetItemSet(); 1960 1961 SvxFontHeightItem& rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT); 1962 sal_uLong nFontHeight = rOldHgt.GetHeight(); 1963 nFontHeight = long(nFontHeight * (double) aFractY); 1964 rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT)); 1965 1966 if( SFX_ITEM_AVAILABLE == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) ) 1967 { 1968 rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT_CJK); 1969 nFontHeight = rOldHgt.GetHeight(); 1970 nFontHeight = long(nFontHeight * (double) aFractY); 1971 rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK)); 1972 } 1973 1974 if( SFX_ITEM_AVAILABLE == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) ) 1975 { 1976 rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT_CTL); 1977 nFontHeight = rOldHgt.GetHeight(); 1978 nFontHeight = long(nFontHeight * (double) aFractY); 1979 rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL)); 1980 } 1981 1982 pTitleSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 1983 } 1984 } 1985 else if (pObj == GetPresObj(PRESOBJ_OUTLINE, nIndexOutline)) 1986 { 1987 String aName(GetLayoutName()); 1988 aName += sal_Unicode( ' ' ); 1989 1990 for (sal_uInt16 i=1; i<=9; i++) 1991 { 1992 String sLayoutName(aName); 1993 sLayoutName += String::CreateFromInt32( (sal_Int32)i ); 1994 SfxStyleSheet* pOutlineSheet = (SfxStyleSheet*)((SdDrawDocument*) pModel)->GetStyleSheetPool()->Find(sLayoutName, SD_STYLE_FAMILY_MASTERPAGE); 1995 1996 if (pOutlineSheet) 1997 { 1998 // Neue Fonthoehe berechnen 1999 SfxItemSet aTempSet(pOutlineSheet->GetItemSet()); 2000 2001 SvxFontHeightItem& rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT); 2002 sal_uLong nFontHeight = rOldHgt.GetHeight(); 2003 nFontHeight = long(nFontHeight * (double) aFractY); 2004 aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT)); 2005 2006 if( SFX_ITEM_AVAILABLE == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) ) 2007 { 2008 rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT_CJK); 2009 nFontHeight = rOldHgt.GetHeight(); 2010 nFontHeight = long(nFontHeight * (double) aFractY); 2011 aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK)); 2012 } 2013 2014 if( SFX_ITEM_AVAILABLE == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) ) 2015 { 2016 rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT_CTL); 2017 nFontHeight = rOldHgt.GetHeight(); 2018 nFontHeight = long(nFontHeight * (double) aFractY); 2019 aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL)); 2020 } 2021 2022 // Bullet anpassen 2023 ((SdStyleSheet*) pOutlineSheet)->AdjustToFontHeight(aTempSet, sal_False); 2024 2025 // Sonderbehandlung: die INVALIDS auf NULL-Pointer 2026 // zurueckgesetzen (sonst landen INVALIDs oder 2027 // Pointer auf die DefaultItems in der Vorlage; 2028 // beides wuerde die Attribut-Vererbung unterbinden) 2029 aTempSet.ClearInvalidItems(); 2030 2031 // Sonderbehandlung: nur die gueltigen Anteile des 2032 // BulletItems 2033 if (aTempSet.GetItemState(EE_PARA_BULLET) == SFX_ITEM_AVAILABLE) 2034 { 2035 SvxBulletItem aOldBulItem((SvxBulletItem&) pOutlineSheet->GetItemSet().Get(EE_PARA_BULLET)); 2036 SvxBulletItem& rNewBulItem = (SvxBulletItem&) aTempSet.Get(EE_PARA_BULLET); 2037 aOldBulItem.CopyValidProperties(rNewBulItem); 2038 aTempSet.Put(aOldBulItem); 2039 } 2040 2041 pOutlineSheet->GetItemSet().Put(aTempSet); 2042 pOutlineSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 2043 } 2044 } 2045 } 2046 else if (pObj == GetPresObj(PRESOBJ_NOTES, nIndexNotes)) 2047 { 2048 SfxStyleSheet* pNotesSheet = GetStyleSheetForPresObj(PRESOBJ_NOTES); 2049 2050 if (pNotesSheet) 2051 { 2052 sal_uLong nHeight = pObj->GetLogicRect().GetSize().Height(); 2053 sal_uLong nFontHeight = (sal_uLong) (nHeight * 0.0741); 2054 SfxItemSet& rSet = pNotesSheet->GetItemSet(); 2055 rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT )); 2056 rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK )); 2057 rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL )); 2058 pNotesSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 2059 } 2060 } 2061 } 2062 else if ( eObjKind != OBJ_TITLETEXT && 2063 eObjKind != OBJ_OUTLINETEXT && 2064 pObj->ISA(SdrTextObj) && 2065 pObj->GetOutlinerParaObject() ) 2066 { 2067 /****************************************************** 2068 * Normales Textobjekt: Texthoehe anpassen 2069 ******************************************************/ 2070 sal_uLong nScriptType = pObj->GetOutlinerParaObject()->GetTextObject().GetScriptType(); 2071 sal_uInt16 nWhich = EE_CHAR_FONTHEIGHT; 2072 if ( nScriptType == SCRIPTTYPE_ASIAN ) 2073 nWhich = EE_CHAR_FONTHEIGHT_CJK; 2074 else if ( nScriptType == SCRIPTTYPE_COMPLEX ) 2075 nWhich = EE_CHAR_FONTHEIGHT_CTL; 2076 2077 // #88084# use more modern method to scale the text height 2078 sal_uInt32 nFontHeight = ((SvxFontHeightItem&)pObj->GetMergedItem(nWhich)).GetHeight(); 2079 sal_uInt32 nNewFontHeight = sal_uInt32((double)nFontHeight * (double)aFractY); 2080 2081 pObj->SetMergedItem(SvxFontHeightItem(nNewFontHeight, 100, nWhich)); 2082 } 2083 } 2084 } 2085 2086 if (mbScaleObjects && !pObj->IsEdgeObj()) 2087 { 2088 /************************************************************** 2089 * Objektposition skalieren 2090 **************************************************************/ 2091 Point aNewPos; 2092 2093 // #76447# corrected scaling; only distances may be scaled 2094 // #88084# use aTopLeft as original TopLeft 2095 aNewPos.X() = long((aTopLeft.X() - GetLftBorder()) * (double)aFractX) + nLeft; 2096 aNewPos.Y() = long((aTopLeft.Y() - GetUppBorder()) * (double)aFractY) + nUpper; 2097 2098 Size aVec(aNewPos.X() - aTopLeft.X(), aNewPos.Y() - aTopLeft.Y()); 2099 2100 if (aVec.Height() != 0 || aVec.Width() != 0) 2101 { 2102 pObj->NbcMove(aVec); 2103 } 2104 2105 pObj->SetChanged(); 2106 pObj->BroadcastObjectChange(); 2107 } 2108 } 2109 } 2110 } 2111 2112 SdrObject* convertPresentationObjectImpl( SdPage& rPage, SdrObject* pSourceObj, PresObjKind& eObjKind, bool bVertical, Rectangle aRect ) 2113 { 2114 SdDrawDocument* pModel = static_cast< SdDrawDocument* >( rPage.GetModel() ); 2115 DBG_ASSERT( pModel, "sd::convertPresentationObjectImpl(), no model on page!" ); 2116 if( !pModel || !pSourceObj ) 2117 return pSourceObj; 2118 2119 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 2120 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && rPage.IsInserted(); 2121 2122 SdrObject* pNewObj = pSourceObj; 2123 if((eObjKind == PRESOBJ_OUTLINE) && (pSourceObj->GetObjIdentifier() == OBJ_TEXT) ) 2124 { 2125 pNewObj = rPage.CreatePresObj(PRESOBJ_OUTLINE, bVertical, aRect); 2126 2127 // Text des Untertitels in das PRESOBJ_OUTLINE setzen 2128 OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject(); 2129 2130 if(pOutlParaObj) 2131 { 2132 // Text umsetzen 2133 ::sd::Outliner* pOutl = pModel->GetInternalOutliner( sal_True ); 2134 pOutl->Clear(); 2135 pOutl->SetText( *pOutlParaObj ); 2136 pOutlParaObj = pOutl->CreateParaObject(); 2137 pNewObj->SetOutlinerParaObject( pOutlParaObj ); 2138 pOutl->Clear(); 2139 pNewObj->SetEmptyPresObj(sal_False); 2140 2141 for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++) 2142 { 2143 // Neue Vorlage zuweisen 2144 String aName(rPage.GetLayoutName()); 2145 aName += sal_Unicode( ' ' ); 2146 aName += String::CreateFromInt32( nLevel ); 2147 SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>( pModel->GetStyleSheetPool()->Find(aName, SD_STYLE_FAMILY_MASTERPAGE) ); 2148 2149 if (pSheet) 2150 { 2151 if (nLevel == 1) 2152 { 2153 SfxStyleSheet* pSubtitleSheet = rPage.GetStyleSheetForPresObj(PRESOBJ_TEXT); 2154 2155 if (pSubtitleSheet) 2156 pOutlParaObj->ChangeStyleSheetName(SD_STYLE_FAMILY_MASTERPAGE, pSubtitleSheet->GetName(), pSheet->GetName()); 2157 } 2158 2159 pNewObj->StartListening(*pSheet); 2160 } 2161 } 2162 2163 // LRSpace-Item loeschen 2164 SfxItemSet aSet(pModel->GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE ); 2165 2166 aSet.Put(pNewObj->GetMergedItemSet()); 2167 2168 aSet.ClearItem(EE_PARA_LRSPACE); 2169 2170 pNewObj->SetMergedItemSet(aSet); 2171 2172 if( bUndo ) 2173 pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj) ); 2174 2175 // Remove outline shape from page 2176 rPage.RemoveObject( pSourceObj->GetOrdNum() ); 2177 2178 if( !bUndo ) 2179 SdrObject::Free( pSourceObj ); 2180 } 2181 } 2182 else if((eObjKind == PRESOBJ_TEXT) && (pSourceObj->GetObjIdentifier() == OBJ_OUTLINETEXT) ) 2183 { 2184 // is there an outline shape we can use to replace empty subtitle shape? 2185 pNewObj = rPage.CreatePresObj(PRESOBJ_TEXT, bVertical, aRect); 2186 2187 // Text des Gliederungsobjekts in das PRESOBJ_TITLE setzen 2188 OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject(); 2189 2190 if(pOutlParaObj) 2191 { 2192 // Text umsetzen 2193 ::sd::Outliner* pOutl = pModel->GetInternalOutliner(); 2194 pOutl->Clear(); 2195 pOutl->SetText( *pOutlParaObj ); 2196 pOutlParaObj = pOutl->CreateParaObject(); 2197 pNewObj->SetOutlinerParaObject( pOutlParaObj ); 2198 pOutl->Clear(); 2199 pNewObj->SetEmptyPresObj(sal_False); 2200 2201 // Linken Einzug zuruecksetzen 2202 SfxItemSet aSet(pModel->GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE ); 2203 2204 aSet.Put(pNewObj->GetMergedItemSet()); 2205 2206 const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&) aSet.Get(EE_PARA_LRSPACE); 2207 SvxLRSpaceItem aNewLRItem(rLRItem); 2208 aNewLRItem.SetTxtLeft(0); 2209 aSet.Put(aNewLRItem); 2210 2211 pNewObj->SetMergedItemSet(aSet); 2212 2213 SfxStyleSheet* pSheet = rPage.GetStyleSheetForPresObj(PRESOBJ_TEXT); 2214 if (pSheet) 2215 pNewObj->SetStyleSheet(pSheet, sal_True); 2216 2217 // Remove subtitle shape from page 2218 if( bUndo ) 2219 pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj)); 2220 2221 rPage.RemoveObject( pSourceObj->GetOrdNum() ); 2222 2223 if( !bUndo ) 2224 SdrObject::Free( pSourceObj ); 2225 } 2226 } 2227 else if((eObjKind == PRESOBJ_OUTLINE) && (pSourceObj->GetObjIdentifier() != OBJ_OUTLINETEXT) ) 2228 { 2229 switch( pSourceObj->GetObjIdentifier() ) 2230 { 2231 case OBJ_TABLE: eObjKind = PRESOBJ_TABLE; break; 2232 case OBJ_MEDIA: eObjKind = PRESOBJ_MEDIA; break; 2233 case OBJ_GRAF: eObjKind = PRESOBJ_GRAPHIC; break; 2234 case OBJ_OLE2: eObjKind = PRESOBJ_OBJECT; break; 2235 } 2236 } 2237 2238 return pNewObj; 2239 } 2240 2241 /** reuses or creates a presentation shape for an auto layout that fits the given parameter 2242 2243 @param eObjKind 2244 The kind of presentation shape we like to have 2245 @param nIndex 2246 If > 1 we skip the first nIndex-1 shapes with the presentation shape kind eObjKind while 2247 looking for an existing presentation shape 2248 @param bVertical 2249 If true, the shape is created vertical if bInit is true 2250 @param aRect 2251 The rectangle that should be used to transform the shape 2252 @param bInit 2253 If true the shape is created if not found 2254 @returns 2255 A presentation shape that was either found or created with the given parameters 2256 */ 2257 SdrObject* SdPage::InsertAutoLayoutShape( SdrObject* pObj, PresObjKind eObjKind, bool bVertical, Rectangle aRect, bool bInit ) 2258 { 2259 ::svl::IUndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; 2260 const bool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted(); 2261 2262 if (!pObj && bInit) 2263 { 2264 pObj = CreatePresObj(eObjKind, bVertical, aRect); 2265 } 2266 else if ( pObj && (pObj->GetUserCall() || bInit) ) 2267 { 2268 // convert object if shape type does not match kind (f.e. converting outline text to subtitle text) 2269 if( bInit ) 2270 pObj = convertPresentationObjectImpl( *this, pObj, eObjKind, bVertical, aRect ); 2271 2272 if( bUndo ) 2273 { 2274 pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) ); 2275 pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoAttrObject( *pObj, sal_True, sal_True ) ); 2276 pUndoManager->AddUndoAction( new UndoObjectUserCall( *pObj ) ); 2277 } 2278 2279 // if ( pObj->ISA(SdrGrafObj) && !pObj->IsEmptyPresObj() ) 2280 ( /*(SdrGrafObj*)*/ pObj)->AdjustToMaxRect( aRect ); 2281 // else 2282 // SetLogicRect( pObj, aRect ); 2283 2284 pObj->SetUserCall(this); 2285 2286 SdrTextObj* pTextObject = dynamic_cast< SdrTextObj* >(pObj); 2287 if( pTextObject ) 2288 { 2289 if( pTextObject->IsVerticalWriting() != (bVertical ? sal_True : sal_False) ) 2290 { 2291 pTextObject->SetVerticalWriting( bVertical ); 2292 2293 // #94826# here make sure the correct anchoring is used when the object 2294 // is re-used but orientation is changed 2295 if(PRESOBJ_OUTLINE == eObjKind) 2296 pTextObject->SetMergedItem(SdrTextHorzAdjustItem( bVertical ? SDRTEXTHORZADJUST_RIGHT : SDRTEXTHORZADJUST_BLOCK )); 2297 } 2298 2299 if( !mbMaster && (pTextObject->GetObjIdentifier() != OBJ_TABLE) ) 2300 { 2301 if ( pTextObject->IsAutoGrowHeight() ) 2302 { 2303 // switch off AutoGrowHeight, set new MinHeight 2304 SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); 2305 SdrTextMinFrameHeightItem aMinHeight( aRect.GetSize().Height() ); 2306 aTempAttr.Put( aMinHeight ); 2307 aTempAttr.Put( SdrTextAutoGrowHeightItem(sal_False) ); 2308 pTextObject->SetMergedItemSet(aTempAttr); 2309 pTextObject->SetLogicRect(aRect); 2310 2311 // switch on AutoGrowHeight 2312 SfxItemSet aAttr( ((SdDrawDocument*) pModel)->GetPool() ); 2313 aAttr.Put( SdrTextAutoGrowHeightItem(sal_True) ); 2314 2315 pTextObject->SetMergedItemSet(aAttr); 2316 } 2317 2318 if ( pTextObject->IsAutoGrowWidth() ) 2319 { 2320 // switch off AutoGrowWidth , set new MinWidth 2321 SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); 2322 SdrTextMinFrameWidthItem aMinWidth( aRect.GetSize().Width() ); 2323 aTempAttr.Put( aMinWidth ); 2324 aTempAttr.Put( SdrTextAutoGrowWidthItem(sal_False) ); 2325 pTextObject->SetMergedItemSet(aTempAttr); 2326 pTextObject->SetLogicRect(aRect); 2327 2328 // switch on AutoGrowWidth 2329 SfxItemSet aAttr( ((SdDrawDocument*) pModel)->GetPool() ); 2330 aAttr.Put( SdrTextAutoGrowWidthItem(sal_True) ); 2331 pTextObject->SetMergedItemSet(aAttr); 2332 } 2333 } 2334 } 2335 } 2336 2337 if(pObj && bInit ) 2338 { 2339 if( !IsPresObj( pObj ) ) 2340 { 2341 if( bUndo ) 2342 pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pObj ) ); 2343 2344 InsertPresObj( pObj, eObjKind ); 2345 } 2346 2347 // make adjustments for vertical title and outline shapes 2348 if( bVertical && (( eObjKind == PRESOBJ_TITLE) || (eObjKind == PRESOBJ_OUTLINE))) 2349 { 2350 SfxItemSet aNewSet(pObj->GetMergedItemSet()); 2351 aNewSet.Put( SdrTextAutoGrowWidthItem(sal_True) ); 2352 aNewSet.Put( SdrTextAutoGrowHeightItem(sal_False) ); 2353 if( eObjKind == PRESOBJ_OUTLINE ) 2354 { 2355 aNewSet.Put( SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP) ); 2356 aNewSet.Put( SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT) ); 2357 } 2358 pObj->SetMergedItemSet(aNewSet); 2359 } 2360 } 2361 2362 if ( pObj && (pObj->GetUserCall() || bInit) && ( pObj->IsEmptyPresObj() || !pObj->ISA(SdrGrafObj) ) ) 2363 pObj->AdjustToMaxRect( aRect ); 2364 2365 return pObj; 2366 } 2367 2368 2369 /************************************************************************* 2370 |* 2371 |* Liefert den PresObjKind eines Objektes zurueck 2372 |* 2373 \************************************************************************/ 2374 2375 PresObjKind SdPage::GetPresObjKind(SdrObject* pObj) const 2376 { 2377 PresObjKind eKind = PRESOBJ_NONE; 2378 if( (pObj != 0) && (maPresentationShapeList.hasShape(*pObj)) ) 2379 { 2380 SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj); 2381 if( pInfo ) 2382 eKind = pInfo->mePresObjKind; 2383 } 2384 2385 return eKind; 2386 } 2387 2388 bool SdPage::IsPresObj(const SdrObject* pObj) 2389 { 2390 return pObj && maPresentationShapeList.hasShape( const_cast<SdrObject&>(*pObj) ); 2391 } 2392 2393 void SdPage::RemovePresObj(const SdrObject* pObj) 2394 { 2395 if( pObj && maPresentationShapeList.hasShape(const_cast<SdrObject&>(*pObj)) ) 2396 { 2397 SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(const_cast<SdrObject&>(*pObj)); 2398 if( pInfo ) 2399 pInfo->mePresObjKind = PRESOBJ_NONE; 2400 maPresentationShapeList.removeShape(const_cast<SdrObject&>(*pObj)); 2401 } 2402 } 2403 2404 void SdPage::InsertPresObj(SdrObject* pObj, PresObjKind eKind ) 2405 { 2406 DBG_ASSERT( pObj, "sd::SdPage::InsertPresObj(), invalid presentation object inserted!" ); 2407 DBG_ASSERT( !IsPresObj(pObj), "sd::SdPage::InsertPresObj(), presentation object inserted twice!" ); 2408 if( pObj ) 2409 { 2410 SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj, true); 2411 if( pInfo ) 2412 pInfo->mePresObjKind = eKind; 2413 maPresentationShapeList.addShape(*pObj); 2414 } 2415 } 2416 2417 /************************************************************************* 2418 |* 2419 |* Text des Objektes setzen 2420 |* 2421 \************************************************************************/ 2422 2423 void SdPage::SetObjText(SdrTextObj* pObj, SdrOutliner* pOutliner, PresObjKind eObjKind, const String& rString ) 2424 { 2425 if ( pObj ) 2426 { 2427 DBG_ASSERT( pObj->ISA(SdrTextObj), "SetObjText: Kein SdrTextObj!" ); 2428 ::Outliner* pOutl = pOutliner; 2429 2430 if (!pOutliner) 2431 { 2432 SfxItemPool* pPool = ((SdDrawDocument*) GetModel())->GetDrawOutliner().GetEmptyItemSet().GetPool(); 2433 pOutl = new ::Outliner( pPool, OUTLINERMODE_OUTLINEOBJECT ); 2434 pOutl->SetRefDevice( SD_MOD()->GetRefDevice( *( (SdDrawDocument*) GetModel() )->GetDocSh() ) ); 2435 pOutl->SetEditTextObjectPool(pPool); 2436 pOutl->SetStyleSheetPool((SfxStyleSheetPool*)GetModel()->GetStyleSheetPool()); 2437 pOutl->EnableUndo(sal_False); 2438 pOutl->SetUpdateMode( sal_False ); 2439 } 2440 2441 sal_uInt16 nOutlMode = pOutl->GetMode(); 2442 Size aPaperSize = pOutl->GetPaperSize(); 2443 sal_Bool bUpdateMode = pOutl->GetUpdateMode(); 2444 pOutl->SetUpdateMode(sal_False); 2445 pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() ); 2446 2447 // #95114# Always set the object's StyleSheet at the Outliner to 2448 // use the current objects StyleSheet. Thus it's the same as in 2449 // SetText(...). 2450 // #95114# Moved this implementation from where SetObjText(...) was called 2451 // to inside this method to work even when outliner is fetched here. 2452 pOutl->SetStyleSheet(0, pObj->GetStyleSheet()); 2453 2454 String aString; 2455 2456 switch( eObjKind ) 2457 { 2458 case PRESOBJ_OUTLINE: 2459 { 2460 pOutl->Init( OUTLINERMODE_OUTLINEOBJECT ); 2461 2462 aString += sal_Unicode( '\t' ); 2463 aString += rString; 2464 2465 if (mbMaster) 2466 { 2467 pOutl->SetStyleSheet( 0, GetStyleSheetForPresObj(eObjKind) ); 2468 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t" )); 2469 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER2 ) ); 2470 2471 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t" )); 2472 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER3 ) ); 2473 2474 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t" )); 2475 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER4 ) ); 2476 2477 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t" )); 2478 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER5 ) ); 2479 2480 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t" )); 2481 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER6 ) ); 2482 2483 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t" )); 2484 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER7 ) ); 2485 2486 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t\t" )); 2487 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER8 ) ); 2488 2489 aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t\t\t" )); 2490 aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER9 ) ); 2491 } 2492 } 2493 break; 2494 2495 case PRESOBJ_TITLE: 2496 { 2497 pOutl->Init( OUTLINERMODE_TITLEOBJECT ); 2498 aString += rString; 2499 } 2500 break; 2501 2502 default: 2503 { 2504 pOutl->Init( OUTLINERMODE_TEXTOBJECT ); 2505 aString += rString; 2506 2507 // check if we need to add a text field 2508 SvxFieldData* pData = NULL; 2509 2510 switch( eObjKind ) 2511 { 2512 case PRESOBJ_HEADER: 2513 pData = new SvxHeaderField(); 2514 break; 2515 case PRESOBJ_FOOTER: 2516 pData = new SvxFooterField(); 2517 break; 2518 case PRESOBJ_SLIDENUMBER: 2519 pData = new SvxPageField(); 2520 break; 2521 case PRESOBJ_DATETIME: 2522 pData = new SvxDateTimeField(); 2523 break; 2524 default: 2525 break; 2526 } 2527 2528 if( pData ) 2529 { 2530 ESelection e; 2531 SvxFieldItem aField( *pData, EE_FEATURE_FIELD ); 2532 pOutl->QuickInsertField(aField,e); 2533 delete pData; 2534 } 2535 } 2536 break; 2537 } 2538 2539 pOutl->SetPaperSize( pObj->GetLogicRect().GetSize() ); 2540 2541 if( aString.Len() ) 2542 pOutl->SetText( aString, pOutl->GetParagraph( 0 ) ); 2543 2544 ( (SdrTextObj*) pObj)->SetOutlinerParaObject( pOutl->CreateParaObject() ); 2545 2546 if (!pOutliner) 2547 { 2548 delete pOutl; 2549 pOutl = NULL; 2550 } 2551 else 2552 { 2553 // Outliner restaurieren 2554 pOutl->Init( nOutlMode ); 2555 pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() ); 2556 pOutl->SetUpdateMode( bUpdateMode ); 2557 pOutl->SetPaperSize( aPaperSize ); 2558 } 2559 } 2560 } 2561 2562 /************************************************************************* 2563 |* 2564 |* Link & Daten von einem VControl empfangen 2565 |* 2566 \************************************************************************/ 2567 2568 void SdPage::SetLinkData(const String&, const String& ) 2569 { 2570 } 2571 2572 /************************************************************************* 2573 |* 2574 |* Layoutname setzen 2575 |* 2576 \************************************************************************/ 2577 void SdPage::SetLayoutName(String aName) 2578 { 2579 maLayoutName = aName; 2580 2581 if( mbMaster ) 2582 { 2583 String aSep( RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR) ); 2584 sal_uInt16 nPos = maLayoutName.Search( aSep ); 2585 if ( nPos != STRING_NOTFOUND ) 2586 { 2587 FmFormPage::SetName(maLayoutName.Copy(0, nPos)); 2588 } 2589 } 2590 } 2591 2592 2593 /************************************************************************* 2594 |* 2595 |* Seitenname zurueckgeben und ggf. generieren 2596 |* 2597 \************************************************************************/ 2598 2599 const String& SdPage::GetName() const 2600 { 2601 String aCreatedPageName( maCreatedPageName ); 2602 if (GetRealName().Len() == 0) 2603 { 2604 if ((mePageKind == PK_STANDARD || mePageKind == PK_NOTES) && !mbMaster) 2605 { 2606 // default name for handout pages 2607 sal_uInt16 nNum = (GetPageNum() + 1) / 2; 2608 2609 aCreatedPageName = String(SdResId(STR_PAGE)); 2610 aCreatedPageName += sal_Unicode( ' ' ); 2611 if( GetModel()->GetPageNumType() == SVX_NUMBER_NONE ) 2612 { 2613 // if the document has number none as a formating 2614 // for page numbers we still default to arabic numbering 2615 // to keep the default page names unique 2616 aCreatedPageName += String::CreateFromInt32( (sal_Int32)nNum ); 2617 } 2618 else 2619 { 2620 aCreatedPageName += ((SdDrawDocument*) GetModel())->CreatePageNumValue(nNum); 2621 } 2622 } 2623 else 2624 { 2625 /****************************************************************** 2626 * Defaultname fuer Handzettelseiten 2627 ******************************************************************/ 2628 aCreatedPageName = String(SdResId(STR_LAYOUT_DEFAULT_NAME)); 2629 } 2630 } 2631 else 2632 { 2633 aCreatedPageName = GetRealName(); 2634 } 2635 2636 if (mePageKind == PK_NOTES) 2637 { 2638 aCreatedPageName += sal_Unicode( ' ' ); 2639 aCreatedPageName += String(SdResId(STR_NOTES)); 2640 } 2641 else if (mePageKind == PK_HANDOUT && mbMaster) 2642 { 2643 aCreatedPageName += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( " (" )); 2644 aCreatedPageName += String(SdResId(STR_HANDOUT)); 2645 aCreatedPageName += sal_Unicode( ')' ); 2646 } 2647 2648 const_cast< SdPage* >(this)->maCreatedPageName = aCreatedPageName; 2649 return maCreatedPageName; 2650 } 2651 2652 /************************************************************************* 2653 |* 2654 |* 2655 |* 2656 \************************************************************************/ 2657 2658 void SdPage::SetOrientation( Orientation eOrient) 2659 { 2660 meOrientation = eOrient; 2661 } 2662 2663 /************************************************************************* 2664 |* 2665 |* 2666 |* 2667 \************************************************************************/ 2668 2669 Orientation SdPage::GetOrientation() const 2670 { 2671 return meOrientation; 2672 } 2673 2674 /************************************************************************* 2675 |* 2676 |* Liefert den Default-Text eines PresObjektes zurueck 2677 |* 2678 \************************************************************************/ 2679 2680 String SdPage::GetPresObjText(PresObjKind eObjKind) const 2681 { 2682 String aString; 2683 2684 if (eObjKind == PRESOBJ_TITLE) 2685 { 2686 if (mbMaster) 2687 { 2688 if (mePageKind != PK_NOTES) 2689 { 2690 aString = String ( SdResId( STR_PRESOBJ_MPTITLE ) ); 2691 } 2692 else 2693 { 2694 aString = String ( SdResId( STR_PRESOBJ_MPNOTESTITLE ) ); 2695 } 2696 } 2697 else 2698 { 2699 aString = String ( SdResId( STR_PRESOBJ_TITLE ) ); 2700 } 2701 } 2702 else if (eObjKind == PRESOBJ_OUTLINE) 2703 { 2704 if (mbMaster) 2705 { 2706 aString = String ( SdResId( STR_PRESOBJ_MPOUTLINE ) ); 2707 } 2708 else 2709 { 2710 aString = String ( SdResId( STR_PRESOBJ_OUTLINE ) ); 2711 } 2712 } 2713 else if (eObjKind == PRESOBJ_NOTES) 2714 { 2715 if (mbMaster) 2716 { 2717 aString = String ( SdResId( STR_PRESOBJ_MPNOTESTEXT ) ); 2718 } 2719 else 2720 { 2721 aString = String ( SdResId( STR_PRESOBJ_NOTESTEXT ) ); 2722 } 2723 } 2724 else if (eObjKind == PRESOBJ_TEXT) 2725 { 2726 aString = String ( SdResId( STR_PRESOBJ_TEXT ) ); 2727 } 2728 else if (eObjKind == PRESOBJ_GRAPHIC) 2729 { 2730 aString = String ( SdResId( STR_PRESOBJ_GRAPHIC ) ); 2731 } 2732 else if (eObjKind == PRESOBJ_OBJECT) 2733 { 2734 aString = String ( SdResId( STR_PRESOBJ_OBJECT ) ); 2735 } 2736 else if (eObjKind == PRESOBJ_CHART) 2737 { 2738 aString = String ( SdResId( STR_PRESOBJ_CHART ) ); 2739 } 2740 else if (eObjKind == PRESOBJ_ORGCHART) 2741 { 2742 aString = String ( SdResId( STR_PRESOBJ_ORGCHART ) ); 2743 } 2744 else if (eObjKind == PRESOBJ_CALC) 2745 { 2746 aString = String ( SdResId( STR_PRESOBJ_TABLE ) ); 2747 } 2748 2749 return(aString); 2750 } 2751 2752 extern uno::Reference< uno::XInterface > createUnoPageImpl( SdPage* pPage ); 2753 2754 uno::Reference< uno::XInterface > SdPage::createUnoPage() 2755 { 2756 return createUnoPageImpl( this ); 2757 } 2758 2759 /** returns the SdPage implementation for the given XDrawPage or 0 if not available */ 2760 SdPage* SdPage::getImplementation( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xPage ) 2761 { 2762 try 2763 { 2764 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( xPage, ::com::sun::star::uno::UNO_QUERY ); 2765 if( xUnoTunnel.is() ) 2766 { 2767 SvxDrawPage* pUnoPage = reinterpret_cast<SvxDrawPage*>(sal::static_int_cast<sal_uIntPtr>(xUnoTunnel->getSomething( SvxDrawPage::getUnoTunnelId()) ) ); 2768 if( pUnoPage ) 2769 return static_cast< SdPage* >( pUnoPage->GetSdrPage() ); 2770 } 2771 } 2772 catch( ::com::sun::star::uno::Exception& e ) 2773 { 2774 (void)e; 2775 DBG_ERROR("sd::SdPage::getImplementation(), exception cathced!" ); 2776 } 2777 2778 return 0; 2779 } 2780 2781 void SdPage::SetName (const String& rName) 2782 { 2783 String aOldName = GetName(); 2784 FmFormPage::SetName (rName); 2785 static_cast<SdDrawDocument*>(pModel)->UpdatePageRelativeURLs(aOldName, rName); 2786 ActionChanged(); 2787 } 2788 2789 const HeaderFooterSettings& SdPage::getHeaderFooterSettings() const 2790 { 2791 if( mePageKind == PK_HANDOUT && !mbMaster ) 2792 { 2793 return (((SdPage&)TRG_GetMasterPage()).maHeaderFooterSettings); 2794 } 2795 else 2796 { 2797 return maHeaderFooterSettings; 2798 } 2799 } 2800 2801 void SdPage::setHeaderFooterSettings( const sd::HeaderFooterSettings& rNewSettings ) 2802 { 2803 if( mePageKind == PK_HANDOUT && !mbMaster ) 2804 { 2805 (((SdPage&)TRG_GetMasterPage()).maHeaderFooterSettings) = rNewSettings; 2806 } 2807 else 2808 { 2809 maHeaderFooterSettings = rNewSettings; 2810 } 2811 2812 SetChanged(); 2813 2814 if(TRG_HasMasterPage()) 2815 { 2816 TRG_GetMasterPageDescriptorViewContact().ActionChanged(); 2817 2818 // #119056# For HeaderFooterSettings SdrObjects are used, but the properties 2819 // used are not part of their model data, but kept in SD. This data is applied 2820 // using a 'backdoor' on primitive creation. Thus, the normal mechanism to detect 2821 // object changes does not work here. It is neccessary to trigger updates here 2822 // directly. BroadcastObjectChange used for PagePreview invalidations, 2823 // flushViewObjectContacts used to invalidate and flush all visualizations in 2824 // edit views. 2825 SdPage* pMasterPage = dynamic_cast< SdPage* >(&TRG_GetMasterPage()); 2826 2827 if(pMasterPage) 2828 { 2829 SdrObject* pCandidate = 0; 2830 2831 pCandidate = pMasterPage->GetPresObj( PRESOBJ_HEADER ); 2832 2833 if(pCandidate) 2834 { 2835 pCandidate->BroadcastObjectChange(); 2836 pCandidate->GetViewContact().flushViewObjectContacts(); 2837 } 2838 2839 pCandidate = pMasterPage->GetPresObj( PRESOBJ_DATETIME ); 2840 2841 if(pCandidate) 2842 { 2843 pCandidate->BroadcastObjectChange(); 2844 pCandidate->GetViewContact().flushViewObjectContacts(); 2845 } 2846 2847 pCandidate = pMasterPage->GetPresObj( PRESOBJ_FOOTER ); 2848 2849 if(pCandidate) 2850 { 2851 pCandidate->BroadcastObjectChange(); 2852 pCandidate->GetViewContact().flushViewObjectContacts(); 2853 } 2854 2855 pCandidate = pMasterPage->GetPresObj( PRESOBJ_SLIDENUMBER ); 2856 2857 if(pCandidate) 2858 { 2859 pCandidate->BroadcastObjectChange(); 2860 pCandidate->GetViewContact().flushViewObjectContacts(); 2861 } 2862 } 2863 } 2864 } 2865 2866 bool SdPage::checkVisibility( 2867 const sdr::contact::ViewObjectContact& rOriginal, 2868 const sdr::contact::DisplayInfo& rDisplayInfo, 2869 bool bEdit ) 2870 { 2871 if( !FmFormPage::checkVisibility( rOriginal, rDisplayInfo, bEdit ) ) 2872 return false; 2873 2874 SdrObject* pObj = rOriginal.GetViewContact().TryToGetSdrObject(); 2875 if( pObj == NULL ) 2876 return false; 2877 2878 const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage()); 2879 const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter() || rOriginal.GetObjectContact().isOutputToPDFFile()); 2880 const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView(); 2881 const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage); 2882 2883 // empty presentation objects only visible during edit mode 2884 if( (bIsPrinting || !bEdit || bIsInsidePageObj ) && pObj->IsEmptyPresObj() ) 2885 { 2886 if( (pObj->GetObjInventor() != SdrInventor) || ( (pObj->GetObjIdentifier() != OBJ_RECT) && (pObj->GetObjIdentifier() != OBJ_PAGE) ) ) 2887 return false; 2888 } 2889 2890 if( ( pObj->GetObjInventor() == SdrInventor ) && ( pObj->GetObjIdentifier() == OBJ_TEXT ) ) 2891 { 2892 const SdPage* pCheckPage = dynamic_cast< const SdPage* >(pObj->GetPage()); 2893 2894 if( pCheckPage ) 2895 { 2896 PresObjKind eKind = pCheckPage->GetPresObjKind(pObj); 2897 2898 if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) ) 2899 { 2900 const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive()); 2901 2902 if( bSubContentProcessing || ( pCheckPage->GetPageKind() == PK_HANDOUT && bIsPrinting ) ) 2903 { 2904 // use the page that is currently processed 2905 const SdPage* pVisualizedSdPage = dynamic_cast< const SdPage* >(pVisualizedPage); 2906 2907 if( pVisualizedSdPage ) 2908 { 2909 // if we are not on a masterpage, see if we have to draw this header&footer object at all 2910 const sd::HeaderFooterSettings& rSettings = pVisualizedSdPage->getHeaderFooterSettings(); 2911 2912 switch( eKind ) 2913 { 2914 case PRESOBJ_FOOTER: 2915 return rSettings.mbFooterVisible; 2916 case PRESOBJ_HEADER: 2917 return rSettings.mbHeaderVisible; 2918 case PRESOBJ_DATETIME: 2919 return rSettings.mbDateTimeVisible; 2920 case PRESOBJ_SLIDENUMBER: 2921 return rSettings.mbSlideNumberVisible; 2922 default: 2923 break; 2924 } 2925 } 2926 } 2927 } // check for placeholders on master 2928 else if( (eKind != PRESOBJ_NONE) && pCheckPage->IsMasterPage() && ( pVisualizedPage != pCheckPage ) ) 2929 { 2930 // presentation objects on master slide are always invisible if slide is shown. 2931 return false; 2932 } 2933 } 2934 } 2935 2936 // i63977, do not print SdrpageObjs from master pages 2937 if( ( pObj->GetObjInventor() == SdrInventor ) && ( pObj->GetObjIdentifier() == OBJ_PAGE ) ) 2938 { 2939 if( pObj->GetPage() && pObj->GetPage()->IsMasterPage() ) 2940 return false; 2941 } 2942 2943 return true; 2944 } 2945 2946 bool SdPage::RestoreDefaultText( SdrObject* pObj ) 2947 { 2948 bool bRet = false; 2949 2950 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj ); 2951 2952 if( pTextObj ) 2953 { 2954 PresObjKind ePresObjKind = GetPresObjKind(pTextObj); 2955 2956 if (ePresObjKind == PRESOBJ_TITLE || 2957 ePresObjKind == PRESOBJ_OUTLINE || 2958 ePresObjKind == PRESOBJ_NOTES || 2959 ePresObjKind == PRESOBJ_TEXT) 2960 { 2961 String aString( GetPresObjText(ePresObjKind) ); 2962 2963 if (aString.Len()) 2964 { 2965 sal_Bool bVertical = sal_False; 2966 OutlinerParaObject* pOldPara = pTextObj->GetOutlinerParaObject(); 2967 if( pOldPara ) 2968 bVertical = pOldPara->IsVertical(); // is old para object vertical? 2969 2970 SetObjText( pTextObj, 0, ePresObjKind, aString ); 2971 2972 if( pOldPara ) 2973 { 2974 //pTextObj->SetVerticalWriting( bVertical ); 2975 // 2976 // #94826# Here, only the vertical flag for the 2977 // OutlinerParaObjects needs to be changed. The 2978 // AutoGrowWidth/Height items still exist in the 2979 // not changed object. 2980 if(pTextObj 2981 && pTextObj->GetOutlinerParaObject() 2982 && pTextObj->GetOutlinerParaObject()->IsVertical() != (bool)bVertical) 2983 { 2984 Rectangle aObjectRect = pTextObj->GetSnapRect(); 2985 pTextObj->GetOutlinerParaObject()->SetVertical(bVertical); 2986 pTextObj->SetSnapRect(aObjectRect); 2987 } 2988 } 2989 2990 pTextObj->SetTextEditOutliner( NULL ); // to make stylesheet settings work 2991 pTextObj->NbcSetStyleSheet( GetStyleSheetForPresObj(ePresObjKind), sal_True ); 2992 pTextObj->SetEmptyPresObj(sal_True); 2993 bRet = true; 2994 } 2995 } 2996 } 2997 return bRet; 2998 } 2999 3000 void SdPage::CalculateHandoutAreas( SdDrawDocument& rModel, AutoLayout eLayout, bool bHorizontal, std::vector< Rectangle >& rAreas ) 3001 { 3002 SdPage& rHandoutMaster = *rModel.GetMasterSdPage( 0, PK_HANDOUT ); 3003 3004 if( eLayout == AUTOLAYOUT_NONE ) 3005 { 3006 // use layout from handout master 3007 SdrObjListIter aShapeIter (rHandoutMaster); 3008 while (aShapeIter.IsMore()) 3009 { 3010 SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next()); 3011 if (pPageObj) 3012 rAreas.push_back( pPageObj->GetCurrentBoundRect() ); 3013 } 3014 } 3015 else 3016 { 3017 Size aArea = rHandoutMaster.GetSize(); 3018 3019 const long nGapW = 1000; // gap is 1cm 3020 const long nGapH = 1000; 3021 3022 long nLeftBorder = rHandoutMaster.GetLftBorder(); 3023 long nRightBorder = rHandoutMaster.GetRgtBorder(); 3024 long nTopBorder = rHandoutMaster.GetUppBorder(); 3025 long nBottomBorder = rHandoutMaster.GetLwrBorder(); 3026 3027 const long nHeaderFooterHeight = static_cast< long >( (aArea.Height() - nTopBorder - nLeftBorder) * 0.05 ); 3028 3029 nTopBorder += nHeaderFooterHeight; 3030 nBottomBorder += nHeaderFooterHeight; 3031 3032 long nX = nGapW + nLeftBorder; 3033 long nY = nGapH + nTopBorder; 3034 3035 aArea.Width() -= nGapW * 2 + nLeftBorder + nRightBorder; 3036 aArea.Height() -= nGapH * 2 + nTopBorder + nBottomBorder; 3037 3038 const bool bLandscape = aArea.Width() > aArea.Height(); 3039 3040 static sal_uInt16 aOffsets[5][9] = 3041 { 3042 { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, // AUTOLAYOUT_HANDOUT9, Portrait, Horizontal order 3043 { 0, 2, 4, 1, 3, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT3, Landscape, Vertical 3044 { 0, 2, 1, 3, 0, 0, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Landscape, Vertical 3045 { 0, 3, 1, 4, 2, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Portrait, Vertical 3046 { 0, 3, 6, 1, 4, 7, 2, 5, 8 }, // AUTOLAYOUT_HANDOUT9, Landscape, Vertical 3047 }; 3048 3049 sal_uInt16* pOffsets = aOffsets[0]; 3050 sal_uInt16 nColCnt = 0, nRowCnt = 0; 3051 switch ( eLayout ) 3052 { 3053 case AUTOLAYOUT_HANDOUT1: 3054 nColCnt = 1; nRowCnt = 1; 3055 break; 3056 3057 case AUTOLAYOUT_HANDOUT2: 3058 if( bLandscape ) 3059 { 3060 nColCnt = 2; nRowCnt = 1; 3061 } 3062 else 3063 { 3064 nColCnt = 1; nRowCnt = 2; 3065 } 3066 break; 3067 3068 case AUTOLAYOUT_HANDOUT3: 3069 if( bLandscape ) 3070 { 3071 nColCnt = 3; nRowCnt = 2; 3072 } 3073 else 3074 { 3075 nColCnt = 2; nRowCnt = 3; 3076 } 3077 pOffsets = aOffsets[ bLandscape ? 1 : 0 ]; 3078 break; 3079 3080 case AUTOLAYOUT_HANDOUT4: 3081 nColCnt = 2; nRowCnt = 2; 3082 pOffsets = aOffsets[ bHorizontal ? 0 : 2 ]; 3083 break; 3084 3085 case AUTOLAYOUT_HANDOUT6: 3086 if( bLandscape ) 3087 { 3088 nColCnt = 3; nRowCnt = 2; 3089 } 3090 else 3091 { 3092 nColCnt = 2; nRowCnt = 3; 3093 } 3094 if( !bHorizontal ) 3095 pOffsets = aOffsets[ bLandscape ? 1 : 3 ]; 3096 break; 3097 3098 default: 3099 case AUTOLAYOUT_HANDOUT9: 3100 nColCnt = 3; nRowCnt = 3; 3101 3102 if( !bHorizontal ) 3103 pOffsets = aOffsets[4]; 3104 break; 3105 } 3106 3107 rAreas.resize( nColCnt * nRowCnt ); 3108 3109 Size aPartArea, aSize; 3110 aPartArea.Width() = ((aArea.Width() - ((nColCnt-1) * nGapW) ) / nColCnt); 3111 aPartArea.Height() = ((aArea.Height() - ((nRowCnt-1) * nGapH) ) / nRowCnt); 3112 3113 SdrPage* pFirstPage = rModel.GetMasterSdPage(0, PK_STANDARD); 3114 if ( pFirstPage ) 3115 { 3116 // scale actual size into handout rect 3117 double fScale = (double)aPartArea.Width() / (double)pFirstPage->GetWdt(); 3118 3119 aSize.Height() = (long)(fScale * pFirstPage->GetHgt() ); 3120 if( aSize.Height() > aPartArea.Height() ) 3121 { 3122 fScale = (double)aPartArea.Height() / (double)pFirstPage->GetHgt(); 3123 aSize.Height() = aPartArea.Height(); 3124 aSize.Width() = (long)(fScale * pFirstPage->GetWdt()); 3125 } 3126 else 3127 { 3128 aSize.Width() = aPartArea.Width(); 3129 } 3130 3131 nX += (aPartArea.Width() - aSize.Width()) / 2; 3132 nY += (aPartArea.Height()- aSize.Height())/ 2; 3133 } 3134 else 3135 { 3136 aSize = aPartArea; 3137 } 3138 3139 Point aPos( nX, nY ); 3140 3141 const bool bRTL = rModel.GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB; 3142 3143 const long nOffsetX = (aPartArea.Width() + nGapW) * (bRTL ? -1 : 1); 3144 const long nOffsetY = aPartArea.Height() + nGapH; 3145 const long nStartX = bRTL ? nOffsetX*(1 - nColCnt) - nX : nX; 3146 3147 for(sal_uInt16 nRow = 0; nRow < nRowCnt; nRow++) 3148 { 3149 aPos.X() = nStartX; 3150 for(sal_uInt16 nCol = 0; nCol < nColCnt; nCol++) 3151 { 3152 rAreas[*pOffsets++] = Rectangle(aPos, aSize); 3153 aPos.X() += nOffsetX; 3154 } 3155 3156 aPos.Y() += nOffsetY; 3157 } 3158 } 3159 } 3160 3161 3162 3163 3164 void SdPage::SetPrecious (const bool bIsPrecious) 3165 { 3166 mbIsPrecious = bIsPrecious; 3167 } 3168 3169 3170 3171 3172 bool SdPage::IsPrecious (void) const 3173 { 3174 return mbIsPrecious; 3175 } 3176 3177 3178 3179 3180 HeaderFooterSettings::HeaderFooterSettings() 3181 { 3182 mbHeaderVisible = true; 3183 mbFooterVisible = true; 3184 mbSlideNumberVisible = false; 3185 mbDateTimeVisible = true; 3186 mbDateTimeIsFixed = true; 3187 meDateTimeFormat = SVXDATEFORMAT_A; 3188 } 3189 3190 bool HeaderFooterSettings::operator==( const HeaderFooterSettings& rSettings ) const 3191 { 3192 return (mbHeaderVisible == rSettings.mbHeaderVisible) && 3193 (maHeaderText == rSettings.maHeaderText) && 3194 (mbFooterVisible == rSettings.mbFooterVisible) && 3195 (maFooterText == rSettings.maFooterText) && 3196 (mbSlideNumberVisible == rSettings.mbSlideNumberVisible) && 3197 (mbDateTimeVisible == rSettings.mbDateTimeVisible) && 3198 (mbDateTimeIsFixed == rSettings.mbDateTimeIsFixed) && 3199 (meDateTimeFormat == rSettings.meDateTimeFormat) && 3200 (maDateTimeText == rSettings.maDateTimeText); 3201 } 3202 3203