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