diff options
Diffstat (limited to 'sd/source/core/sdpage.cxx')
-rwxr-xr-x | sd/source/core/sdpage.cxx | 3151 |
1 files changed, 3151 insertions, 0 deletions
diff --git a/sd/source/core/sdpage.cxx b/sd/source/core/sdpage.cxx new file mode 100755 index 000000000000..971bb2340069 --- /dev/null +++ b/sd/source/core/sdpage.cxx @@ -0,0 +1,3151 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <algorithm> + +#include <comphelper/classids.hxx> + +#include <vcl/svapp.hxx> +#include "eetext.hxx" +#include <editeng/eeitem.hxx> +#include <svx/svdoutl.hxx> +#include <editeng/editdata.hxx> +#include <svx/pageitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/bulitem.hxx> +#include <svx/svdpagv.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/outlobj.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdopage.hxx> +#include <svx/svdopage.hxx> +#include <sfx2/printer.hxx> +#include <basic/basmgr.hxx> +#include <editeng/pbinitem.hxx> +#include <svx/svdundo.hxx> +#include <svl/smplhint.hxx> +#include <editeng/adjitem.hxx> +#include <editeng/editobj.hxx> +#ifndef _SVX_SRIPTTYPEITEM_HXX +#include <editeng/scripttypeitem.hxx> +#endif +#include <svx/unopage.hxx> +#include <editeng/flditem.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/svditer.hxx> + +#include <editeng/adjitem.hxx> + +#include "../ui/inc/DrawDocShell.hxx" +#include "Outliner.hxx" + +#include "misc.hxx" +#include "eetext.hxx" +#include "drawdoc.hxx" +#include "sdpage.hxx" +#include "pglink.hxx" +#include "sdresid.hxx" +#include "stlsheet.hxx" +#include "glob.hrc" +#include "glob.hxx" +#include "helpids.h" +#include "anminfo.hxx" +#include "undo/undomanager.hxx" +#include "undo/undoobjects.hxx" +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/unoapi.hxx> + +#include <set> + +using namespace ::sd; +using namespace ::com::sun::star; + +TYPEINIT2( SdPage, FmFormPage, SdrObjUserCall ); + +/************************************************************************* +|* +|* Ctor +|* +\************************************************************************/ + +SdPage::SdPage(SdDrawDocument& rNewDoc, StarBASIC* pBasic, BOOL bMasterPage) +: FmFormPage(rNewDoc, pBasic, bMasterPage) +, SdrObjUserCall() +, mePageKind(PK_STANDARD) +, meAutoLayout(AUTOLAYOUT_NONE) +, mbSelected(FALSE) +, mePresChange(PRESCHANGE_MANUAL) +, mnTime(1) +, mbSoundOn(FALSE) +, mbExcluded(FALSE) +, mbLoopSound(FALSE) +, mbStopSound(FALSE) +, mbScaleObjects(TRUE) +, mbBackgroundFullSize( FALSE ) +, meCharSet(gsl_getSystemTextEncoding()) +, mnPaperBin(PAPERBIN_PRINTER_SETTINGS) +, mpPageLink(NULL) +, mpItems(NULL) +, mnTransitionType(0) +, mnTransitionSubtype(0) +, mbTransitionDirection(sal_True) +, mnTransitionFadeColor(0) +, mfTransitionDuration(2.0) +, mbIsPrecious(true) +{ + // Der Layoutname der Seite wird von SVDRAW benutzt, um die Praesentations- + // vorlagen der Gliederungsobjekte zu ermitteln. Darum enthaelt er bereits + // den Bezeichner fuer die Gliederung (STR_LAYOUT_OUTLINE). + maLayoutName = String(SdResId(STR_LAYOUT_DEFAULT_NAME)); + maLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR )); + maLayoutName += String(SdResId(STR_LAYOUT_OUTLINE)); + + Size aPageSize(GetSize()); + + if (aPageSize.Width() > aPageSize.Height()) + { + meOrientation = ORIENTATION_LANDSCAPE; + } + else + { + meOrientation = ORIENTATION_PORTRAIT; + } +} + +/************************************************************************* +|* +|* Dtor +|* +\************************************************************************/ + +SdPage::~SdPage() +{ + DisconnectLink(); + + EndListenOutlineText(); + + if( mpItems ) + delete mpItems; +} + +struct OrdNumSorter +{ + bool operator()( SdrObject* p1, SdrObject* p2 ) + { + return p1->GetOrdNum() < p2->GetOrdNum(); + } +}; + +/** returns the nIndex'th object from the given PresObjKind, index starts with 1 */ +SdrObject* SdPage::GetPresObj(PresObjKind eObjKind, int nIndex, bool bFuzzySearch /* = false */ ) +{ + // first sort all matching shapes with z-order + std::vector< SdrObject* > aMatches; + + SdrObject* pObj = 0; + while( (pObj = maPresentationShapeList.getNextShape(pObj)) != 0 ) + { + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj); + if( pInfo ) + { + bool bFound = false; + if( pInfo->mePresObjKind == eObjKind ) + { + bFound = true; + } + else if( bFuzzySearch && (eObjKind == PRESOBJ_OUTLINE) ) + { + switch( pInfo->mePresObjKind ) + { + case PRESOBJ_GRAPHIC: + case PRESOBJ_OBJECT: + case PRESOBJ_CHART: + case PRESOBJ_ORGCHART: + case PRESOBJ_TABLE: + case PRESOBJ_CALC: + case PRESOBJ_IMAGE: + case PRESOBJ_MEDIA: + bFound = TRUE; + break; + default: + break; + } + } + if( bFound ) + { + aMatches.push_back( pObj ); + } + } + } + + if( aMatches.size() > 1 ) + { + OrdNumSorter aSortHelper; + std::sort( aMatches.begin(), aMatches.end(), aSortHelper ); + } + + if( nIndex > 0 ) + nIndex--; + + if( (nIndex >= 0) && ( aMatches.size() > static_cast<unsigned int>(nIndex)) ) + return aMatches[nIndex]; + + return 0; +} + +/** create background properties */ +void SdPage::EnsureMasterPageDefaultBackground() +{ + if(mbMaster) + { + // no hard attributes on MasterPage attributes + getSdrPageProperties().ClearItem(); + SfxStyleSheet* pSheetForPresObj = GetStyleSheetForMasterPageBackground(); + + if(pSheetForPresObj) + { + // set StyleSheet for background fill attributes + getSdrPageProperties().SetStyleSheet(pSheetForPresObj); + } + else + { + // no style found, assert and set at least XFILL_NONE + OSL_ENSURE(false, "No Style for MasterPageBackground fill found (!)"); + getSdrPageProperties().PutItem(XFillStyleItem(XFILL_NONE)); + } + } +} + +/** creates a presentation object with the given PresObjKind on this page. A user call will be set +*/ +SdrObject* SdPage::CreatePresObj(PresObjKind eObjKind, BOOL bVertical, const Rectangle& rRect, BOOL /* bInsert */ ) +{ + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && IsInserted(); + + SdrObject* pSdrObj = NULL; + + bool bForceText = false; // forces the shape text to be set even if its empty + bool bEmptyPresObj = true; + + switch( eObjKind ) + { + case PRESOBJ_TITLE: + { + pSdrObj = new SdrRectObj(OBJ_TITLETEXT); + + if (mbMaster) + { + pSdrObj->SetNotVisibleAsMaster(TRUE); + } + } + break; + + case PRESOBJ_OUTLINE: + { + pSdrObj = new SdrRectObj(OBJ_OUTLINETEXT); + + if (mbMaster) + { + pSdrObj->SetNotVisibleAsMaster(TRUE); + } + } + break; + + case PRESOBJ_NOTES: + { + pSdrObj = new SdrRectObj(OBJ_TEXT); + + if (mbMaster) + { + pSdrObj->SetNotVisibleAsMaster(TRUE); + } + } + break; + + case PRESOBJ_TEXT: + { + pSdrObj = new SdrRectObj(OBJ_TEXT); + } + break; + + case PRESOBJ_GRAPHIC: + { + BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_GRAPHIC ) ); + Graphic aGraphic( aBmpEx ); + OutputDevice &aOutDev = *Application::GetDefaultDevice(); + aOutDev.Push(); + + aOutDev.SetMapMode( aGraphic.GetPrefMapMode() ); + Size aSizePix = aOutDev.LogicToPixel( aGraphic.GetPrefSize() ); + aOutDev.SetMapMode(MAP_100TH_MM); + + Size aSize = aOutDev.PixelToLogic(aSizePix); + Point aPnt (0, 0); + Rectangle aRect (aPnt, aSize); + pSdrObj = new SdrGrafObj(aGraphic, aRect); + aOutDev.Pop(); + } + break; + + case PRESOBJ_MEDIA: + case PRESOBJ_OBJECT: + { + pSdrObj = new SdrOle2Obj(); + BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_OBJECT ) ); + Graphic aGraphic( aBmpEx ); + ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); + } + break; + + case PRESOBJ_CHART: + { + pSdrObj = new SdrOle2Obj(); + ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarChart" ))); + BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_CHART ) ); + Graphic aGraphic( aBmpEx ); + ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); + } + break; + + case PRESOBJ_ORGCHART: + { + pSdrObj = new SdrOle2Obj(); + ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarOrg" ))); + BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_ORGCHART ) ); + Graphic aGraphic( aBmpEx ); + ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); + } + + case PRESOBJ_TABLE: + case PRESOBJ_CALC: + { + pSdrObj = new SdrOle2Obj(); + ( (SdrOle2Obj*) pSdrObj)->SetProgName( String( RTL_CONSTASCII_USTRINGPARAM( "StarCalc" ))); + BitmapEx aBmpEx( SdResId( BMP_PRESOBJ_TABLE ) ); + Graphic aGraphic( aBmpEx ); + ( (SdrOle2Obj*) pSdrObj)->SetGraphic(&aGraphic); + } + break; + + case PRESOBJ_HANDOUT: + { + //Erste Standardseite am SdrPageObj vermerken + // #i105146# We want no content to be displayed for PK_HANDOUT, + // so just never set a page as content + pSdrObj = new SdrPageObj(0); +// pSdrObj->SetResizeProtect(TRUE); + } + break; + + case PRESOBJ_PAGE: + { + //Notizseite am SdrPageObj vermerken + sal_uInt16 nDestPageNum(GetPageNum()); + + if(nDestPageNum) + { + // decrement only when != 0, else we get a 0xffff + nDestPageNum -= 1; + } + + if(nDestPageNum < pModel->GetPageCount()) + { + pSdrObj = new SdrPageObj(pModel->GetPage(nDestPageNum)); + } + else + { + pSdrObj = new SdrPageObj(); + } + + pSdrObj->SetResizeProtect(TRUE); + } + break; + + case PRESOBJ_HEADER: + case PRESOBJ_FOOTER: + case PRESOBJ_DATETIME: + case PRESOBJ_SLIDENUMBER: + { + pSdrObj = new SdrRectObj(OBJ_TEXT); + bEmptyPresObj = false; + bForceText = true; + } + break; + default: + break; + } + + if (pSdrObj) + { + pSdrObj->SetEmptyPresObj(bEmptyPresObj); + pSdrObj->SetLogicRect(rRect); + + InsertObject(pSdrObj); + + if ( pSdrObj->ISA(SdrTextObj) ) + { + // #96243# Tell the object EARLY that it is vertical to have the + // defaults for AutoGrowWidth/Height reversed + if(bVertical) + ((SdrTextObj*)pSdrObj)->SetVerticalWriting(TRUE); + + SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); + if( bVertical ) + aTempAttr.Put( SdrTextMinFrameWidthItem( rRect.GetSize().Width() ) ); + else + aTempAttr.Put( SdrTextMinFrameHeightItem( rRect.GetSize().Height() ) ); + + if (mbMaster) + { + // Bei Praesentationsobjekten auf der MasterPage soll die + // Groesse vom Benutzwer frei waehlbar sein + + // #96243# potential problem: This action was still NOT + // adapted for vertical text. This sure needs to be done. + if(bVertical) + aTempAttr.Put(SdrTextAutoGrowWidthItem(FALSE)); + else + aTempAttr.Put(SdrTextAutoGrowHeightItem(FALSE)); + } + + // check if we need another vertical adjustement than the default + SdrTextVertAdjust eV = SDRTEXTVERTADJUST_TOP; + + if( (eObjKind == PRESOBJ_FOOTER) && (mePageKind != PK_STANDARD) ) + { + eV = SDRTEXTVERTADJUST_BOTTOM; + } + else if( (eObjKind == PRESOBJ_SLIDENUMBER) && (mePageKind != PK_STANDARD) ) + { + eV = SDRTEXTVERTADJUST_BOTTOM; + } + + if( eV != SDRTEXTVERTADJUST_TOP ) + aTempAttr.Put(SdrTextVertAdjustItem(eV)); + + pSdrObj->SetMergedItemSet(aTempAttr); + + pSdrObj->SetLogicRect(rRect); + } + + String aString = GetPresObjText(eObjKind); + if( (aString.Len() || bForceText) && pSdrObj->ISA(SdrTextObj) ) + { + SdrOutliner* pOutliner = ( (SdDrawDocument*) GetModel() )->GetInternalOutliner(); + + USHORT nOutlMode = pOutliner->GetMode(); + pOutliner->Init( OUTLINERMODE_TEXTOBJECT ); + pOutliner->SetStyleSheet( 0, NULL ); + pOutliner->SetVertical( bVertical ); + + String aEmptyStr; + SetObjText( (SdrTextObj*) pSdrObj, (SdrOutliner*)pOutliner, eObjKind, aString ); + + pOutliner->Init( nOutlMode ); + pOutliner->SetStyleSheet( 0, NULL ); + } + + if( (eObjKind == PRESOBJ_HEADER) || (eObjKind == PRESOBJ_FOOTER) || (eObjKind == PRESOBJ_SLIDENUMBER) || (eObjKind == PRESOBJ_DATETIME) ) + { + SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); + aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT ) ); + aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CTL ) ); + aTempAttr.Put( SvxFontHeightItem( 493, 100, EE_CHAR_FONTHEIGHT_CJK ) ); + + SvxAdjust eH = SVX_ADJUST_LEFT; + + if( (eObjKind == PRESOBJ_DATETIME) && (mePageKind != PK_STANDARD ) ) + { + eH = SVX_ADJUST_RIGHT; + } + else if( (eObjKind == PRESOBJ_FOOTER) && (mePageKind == PK_STANDARD ) ) + { + eH = SVX_ADJUST_CENTER; + } + else if( eObjKind == PRESOBJ_SLIDENUMBER ) + { + eH = SVX_ADJUST_RIGHT; + } + + if( eH != SVX_ADJUST_LEFT ) + aTempAttr.Put(SvxAdjustItem(eH, EE_PARA_JUST )); + + pSdrObj->SetMergedItemSet(aTempAttr); + } + + if (mbMaster) + { + SdrLayerAdmin& rLayerAdmin = pModel->GetLayerAdmin(); + + // Hintergrundobjekte der MasterPage + pSdrObj->SetLayer( rLayerAdmin. + GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE) ); + } + + // Objekt am StyleSheet anmelden + // #95114# Set style only when one was found (as in 5.2) + // pSdrObj->NbcSetStyleSheet( GetStyleSheetForPresObj(eObjKind), FALSE ); + if( mePageKind != PK_HANDOUT ) + { + SfxStyleSheet* pSheetForPresObj = GetStyleSheetForPresObj(eObjKind); + if(pSheetForPresObj) + pSdrObj->SetStyleSheet(pSheetForPresObj, FALSE); + } + + if (eObjKind == PRESOBJ_OUTLINE) + { + for (USHORT nLevel = 1; nLevel < 10; nLevel++) + { + String aName(maLayoutName); + aName += sal_Unicode( ' ' ); + aName += String::CreateFromInt32( nLevel ); + SfxStyleSheet* pSheet = (SfxStyleSheet*)pModel->GetStyleSheetPool()->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); + DBG_ASSERT(pSheet, "Vorlage fuer Gliederungsobjekt nicht gefunden"); + if (pSheet) + pSdrObj->StartListening(*pSheet); + } + } + + if ( eObjKind == PRESOBJ_OBJECT || + eObjKind == PRESOBJ_CHART || + eObjKind == PRESOBJ_ORGCHART || + eObjKind == PRESOBJ_CALC || + eObjKind == PRESOBJ_GRAPHIC ) + { + SfxItemSet aSet( ((SdDrawDocument*) pModel)->GetPool() ); + aSet.Put( SdrTextContourFrameItem( TRUE ) ); + aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, EE_PARA_JUST ) ); + + pSdrObj->SetMergedItemSet(aSet); + } + + if( bUndo ) + { + pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoNewObject(*pSdrObj)); + } + + if( bUndo ) + { + pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pSdrObj ) ); + pUndoManager->AddUndoAction( new UndoObjectUserCall(*pSdrObj) ); + } + + InsertPresObj(pSdrObj, eObjKind); + pSdrObj->SetUserCall(this); + + pSdrObj->RecalcBoundRect(); + } + + return(pSdrObj); +} + +/************************************************************************* +|* +|* Es werden Praesentationsobjekte auf der Page erzeugt. +|* Alle Praesentationsobjekte erhalten einen UserCall auf die Page. +|* +\************************************************************************/ + +SfxStyleSheet* SdPage::GetStyleSheetForMasterPageBackground() const +{ + String aName(GetLayoutName()); + String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); + USHORT nPos = aName.Search(aSep); + + if (nPos != STRING_NOTFOUND) + { + nPos = nPos + aSep.Len(); + aName.Erase(nPos); + } + + aName += String(SdResId(STR_LAYOUT_BACKGROUND)); + + SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); + SfxStyleSheetBase* pResult = pStShPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); + return (SfxStyleSheet*)pResult; +} + +SfxStyleSheet* SdPage::GetStyleSheetForPresObj(PresObjKind eObjKind) const +{ + String aName(GetLayoutName()); + String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); + USHORT nPos = aName.Search(aSep); + if (nPos != STRING_NOTFOUND) + { + nPos = nPos + aSep.Len(); + aName.Erase(nPos); + } + + switch (eObjKind) + { + case PRESOBJ_OUTLINE: + { + aName = GetLayoutName(); + aName += sal_Unicode( ' ' ); + aName += String::CreateFromInt32( 1 ); + } + break; + + case PRESOBJ_TITLE: + aName += String(SdResId(STR_LAYOUT_TITLE)); + break; + + case PRESOBJ_NOTES: + aName += String(SdResId(STR_LAYOUT_NOTES)); + break; + + case PRESOBJ_TEXT: + aName += String(SdResId(STR_LAYOUT_SUBTITLE)); + break; + + case PRESOBJ_HEADER: + case PRESOBJ_FOOTER: + case PRESOBJ_DATETIME: + case PRESOBJ_SLIDENUMBER: + aName += String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS)); + break; + + default: + break; + } + + SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); + SfxStyleSheetBase* pResult = pStShPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); + return (SfxStyleSheet*)pResult; +} + +/** returns the presentation style with the given helpid from this masterpage or this + slides masterpage */ +SdStyleSheet* SdPage::getPresentationStyle( sal_uInt32 nHelpId ) const +{ + String aStyleName( pPage->GetLayoutName() ); + const String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); + aStyleName.Erase(aStyleName.Search(aSep) + aSep.Len()); + + sal_uInt16 nNameId; + switch( nHelpId ) + { + case HID_PSEUDOSHEET_TITLE: nNameId = STR_LAYOUT_TITLE; break; + case HID_PSEUDOSHEET_SUBTITLE: nNameId = STR_LAYOUT_SUBTITLE; break; + case HID_PSEUDOSHEET_OUTLINE1: + case HID_PSEUDOSHEET_OUTLINE2: + case HID_PSEUDOSHEET_OUTLINE3: + case HID_PSEUDOSHEET_OUTLINE4: + case HID_PSEUDOSHEET_OUTLINE5: + case HID_PSEUDOSHEET_OUTLINE6: + case HID_PSEUDOSHEET_OUTLINE7: + case HID_PSEUDOSHEET_OUTLINE8: + case HID_PSEUDOSHEET_OUTLINE9: nNameId = STR_LAYOUT_OUTLINE; break; + case HID_PSEUDOSHEET_BACKGROUNDOBJECTS: nNameId = STR_LAYOUT_BACKGROUNDOBJECTS; break; + case HID_PSEUDOSHEET_BACKGROUND: nNameId = STR_LAYOUT_BACKGROUND; break; + case HID_PSEUDOSHEET_NOTES: nNameId = STR_LAYOUT_NOTES; break; + + default: + DBG_ERROR( "SdPage::getPresentationStyle(), illegal argument!" ); + return 0; + } + aStyleName.Append( String( SdResId( nNameId ) ) ); + if( nNameId == STR_LAYOUT_OUTLINE ) + { + aStyleName.Append( sal_Unicode( ' ' )); + aStyleName.Append( String::CreateFromInt32( sal_Int32( nHelpId - HID_PSEUDOSHEET_OUTLINE ))); + } + + SfxStyleSheetBasePool* pStShPool = pModel->GetStyleSheetPool(); + SfxStyleSheetBase* pResult = pStShPool->Find(aStyleName, SD_STYLE_FAMILY_MASTERPAGE); + return dynamic_cast<SdStyleSheet*>(pResult); +} + +/************************************************************************* +|* +|* Das Praesentationsobjekt rObj hat sich geaendert und wird nicht mehr +|* durch das Praesentationsobjekt der MasterPage referenziert. +|* Der UserCall wird geloescht. +|* +\************************************************************************/ + +void SdPage::Changed(const SdrObject& rObj, SdrUserCallType eType, const Rectangle& ) +{ + if (!maLockAutoLayoutArrangement.isLocked()) + { + switch (eType) + { + case SDRUSERCALL_MOVEONLY: + case SDRUSERCALL_RESIZE: + { + if( pModel->isLocked() ) + break; + + SdrObject* pObj = (SdrObject*) &rObj; + + if (pObj) + { + if (!mbMaster) + { + if( pObj->GetUserCall() ) + { + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && IsInserted(); +/* + DBG_ASSERT( bUndo || (pUndoManager && pUndoManager->isInUndo()), + "SdPage::Changed(), model change without undo!?" ); +*/ + if( bUndo ) + pUndoManager->AddUndoAction( new UndoObjectUserCall(*pObj) ); + + // Objekt was resized by user and does not listen to its slide anymore + pObj->SetUserCall(0); + } + } + else if (pModel) + { + // MasterPage-Objekt wurde veraendert, daher + // Objekte auf allen Seiten anpassen + USHORT nPageCount = ((SdDrawDocument*) pModel)->GetSdPageCount(mePageKind); + + for (USHORT i = 0; i < nPageCount; i++) + { + SdPage* pLoopPage = ((SdDrawDocument*) pModel)->GetSdPage(i, mePageKind); + + if (pLoopPage && this == &(pLoopPage->TRG_GetMasterPage())) + { + // Seite hoert auf diese MasterPage, daher + // AutoLayout anpassen + pLoopPage->SetAutoLayout(pLoopPage->GetAutoLayout()); + } + } + } + } + } + break; + + case SDRUSERCALL_DELETE: + case SDRUSERCALL_REMOVED: + default: + break; + } + } +} + +/************************************************************************* +|* +|* Erzeugt auf einer MasterPage Hintergrund, Titel- und Layout-Bereich +|* +\************************************************************************/ + +void SdPage::CreateTitleAndLayout(BOOL bInit, BOOL bCreate ) +{ + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && IsInserted(); + + SdPage* pMasterPage = this; + + if (!mbMaster) + { + pMasterPage = (SdPage*)(&(TRG_GetMasterPage())); + } + + if (!pMasterPage) + { + return; + } + + /************************************************************************** + * Hintergrund, Titel- und Layout-Bereich werden angelegt + **************************************************************************/ + if( mePageKind == PK_STANDARD ) + { + pMasterPage->EnsureMasterPageDefaultBackground(); + } + + if( ( (SdDrawDocument*) GetModel() )->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ) + { + if( mePageKind == PK_HANDOUT && bInit ) + { + // handout template + + // delete all available handout presentation objects + SdrObject* pObj; + while( (pObj = pMasterPage->GetPresObj(PRESOBJ_HANDOUT)) != 0 ) + { + if( bUndo ) + pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); + + pMasterPage->RemoveObject(pObj->GetOrdNum()); + } + + std::vector< Rectangle > aAreas; + CalculateHandoutAreas( *static_cast< SdDrawDocument* >(GetModel() ), pMasterPage->GetAutoLayout(), false, aAreas ); + + const bool bSkip = pMasterPage->GetAutoLayout() == AUTOLAYOUT_HANDOUT3; + std::vector< Rectangle >::iterator iter( aAreas.begin() ); + + while( iter != aAreas.end() ) + { + SdrPageObj* pPageObj = static_cast<SdrPageObj*>(pMasterPage->CreatePresObj(PRESOBJ_HANDOUT, FALSE, (*iter++), TRUE) ); + // #i105146# We want no content to be displayed for PK_HANDOUT, + // so just never set a page as content + pPageObj->SetReferencedPage(0L); + + if( bSkip && iter != aAreas.end() ) + iter++; + } + } + + if( mePageKind != PK_HANDOUT ) + { + SdrObject* pMasterTitle = pMasterPage->GetPresObj( PRESOBJ_TITLE ); + if( pMasterTitle == NULL ) + pMasterPage->CreateDefaultPresObj(PRESOBJ_TITLE, true); + + SdrObject* pMasterOutline = pMasterPage->GetPresObj( mePageKind==PK_NOTES ? PRESOBJ_NOTES : PRESOBJ_OUTLINE ); + if( pMasterOutline == NULL ) + pMasterPage->CreateDefaultPresObj( mePageKind == PK_STANDARD ? PRESOBJ_OUTLINE : PRESOBJ_NOTES, true ); + } + + // create header&footer objects + + if( bCreate ) + { + if( mePageKind != PK_STANDARD ) + { + SdrObject* pHeader = pMasterPage->GetPresObj( PRESOBJ_HEADER ); + if( pHeader == NULL ) + pMasterPage->CreateDefaultPresObj( PRESOBJ_HEADER, true ); + } + + SdrObject* pDate = pMasterPage->GetPresObj( PRESOBJ_DATETIME ); + if( pDate == NULL ) + pMasterPage->CreateDefaultPresObj( PRESOBJ_DATETIME, true ); + + SdrObject* pFooter = pMasterPage->GetPresObj( PRESOBJ_FOOTER ); + if( pFooter == NULL ) + pMasterPage->CreateDefaultPresObj( PRESOBJ_FOOTER, true ); + + SdrObject* pNumber = pMasterPage->GetPresObj( PRESOBJ_SLIDENUMBER ); + if( pNumber == NULL ) + pMasterPage->CreateDefaultPresObj( PRESOBJ_SLIDENUMBER, true ); + } + } +} + +SdrObject* SdPage::CreateDefaultPresObj(PresObjKind eObjKind, bool bInsert) +{ + if( eObjKind == PRESOBJ_TITLE ) + { + Rectangle aTitleRect( GetTitleRect() ); + return CreatePresObj(PRESOBJ_TITLE, FALSE, aTitleRect, bInsert); + } + else if( eObjKind == PRESOBJ_OUTLINE ) + { + Rectangle aLayoutRect( GetLayoutRect() ); + return CreatePresObj( PRESOBJ_OUTLINE, FALSE, aLayoutRect, bInsert); + } + else if( eObjKind == PRESOBJ_NOTES ) + { + Rectangle aLayoutRect( GetLayoutRect() ); + return CreatePresObj( PRESOBJ_NOTES, FALSE, aLayoutRect, bInsert); + } + else if( (eObjKind == PRESOBJ_FOOTER) || (eObjKind == PRESOBJ_DATETIME) || (eObjKind == PRESOBJ_SLIDENUMBER) || (eObjKind == PRESOBJ_HEADER ) ) + { + // create footer objects for standard master page + if( mePageKind == PK_STANDARD ) + { + const long nLftBorder = GetLftBorder(); + const long nUppBorder = GetUppBorder(); + + Point aTitlePos ( nLftBorder, nUppBorder ); + Size aPageSize ( GetSize() ); + aPageSize.Width() -= nLftBorder + GetRgtBorder(); + aPageSize.Height() -= nUppBorder + GetLwrBorder(); + + const int Y = long(nUppBorder + aPageSize.Height() * 0.911); + const int W1 = long(aPageSize.Width() * 0.233); + const int W2 = long(aPageSize.Width() * 0.317); + const int H = long(aPageSize.Height() * 0.069); + + if( eObjKind == PRESOBJ_DATETIME ) + { + Point aPos( long(nLftBorder+(aPageSize.Width()*0.05)), Y ); + Size aSize( W1, H ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_DATETIME, FALSE, aRect, bInsert ); + } + else if( eObjKind == PRESOBJ_FOOTER ) + { + Point aPos( long(nLftBorder+ aPageSize.Width() * 0.342), Y ); + Size aSize( W2, H ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_FOOTER, FALSE, aRect, bInsert ); + } + else if( eObjKind == PRESOBJ_SLIDENUMBER ) + { + Point aPos( long(nLftBorder+(aPageSize.Width()*0.717)), Y ); + Size aSize( W1, H ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_SLIDENUMBER, FALSE, aRect, bInsert ); + } + else + { + DBG_ERROR( "SdPage::CreateDefaultPresObj() - can't create a header placeholder for a slide master" ); + return NULL; + } + } + else + { + // create header&footer objects for handout and notes master + Point aTitlePos ( GetLftBorder(), GetUppBorder() ); + Size aPageSize ( GetSize() ); + aPageSize.Width() -= GetLftBorder() + GetRgtBorder(); + aPageSize.Height() -= GetUppBorder() + GetLwrBorder(); + + + const int NOTES_HEADER_FOOTER_WIDTH = long(aPageSize.Width() * 0.434); + const int NOTES_HEADER_FOOTER_HEIGHT = long(aPageSize.Height() * 0.05); + + Size aSize( NOTES_HEADER_FOOTER_WIDTH, NOTES_HEADER_FOOTER_HEIGHT ); + + const int X1 = GetLftBorder(); + const int X2 = GetLftBorder() + long(aPageSize.Width() - NOTES_HEADER_FOOTER_WIDTH); + const int Y1 = GetUppBorder(); + const int Y2 = GetUppBorder() + long(aPageSize.Height() - NOTES_HEADER_FOOTER_HEIGHT ); + + if( eObjKind == PRESOBJ_HEADER ) + { + Point aPos( X1, Y1 ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_HEADER, FALSE, aRect, bInsert ); + } + else if( eObjKind == PRESOBJ_DATETIME ) + { + Point aPos( X2, Y1 ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_DATETIME, FALSE, aRect, bInsert ); + } + else if( eObjKind == PRESOBJ_FOOTER ) + { + Point aPos( X1, Y2 ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_FOOTER, FALSE, aRect, bInsert ); + } + else if( eObjKind == PRESOBJ_SLIDENUMBER ) + { + Point aPos( X2, Y2 ); + Rectangle aRect( aPos, aSize ); + return CreatePresObj( PRESOBJ_SLIDENUMBER, FALSE, aRect, bInsert ); + } + + DBG_ERROR("SdPage::CreateDefaultPresObj() - this should not happen!"); + return NULL; + } + } + else + { + DBG_ERROR("SdPage::CreateDefaultPresObj() - unknown PRESOBJ kind" ); + return NULL; + } +} + +/************************************************************************* +|* +|* Titelbereich zurueckgeben +|* +\************************************************************************/ + +Rectangle SdPage::GetTitleRect() const +{ + Rectangle aTitleRect; + + if (mePageKind != PK_HANDOUT) + { + /****************************************************************** + * Standard- oder Notiz-Seite: Titelbereich + ******************************************************************/ + Point aTitlePos ( GetLftBorder(), GetUppBorder() ); + Size aTitleSize ( GetSize() ); + aTitleSize.Width() -= GetLftBorder() + GetRgtBorder(); + aTitleSize.Height() -= GetUppBorder() + GetLwrBorder(); + + if (mePageKind == PK_STANDARD) + { + aTitlePos.X() += long( aTitleSize.Width() * 0.05 ); + aTitlePos.Y() += long( aTitleSize.Height() * 0.0399 ); + aTitleSize.Width() = long( aTitleSize.Width() * 0.9 ); + aTitleSize.Height() = long( aTitleSize.Height() * 0.167 ); + } + else if (mePageKind == PK_NOTES) + { + Point aPos = aTitlePos; + aPos.Y() += long( aTitleSize.Height() * 0.076 ); + + // Hoehe beschraenken + aTitleSize.Height() = (long) (aTitleSize.Height() * 0.375); + + Size aPartArea = aTitleSize; + Size aSize; + sal_uInt16 nDestPageNum(GetPageNum()); + SdrPage* pRefPage = 0L; + + if(nDestPageNum) + { + // only decrement if != 0, else we get 0xffff + nDestPageNum -= 1; + } + + if(nDestPageNum < pModel->GetPageCount()) + { + pRefPage = pModel->GetPage(nDestPageNum); + } + + if ( pRefPage ) + { + // tatsaechliche Seitengroesse in das Handout-Rechteck skalieren + double fH = (double) aPartArea.Width() / pRefPage->GetWdt(); + double fV = (double) aPartArea.Height() / pRefPage->GetHgt(); + + if ( fH > fV ) + fH = fV; + aSize.Width() = (long) (fH * pRefPage->GetWdt()); + aSize.Height() = (long) (fH * pRefPage->GetHgt()); + + aPos.X() += (aPartArea.Width() - aSize.Width()) / 2; + aPos.Y() += (aPartArea.Height()- aSize.Height())/ 2; + } + + aTitlePos = aPos; + aTitleSize = aSize; + } + + aTitleRect.SetPos(aTitlePos); + aTitleRect.SetSize(aTitleSize); + } + + return aTitleRect; +} + + +/************************************************************************* +|* +|* Gliederungsbereich zurueckgeben +|* +\************************************************************************/ + +Rectangle SdPage::GetLayoutRect() const +{ + Rectangle aLayoutRect; + + if (mePageKind != PK_HANDOUT) + { + Point aLayoutPos ( GetLftBorder(), GetUppBorder() ); + Size aLayoutSize ( GetSize() ); + aLayoutSize.Width() -= GetLftBorder() + GetRgtBorder(); + aLayoutSize.Height() -= GetUppBorder() + GetLwrBorder(); + + if (mePageKind == PK_STANDARD) + { + aLayoutPos.X() += long( aLayoutSize.Width() * 0.05 ); + aLayoutPos.Y() += long( aLayoutSize.Height() * 0.234 ); + aLayoutSize.Width() = long( aLayoutSize.Width() * 0.9 ); + aLayoutSize.Height() = long( aLayoutSize.Height() * 0.66 ); + aLayoutRect.SetPos(aLayoutPos); + aLayoutRect.SetSize(aLayoutSize); + } + else if (mePageKind == PK_NOTES) + { + aLayoutPos.X() += long( aLayoutSize.Width() * 0.1 ); + aLayoutPos.Y() += long( aLayoutSize.Height() * 0.475 ); + aLayoutSize.Width() = long( aLayoutSize.Width() * 0.8 ); + aLayoutSize.Height() = long( aLayoutSize.Height() * 0.45 ); + aLayoutRect.SetPos(aLayoutPos); + aLayoutRect.SetSize(aLayoutSize); + } + } + + return aLayoutRect; +} + + +/************************************************************************** +|* +|* Diese Methode weist ein AutoLayout zu +|* +\*************************************************************************/ + +const int MAX_PRESOBJS = 7; // maximum number of presentation objects per layout +const int VERTICAL = 0x8000; + +struct LayoutDescriptor +{ + int mnLayout; + PresObjKind meKind[MAX_PRESOBJS]; + bool mbVertical[MAX_PRESOBJS]; + + LayoutDescriptor( int nLayout, int k0 = 0, int k1 = 0, int k2 = 0, int k3 = 0, int k4 = 0, int k5 = 0, int k6 = 0 ); +}; + +LayoutDescriptor::LayoutDescriptor( int nLayout, int k0, int k1, int k2, int k3, int k4, int k5, int k6 ) +: mnLayout( nLayout ) +{ + meKind[0] = static_cast<PresObjKind>(k0 & (~VERTICAL)); mbVertical[0] = (k0 & VERTICAL) == VERTICAL; + meKind[1] = static_cast<PresObjKind>(k1 & (~VERTICAL)); mbVertical[1] = (k1 & VERTICAL) == VERTICAL; + meKind[2] = static_cast<PresObjKind>(k2 & (~VERTICAL)); mbVertical[2] = (k2 & VERTICAL) == VERTICAL; + meKind[3] = static_cast<PresObjKind>(k3 & (~VERTICAL)); mbVertical[3] = (k3 & VERTICAL) == VERTICAL; + meKind[4] = static_cast<PresObjKind>(k4 & (~VERTICAL)); mbVertical[4] = (k4 & VERTICAL) == VERTICAL; + meKind[5] = static_cast<PresObjKind>(k5 & (~VERTICAL)); mbVertical[5] = (k5 & VERTICAL) == VERTICAL; + meKind[6] = static_cast<PresObjKind>(k6 & (~VERTICAL)); mbVertical[6] = (k6 & VERTICAL) == VERTICAL; +} + +static const LayoutDescriptor& GetLayoutDescriptor( AutoLayout eLayout ) +{ + static LayoutDescriptor aLayouts[AUTOLAYOUT__END-AUTOLAYOUT__START] = + { + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_TEXT ), // AUTOLAYOUT_TITLE + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_ENUM + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CHART + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2TEXT + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTCHART + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_ORG + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTCLbIP + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CHARTTEXT + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TAB + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_CLIPTEXT + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOBJ + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OBJECT ), // AUTOLAYOUT_OBJ + LayoutDescriptor( 2, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXT2OBJ + LayoutDescriptor( 1, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOBJ + LayoutDescriptor( 4, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_OBJOVERTEXT + LayoutDescriptor( 3, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2OBJTEXT + LayoutDescriptor( 5, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_2OBJOVERTEXT + LayoutDescriptor( 4, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), // AUTOLAYOUT_TEXTOVEROBJ + LayoutDescriptor( 6, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_4OBJ + PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ), + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_NONE ), // AUTOLAYOUT_ONLY_TITLE + LayoutDescriptor( 0, PRESOBJ_NONE ), // AUTOLAYOUT_NONE + LayoutDescriptor( 0, PRESOBJ_PAGE, PRESOBJ_NOTES ), // AUTOLAYOUT_NOTES + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT1 + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT2 + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT3 + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT4 + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT6 + LayoutDescriptor( 7, PRESOBJ_TITLE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL, PRESOBJ_OUTLINE ),// AUTOLAYOUT_VERTICAL_TITLE_TEXT_CHART + LayoutDescriptor( 8, PRESOBJ_TITLE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_VERTICAL_TITLE_VERTICAL_OUTLINE + LayoutDescriptor( 0, PRESOBJ_TITLE, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE + LayoutDescriptor( 9, PRESOBJ_TITLE, PRESOBJ_OUTLINE|VERTICAL, PRESOBJ_OUTLINE|VERTICAL ), // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE_CLIPART + LayoutDescriptor( 0 ), // AUTOLAYOUT_HANDOUT9 + LayoutDescriptor( 10, PRESOBJ_TEXT, PRESOBJ_NONE ), // AUTOLAYOUT_ONLY_TEXT + LayoutDescriptor( 6, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_4CLIPART + PRESOBJ_GRAPHIC, PRESOBJ_GRAPHIC ), + LayoutDescriptor( 11, PRESOBJ_TITLE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, // AUTOLAYOUT_6CLIPART + PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE, PRESOBJ_OUTLINE ) + }; + + if( (eLayout < AUTOLAYOUT__START) || (eLayout >= AUTOLAYOUT__END) ) + eLayout = AUTOLAYOUT_NONE; + + return aLayouts[ eLayout - AUTOLAYOUT__START ]; +} + +static void CalcAutoLayoutRectangles( SdPage& rPage, int nLayout, Rectangle* rRectangle ) +{ + Rectangle aTitleRect; + Rectangle aLayoutRect; + + if( rPage.GetPageKind() != PK_HANDOUT ) + { + SdPage& rMasterPage = static_cast<SdPage&>(rPage.TRG_GetMasterPage()); + SdrObject* pMasterTitle = rMasterPage.GetPresObj( PRESOBJ_TITLE ); + SdrObject* pMasterOutline = rMasterPage.GetPresObj( rPage.GetPageKind()==PK_NOTES ? PRESOBJ_NOTES : PRESOBJ_OUTLINE ); + + if( pMasterTitle ) + aTitleRect = pMasterTitle->GetLogicRect(); + + if (aTitleRect.IsEmpty() ) + aTitleRect = rPage.GetTitleRect(); + + if( pMasterOutline ) + aLayoutRect = pMasterOutline->GetLogicRect(); + + if (aLayoutRect.IsEmpty() ) + aLayoutRect = rPage.GetLayoutRect(); + } + + rRectangle[0] = aTitleRect; + + int i; + for( i = 1; i < MAX_PRESOBJS; i++ ) + rRectangle[i] = aLayoutRect; + + Size aTitleSize( aTitleRect.GetSize() ); + Point aTitlePos( aTitleRect.TopLeft() ); + Size aLayoutSize( aLayoutRect.GetSize() ); + Point aLayoutPos( aLayoutRect.TopLeft() ); + Size aTempSize; + Point aTempPnt; + + sal_Bool bRightToLeft = ( rPage.GetModel() && static_cast< SdDrawDocument* >( rPage.GetModel() )->GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB ); + + switch( nLayout ) + { + case 0: // default layout using only the title and layout area + break; // do nothing + case 1: // title, 2 shapes + case 9: // title, 2 vertical shapes + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + if( bRightToLeft && (nLayout != 9) ) + ::std::swap< Rectangle >( rRectangle[1], rRectangle[2] ); + break; + case 2: // title, shape, 2 shapes + aTempPnt = aLayoutPos; + aTempSize = aLayoutSize; + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos = aTempPnt; + aLayoutSize = aTempSize; + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + if( bRightToLeft ) + { + ::std::swap< long >( rRectangle[1].Left(), rRectangle[2].Left() ); + rRectangle[3].Left() = rRectangle[2].Left(); + } + break; + case 3: // title, 2 shapes, shape + aTempPnt = aLayoutPos; + aTempSize = aLayoutSize; + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos = aTempPnt; + aLayoutSize = aTempSize; + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); + rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); + + if( bRightToLeft ) + { + ::std::swap< long >( rRectangle[1].Left(), rRectangle[2].Left() ); + rRectangle[3].Left() = rRectangle[2].Left(); + } + break; + case 4: // title, shape above shape + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + break; + + case 5: // title, 2 shapes above shape + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aTempPnt = aLayoutPos; + aLayoutPos.X() = long (aLayoutPos.X() + aLayoutSize.Width() * 1.05); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = aTempPnt.X(); + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + aLayoutSize.Width() = long (aLayoutSize.Width() / 0.488); + rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); + break; + case 6: // title, 4 shapes + { + ULONG nX = long (aLayoutPos.X()); + + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.488); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = nX; + rRectangle[4] = Rectangle (aLayoutPos, aLayoutSize); + break; + } + case 7: // vertical title, shape above shape + { + Size aSize( rRectangle[0].GetSize().Height(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); + rRectangle[0].SetSize( aSize ); + rRectangle[0].SetPos( aTitleRect.TopRight() - Point( aSize.Width(), 0 ) ); + + Size aPageSize ( rPage.GetSize() ); + aPageSize.Height() -= rPage.GetUppBorder() + rPage.GetLwrBorder(); + aSize.Height() = long ( rRectangle[0].GetSize().Height() * 0.47 ); + aSize.Width() = long( aPageSize.Width() * 0.7 ); + rRectangle[1].SetPos( aTitleRect.TopLeft() ); + rRectangle[1].SetSize( aSize ); + + aSize.Height() = rRectangle[0].GetSize().Height(); + Point aPos( aTitleRect.TopLeft() ); + aPos.Y() += long ( aSize.Height() * 0.53 ); + rRectangle[2].SetPos( aPos ); + aSize.Height() = long ( rRectangle[0].GetSize().Height() * 0.47 ); + rRectangle[2].SetSize( aSize ); + break; + } + case 8: // vertical title, shape + { + Size aSize( rRectangle[0].GetSize().Height(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); + rRectangle[0].SetSize( aSize ); + rRectangle[0].SetPos( aTitleRect.TopRight() - Point( aSize.Width(), 0 ) ); + + Size aPageSize ( rPage.GetSize() ); + aPageSize.Height() -= rPage.GetUppBorder() + rPage.GetLwrBorder(); + aSize.Height() = rRectangle[0].GetSize().Height(); + aSize.Width() = long( aPageSize.Width() * 0.7 ); + rRectangle[1].SetPos( aTitleRect.TopLeft() ); + rRectangle[1].SetSize( aSize ); + break; + } + case 10: // onlytext + { + Size aSize( rRectangle[0].GetSize().Width(), rRectangle[1].BottomLeft().Y() - rRectangle[0].TopLeft().Y() ); + rRectangle[0].SetSize( aSize ); + rRectangle[0].SetPos( aTitlePos); + break; + } + case 11: // title, 6 shapes + { + ULONG nX = long (aLayoutPos.X()); + + aLayoutSize.Height() = long (aLayoutSize.Height() * 0.477); + aLayoutSize.Width() = long (aLayoutSize.Width() * 0.322); + rRectangle[1] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); + rRectangle[2] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = long (nX + aLayoutSize.Width() * 2 * 1.05); + rRectangle[3] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.Y() = long (aLayoutPos.Y() + aLayoutSize.Height() * 1.095); + rRectangle[4] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = long (nX + aLayoutSize.Width() * 1.05); + rRectangle[5] = Rectangle (aLayoutPos, aLayoutSize); + + aLayoutPos.X() = nX; + rRectangle[6] = Rectangle (aLayoutPos, aLayoutSize); + + break; + } + + } +} + + +void findAutoLayoutShapesImpl( SdPage& rPage, const LayoutDescriptor& rDescriptor, std::vector< SdrObject* >& rShapes, bool bInit, bool bSwitchLayout ) +{ + int i; + + // init list of indexes for each presentation shape kind + // this is used to find subsequent shapes with the same presentation shape kind + int PresObjIndex[PRESOBJ_MAX]; + for( i = 0; i < PRESOBJ_MAX; i++ ) PresObjIndex[i] = 1; + + bool bMissing = false; + + // for each entry in the layoutdescriptor, arrange a presentation shape + for( i = 0; (i < PRESOBJ_MAX) && (rDescriptor.meKind[i] != PRESOBJ_NONE); i++ ) + { + PresObjKind eKind = rDescriptor.meKind[i]; + SdrObject* pObj = 0; + while( (pObj = rPage.GetPresObj( eKind, PresObjIndex[eKind], true )) != 0 ) + { + PresObjIndex[eKind]++; // on next search for eKind, find next shape with same eKind + + if( !bSwitchLayout || !pObj->IsEmptyPresObj() ) + { + rShapes[i] = pObj; + break; + } + } + + if( !pObj ) + bMissing = true; + } + + if( bMissing && bInit ) + { + // for each entry in the layoutdescriptor, look for an alternative shape + for( i = 0; (i < PRESOBJ_MAX) && (rDescriptor.meKind[i] != PRESOBJ_NONE); i++ ) + { + if( rShapes[i] ) + continue; + + PresObjKind eKind = rDescriptor.meKind[i]; + + SdrObject* pObj = 0; + bool bFound = false; + + const int nShapeCount = rPage.GetObjCount(); + int nShapeIndex = 0; + while((nShapeIndex < nShapeCount) && !bFound ) + { + pObj = rPage.GetObj(nShapeIndex++); + + if( pObj->IsEmptyPresObj() ) + continue; + + if( pObj->GetObjInventor() != SdrInventor ) + continue; + + // do not reuse shapes that are already part of the layout + if( std::find( rShapes.begin(), rShapes.end(), pObj ) != rShapes.end() ) + continue; + + bool bPresStyle = pObj->GetStyleSheet() && (pObj->GetStyleSheet()->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE); + SdrObjKind eSdrObjKind = static_cast< SdrObjKind >( pObj->GetObjIdentifier() ); + + switch( eKind ) + { + case PRESOBJ_TITLE: + bFound = eSdrObjKind == OBJ_TITLETEXT; + break; + case PRESOBJ_TABLE: + bFound = eSdrObjKind == OBJ_TABLE; + break; + case PRESOBJ_MEDIA: + bFound = eSdrObjKind == OBJ_MEDIA; + break; + case PRESOBJ_OUTLINE: + bFound = (eSdrObjKind == OBJ_OUTLINETEXT) || + ((eSdrObjKind == OBJ_TEXT) && bPresStyle) || + (eSdrObjKind == OBJ_TABLE) || (eSdrObjKind == OBJ_MEDIA) || (eSdrObjKind == OBJ_GRAF) || (eSdrObjKind == OBJ_OLE2); + break; + case PRESOBJ_GRAPHIC: + bFound = eSdrObjKind == OBJ_GRAF; + break; + case PRESOBJ_OBJECT: + if( eSdrObjKind == OBJ_OLE2 ) + { + SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj ); + if( pOle2 ) + { + if( pOle2->IsEmpty() ) + bFound = true; + else if( rPage.GetModel() ) + { + SdrModel* pSdrModel = rPage.GetModel(); + ::comphelper::IEmbeddedHelper *pPersist = pSdrModel->GetPersist(); + if( pPersist ) + { + uno::Reference < embed::XEmbeddedObject > xObject = pPersist->getEmbeddedObjectContainer(). + GetEmbeddedObject( static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ); + + // TODO CL->KA: Why is this not working anymore? + if( xObject.is() ) + { + SvGlobalName aClassId( xObject->getClassID() ); + + const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID ); + const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID ); + const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID ); + + if( aPluginClassId != aClassId && aAppletClassId != aClassId && aIFrameClassId != aClassId ) + { + bFound = true; + } + } + } + } + } + } + break; + case PRESOBJ_CHART: + case PRESOBJ_CALC: + if( eSdrObjKind == OBJ_OLE2 ) + { + SdrOle2Obj* pOle2 = dynamic_cast< SdrOle2Obj* >( pObj ); + if( pOle2 ) + { + if( + ((eKind == PRESOBJ_CHART) && + ( pOle2->GetProgName().EqualsAscii( "StarChart" ) || pOle2->IsChart() ) ) + || + ((eKind == PRESOBJ_CALC) && + ( pOle2->GetProgName().EqualsAscii( "StarCalc" ) || pOle2->IsCalc() ) ) ) + { + bFound = true; + } + } + break; + } + else if( eSdrObjKind == OBJ_TABLE ) + { + bFound = true; + } + break; + case PRESOBJ_PAGE: + case PRESOBJ_HANDOUT: + bFound = eSdrObjKind == OBJ_PAGE; + break; + case PRESOBJ_NOTES: + case PRESOBJ_TEXT: + bFound = (bPresStyle && (eSdrObjKind == OBJ_TEXT)) || (eSdrObjKind == OBJ_OUTLINETEXT); + break; + default: + break; + } + } + + if( bFound ) + rShapes[i] = pObj; + } + } +} + +void SdPage::SetAutoLayout(AutoLayout eLayout, BOOL bInit, BOOL bCreate ) +{ + sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement ); + + const bool bSwitchLayout = eLayout != GetAutoLayout(); + + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && IsInserted(); + + meAutoLayout = eLayout; + + // if needed, creates and initialises the presentation shapes on this slides master page + CreateTitleAndLayout(bInit, bCreate); + + if((meAutoLayout == AUTOLAYOUT_NONE && maPresentationShapeList.isEmpty()) || mbMaster) + { + // MasterPage or no layout and no presentation shapes available, noting to do + return; + } + + Rectangle aRectangle[MAX_PRESOBJS]; + const LayoutDescriptor& aDescriptor = GetLayoutDescriptor( meAutoLayout ); + CalcAutoLayoutRectangles( *this, aDescriptor.mnLayout, aRectangle ); + + std::set< SdrObject* > aUsedPresentationObjects; + + + std::vector< SdrObject* > aLayoutShapes(PRESOBJ_MAX, 0); + findAutoLayoutShapesImpl( *this, aDescriptor, aLayoutShapes, bInit, bSwitchLayout ); + + int i; + + // for each entry in the layoutdescriptor, arrange a presentation shape + for( i = 0; (i < PRESOBJ_MAX) && (aDescriptor.meKind[i] != PRESOBJ_NONE); i++ ) + { + PresObjKind eKind = aDescriptor.meKind[i]; + SdrObject* pObj = InsertAutoLayoutShape( aLayoutShapes[i], eKind, aDescriptor.mbVertical[i], aRectangle[i], bInit ); + if( pObj ) + aUsedPresentationObjects.insert(pObj); // remember that we used this empty shape + } + + // now delete all empty presentation objects that are no longer used by the new layout + if( bInit ) + { + SdrObject* pObj = maPresentationShapeList.getNextShape(0); + + while( pObj ) + { + SdrObject* pNext = maPresentationShapeList.getNextShape(pObj); + if( aUsedPresentationObjects.count(pObj) == 0 ) + { + + if( pObj->IsEmptyPresObj() ) + { + if( bUndo ) + pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); + + RemoveObject( pObj->GetOrdNum() ); + + if( !bUndo ) + SdrObject::Free( pObj ); + } +/* #i108541# keep non empty pres obj as pres obj even if they are not part of the current layout + else + { + if( bUndo ) + { + pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pObj ) ); + if( pObj->GetUserCall() ) + pUndoManager->AddUndoAction( new UndoObjectUserCall( *pObj ) ); + } + maPresentationShapeList.removeShape( *pObj ); + pObj->SetUserCall(0); + } +*/ + } + pObj = pNext; + } + } +} + +/************************************************************************* +|* +|* Objekt einfuegen +|* +\************************************************************************/ + +void SdPage::NbcInsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* pReason) +{ + FmFormPage::NbcInsertObject(pObj, nPos, pReason); + + ((SdDrawDocument*) pModel)->InsertObject(pObj, this); + + SdrLayerID nId = pObj->GetLayer(); + if( mbMaster ) + { + if( nId == 0 ) + pObj->NbcSetLayer( 2 ); // wrong layer. corrected to BackgroundObj layer + } + else + { + if( nId == 2 ) + pObj->NbcSetLayer( 0 ); // wrong layer. corrected to layout layer + } +} + +/************************************************************************* +|* +|* Objekt loeschen +|* +\************************************************************************/ + +SdrObject* SdPage::RemoveObject(ULONG nObjNum) +{ + onRemoveObject(GetObj( nObjNum )); + return FmFormPage::RemoveObject(nObjNum); +} + +/************************************************************************* +|* +|* Objekt loeschen, ohne Broadcast +|* +\************************************************************************/ + +SdrObject* SdPage::NbcRemoveObject(ULONG nObjNum) +{ + onRemoveObject(GetObj( nObjNum )); + return FmFormPage::NbcRemoveObject(nObjNum); +} + +// #95876# Also overload ReplaceObject methods to realize when +// objects are removed with this mechanism instead of RemoveObject +SdrObject* SdPage::NbcReplaceObject(SdrObject* pNewObj, ULONG nObjNum) +{ + onRemoveObject(GetObj( nObjNum )); + return FmFormPage::NbcReplaceObject(pNewObj, nObjNum); +} + +// #95876# Also overload ReplaceObject methods to realize when +// objects are removed with this mechanism instead of RemoveObject +SdrObject* SdPage::ReplaceObject(SdrObject* pNewObj, ULONG nObjNum) +{ + onRemoveObject(GetObj( nObjNum )); + return FmFormPage::ReplaceObject(pNewObj, nObjNum); +} + +// ------------------------------------------------------------------------- + +// called after a shape is removed or replaced from this slide + +void SdPage::onRemoveObject( SdrObject* pObject ) +{ + if( pObject ) + { + RemovePresObj(pObject); + + if( pModel ) + static_cast<SdDrawDocument*>(pModel)->RemoveObject(pObject, this); + + removeAnimations( pObject ); + } +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetSize(const Size& aSize) +{ + Size aOldSize = GetSize(); + + if (aSize != aOldSize) + { + FmFormPage::SetSize(aSize); + + if (aOldSize.Height() == 10 && aOldSize.Width() == 10) + { + // Die Seite bekommt erstmalig eine gueltige Groesse gesetzt, + // daher wird nun die Orientation initialisiert + if (aSize.Width() > aSize.Height()) + { + meOrientation = ORIENTATION_LANDSCAPE; + } + else + { + meOrientation = ORIENTATION_PORTRAIT; + } + } + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetBorder(INT32 nLft, INT32 nUpp, INT32 nRgt, INT32 nLwr) +{ + if (nLft != GetLftBorder() || nUpp != GetUppBorder() || + nRgt != GetRgtBorder() || nLwr != GetLwrBorder() ) + { + FmFormPage::SetBorder(nLft, nUpp, nRgt, nLwr); + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetLftBorder(INT32 nBorder) +{ + if (nBorder != GetLftBorder() ) + { + FmFormPage::SetLftBorder(nBorder); + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetRgtBorder(INT32 nBorder) +{ + if (nBorder != GetRgtBorder() ) + { + FmFormPage::SetRgtBorder(nBorder); + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetUppBorder(INT32 nBorder) +{ + if (nBorder != GetUppBorder() ) + { + FmFormPage::SetUppBorder(nBorder); + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetLwrBorder(INT32 nBorder) +{ + if (nBorder != GetLwrBorder() ) + { + FmFormPage::SetLwrBorder(nBorder); + } +} + +/************************************************************************* +|* +|* Setzt BackgroundFullSize und ruft dann AdjustBackground auf +|* +\************************************************************************/ + +void SdPage::SetBackgroundFullSize( BOOL bIn ) +{ + if( bIn != mbBackgroundFullSize ) + { + mbBackgroundFullSize = bIn; + } +} + +/************************************************************************* +|* +|* Alle Objekte an neue Seitengroesse anpassen +|* +|* bScaleAllObj: Alle Objekte werden in die neue Flaeche innerhalb der +|* Seitenraender skaliert. Dabei werden die Position, Groesse und bei +|* Praesentationsobjekten auf der MasterPage auch die Schrifthoehe der +|* Praesentationsvorlagen skaliert. +|* +\************************************************************************/ + +void SdPage::ScaleObjects(const Size& rNewPageSize, const Rectangle& rNewBorderRect, BOOL bScaleAllObj) +{ + sd::ScopeLockGuard aGuard( maLockAutoLayoutArrangement ); + + mbScaleObjects = bScaleAllObj; + SdrObject* pObj = NULL; + Point aRefPnt(0, 0); + Size aNewPageSize(rNewPageSize); + INT32 nLeft = rNewBorderRect.Left(); + INT32 nRight = rNewBorderRect.Right(); + INT32 nUpper = rNewBorderRect.Top(); + INT32 nLower = rNewBorderRect.Bottom(); + + // Negative Werte stehen fuer nicht zu aendernde Werte + // -> aktuelle Werte verwenden + if (aNewPageSize.Width() < 0) + { + aNewPageSize.Width() = GetWdt(); + } + if (aNewPageSize.Height() < 0) + { + aNewPageSize.Height() = GetHgt(); + } + if (nLeft < 0) + { + nLeft = GetLftBorder(); + } + if (nRight < 0) + { + nRight = GetRgtBorder(); + } + if (nUpper < 0) + { + nUpper = GetUppBorder(); + } + if (nLower < 0) + { + nLower = GetLwrBorder(); + } + + Point aBackgroundPos(nLeft, nUpper); + Size aBackgroundSize(aNewPageSize); + Rectangle aBorderRect (aBackgroundPos, aBackgroundSize); + + if (mbScaleObjects) + { + aBackgroundSize.Width() -= nLeft + nRight; + aBackgroundSize.Height() -= nUpper + nLower; + aBorderRect.SetSize(aBackgroundSize); + aNewPageSize = aBackgroundSize; + } + + long nOldWidth = GetWdt() - GetLftBorder() - GetRgtBorder(); + long nOldHeight = GetHgt() - GetUppBorder() - GetLwrBorder(); + + Fraction aFractX = Fraction(aNewPageSize.Width(), nOldWidth); + Fraction aFractY = Fraction(aNewPageSize.Height(), nOldHeight); + + ULONG nObjCnt = (mbScaleObjects ? GetObjCount() : 0); + + for (ULONG nObj = 0; nObj < nObjCnt; nObj++) + { + BOOL bIsPresObjOnMaster = FALSE; + + // Alle Objekte + pObj = GetObj(nObj); + + if (mbMaster && IsPresObj(pObj)) + { + // Es ist ein Praesentationsobjekt auf der MasterPage + bIsPresObjOnMaster = TRUE; + } + + if (pObj) + { + // #88084# remember aTopLeft as original TopLeft + Point aTopLeft(pObj->GetCurrentBoundRect().TopLeft()); + + if (!pObj->IsEdgeObj()) + { + /************************************************************** + * Objekt skalieren + **************************************************************/ + if (mbScaleObjects) + { + // #88084# use aTopLeft as original TopLeft + aRefPnt = aTopLeft; + } + + pObj->Resize(aRefPnt, aFractX, aFractY); + + if (mbScaleObjects) + { + SdrObjKind eObjKind = (SdrObjKind) pObj->GetObjIdentifier(); + + if (bIsPresObjOnMaster) + { + /********************************************************** + * Praesentationsvorlage: Texthoehe anpassen + **********************************************************/ + USHORT nIndexTitle = 0; + USHORT nIndexOutline = 0; + USHORT nIndexNotes = 0; + + if (pObj == GetPresObj(PRESOBJ_TITLE, nIndexTitle)) + { + SfxStyleSheet* pTitleSheet = GetStyleSheetForPresObj(PRESOBJ_TITLE); + + if (pTitleSheet) + { + SfxItemSet& rSet = pTitleSheet->GetItemSet(); + + SvxFontHeightItem& rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT); + ULONG nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT)); + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) ) + { + rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT_CJK); + nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK)); + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) ) + { + rOldHgt = (SvxFontHeightItem&) rSet.Get(EE_CHAR_FONTHEIGHT_CTL); + nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + rSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL)); + } + + pTitleSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + } + } + else if (pObj == GetPresObj(PRESOBJ_OUTLINE, nIndexOutline)) + { + String aName(GetLayoutName()); + aName += sal_Unicode( ' ' ); + + for (USHORT i=1; i<=9; i++) + { + String sLayoutName(aName); + sLayoutName += String::CreateFromInt32( (sal_Int32)i ); + SfxStyleSheet* pOutlineSheet = (SfxStyleSheet*)((SdDrawDocument*) pModel)->GetStyleSheetPool()->Find(sLayoutName, SD_STYLE_FAMILY_MASTERPAGE); + + if (pOutlineSheet) + { + // Neue Fonthoehe berechnen + SfxItemSet aTempSet(pOutlineSheet->GetItemSet()); + + SvxFontHeightItem& rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT); + ULONG nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT)); + + if( SFX_ITEM_AVAILABLE == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CJK ) ) + { + rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT_CJK); + nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK)); + } + + if( SFX_ITEM_AVAILABLE == aTempSet.GetItemState( EE_CHAR_FONTHEIGHT_CTL ) ) + { + rOldHgt = (SvxFontHeightItem&) aTempSet.Get(EE_CHAR_FONTHEIGHT_CTL); + nFontHeight = rOldHgt.GetHeight(); + nFontHeight = long(nFontHeight * (double) aFractY); + aTempSet.Put(SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL)); + } + + // Bullet anpassen + ((SdStyleSheet*) pOutlineSheet)->AdjustToFontHeight(aTempSet, FALSE); + + // Sonderbehandlung: die INVALIDS auf NULL-Pointer + // zurueckgesetzen (sonst landen INVALIDs oder + // Pointer auf die DefaultItems in der Vorlage; + // beides wuerde die Attribut-Vererbung unterbinden) + aTempSet.ClearInvalidItems(); + + // Sonderbehandlung: nur die gueltigen Anteile des + // BulletItems + if (aTempSet.GetItemState(EE_PARA_BULLET) == SFX_ITEM_AVAILABLE) + { + SvxBulletItem aOldBulItem((SvxBulletItem&) pOutlineSheet->GetItemSet().Get(EE_PARA_BULLET)); + SvxBulletItem& rNewBulItem = (SvxBulletItem&) aTempSet.Get(EE_PARA_BULLET); + aOldBulItem.CopyValidProperties(rNewBulItem); + aTempSet.Put(aOldBulItem); + } + + pOutlineSheet->GetItemSet().Put(aTempSet); + pOutlineSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + } + } + } + else if (pObj == GetPresObj(PRESOBJ_NOTES, nIndexNotes)) + { + SfxStyleSheet* pNotesSheet = GetStyleSheetForPresObj(PRESOBJ_NOTES); + + if (pNotesSheet) + { + ULONG nHeight = pObj->GetLogicRect().GetSize().Height(); + ULONG nFontHeight = (ULONG) (nHeight * 0.0741); + SfxItemSet& rSet = pNotesSheet->GetItemSet(); + rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT )); + rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CJK )); + rSet.Put( SvxFontHeightItem(nFontHeight, 100, EE_CHAR_FONTHEIGHT_CTL )); + pNotesSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + } + } + } + else if ( eObjKind != OBJ_TITLETEXT && + eObjKind != OBJ_OUTLINETEXT && + pObj->ISA(SdrTextObj) && + pObj->GetOutlinerParaObject() ) + { + /****************************************************** + * Normales Textobjekt: Texthoehe anpassen + ******************************************************/ + ULONG nScriptType = pObj->GetOutlinerParaObject()->GetTextObject().GetScriptType(); + USHORT nWhich = EE_CHAR_FONTHEIGHT; + if ( nScriptType == SCRIPTTYPE_ASIAN ) + nWhich = EE_CHAR_FONTHEIGHT_CJK; + else if ( nScriptType == SCRIPTTYPE_COMPLEX ) + nWhich = EE_CHAR_FONTHEIGHT_CTL; + + // #88084# use more modern method to scale the text height + sal_uInt32 nFontHeight = ((SvxFontHeightItem&)pObj->GetMergedItem(nWhich)).GetHeight(); + sal_uInt32 nNewFontHeight = sal_uInt32((double)nFontHeight * (double)aFractY); + + pObj->SetMergedItem(SvxFontHeightItem(nNewFontHeight, 100, nWhich)); + } + } + } + + if (mbScaleObjects && !pObj->IsEdgeObj()) + { + /************************************************************** + * Objektposition skalieren + **************************************************************/ + Point aNewPos; + + // #76447# corrected scaling; only distances may be scaled + // #88084# use aTopLeft as original TopLeft + aNewPos.X() = long((aTopLeft.X() - GetLftBorder()) * (double)aFractX) + nLeft; + aNewPos.Y() = long((aTopLeft.Y() - GetUppBorder()) * (double)aFractY) + nUpper; + + Size aVec(aNewPos.X() - aTopLeft.X(), aNewPos.Y() - aTopLeft.Y()); + + if (aVec.Height() != 0 || aVec.Width() != 0) + { + pObj->NbcMove(aVec); + } + + pObj->SetChanged(); + pObj->BroadcastObjectChange(); + } + } + } +} + +SdrObject* convertPresentationObjectImpl( SdPage& rPage, SdrObject* pSourceObj, PresObjKind& eObjKind, bool bVertical, Rectangle aRect ) +{ + SdDrawDocument* pModel = static_cast< SdDrawDocument* >( rPage.GetModel() ); + DBG_ASSERT( pModel, "sd::convertPresentationObjectImpl(), no model on page!" ); + if( !pModel || !pSourceObj ) + return pSourceObj; + + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && rPage.IsInserted(); + + SdrObject* pNewObj = pSourceObj; + if((eObjKind == PRESOBJ_OUTLINE) && (pSourceObj->GetObjIdentifier() == OBJ_TEXT) ) + { + pNewObj = rPage.CreatePresObj(PRESOBJ_OUTLINE, bVertical, aRect); + + // Text des Untertitels in das PRESOBJ_OUTLINE setzen + OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject(); + + if(pOutlParaObj) + { + // Text umsetzen + ::sd::Outliner* pOutl = pModel->GetInternalOutliner( TRUE ); + pOutl->Clear(); + pOutl->SetText( *pOutlParaObj ); + pOutlParaObj = pOutl->CreateParaObject(); + pNewObj->SetOutlinerParaObject( pOutlParaObj ); + pOutl->Clear(); + pNewObj->SetEmptyPresObj(FALSE); + + for (USHORT nLevel = 1; nLevel < 10; nLevel++) + { + // Neue Vorlage zuweisen + String aName(rPage.GetLayoutName()); + aName += sal_Unicode( ' ' ); + aName += String::CreateFromInt32( nLevel ); + SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>( pModel->GetStyleSheetPool()->Find(aName, SD_STYLE_FAMILY_MASTERPAGE) ); + + if (pSheet) + { + if (nLevel == 1) + { + SfxStyleSheet* pSubtitleSheet = rPage.GetStyleSheetForPresObj(PRESOBJ_TEXT); + + if (pSubtitleSheet) + pOutlParaObj->ChangeStyleSheetName(SD_STYLE_FAMILY_MASTERPAGE, pSubtitleSheet->GetName(), pSheet->GetName()); + } + + pNewObj->StartListening(*pSheet); + } + } + + // LRSpace-Item loeschen + SfxItemSet aSet(pModel->GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE ); + + aSet.Put(pNewObj->GetMergedItemSet()); + + aSet.ClearItem(EE_PARA_LRSPACE); + + pNewObj->SetMergedItemSet(aSet); + + if( bUndo ) + pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj) ); + + // Remove outline shape from page + rPage.RemoveObject( pSourceObj->GetOrdNum() ); + + if( !bUndo ) + SdrObject::Free( pSourceObj ); + } + } + else if((eObjKind == PRESOBJ_TEXT) && (pSourceObj->GetObjIdentifier() == OBJ_OUTLINETEXT) ) + { + // is there an outline shape we can use to replace empty subtitle shape? + pNewObj = rPage.CreatePresObj(PRESOBJ_TEXT, bVertical, aRect); + + // Text des Gliederungsobjekts in das PRESOBJ_TITLE setzen + OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject(); + + if(pOutlParaObj) + { + // Text umsetzen + ::sd::Outliner* pOutl = pModel->GetInternalOutliner(); + pOutl->Clear(); + pOutl->SetText( *pOutlParaObj ); + pOutlParaObj = pOutl->CreateParaObject(); + pNewObj->SetOutlinerParaObject( pOutlParaObj ); + pOutl->Clear(); + pNewObj->SetEmptyPresObj(FALSE); + + // Linken Einzug zuruecksetzen + SfxItemSet aSet(pModel->GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE ); + + aSet.Put(pNewObj->GetMergedItemSet()); + + const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&) aSet.Get(EE_PARA_LRSPACE); + SvxLRSpaceItem aNewLRItem(rLRItem); + aNewLRItem.SetTxtLeft(0); + aSet.Put(aNewLRItem); + + pNewObj->SetMergedItemSet(aSet); + + SfxStyleSheet* pSheet = rPage.GetStyleSheetForPresObj(PRESOBJ_TEXT); + if (pSheet) + pNewObj->SetStyleSheet(pSheet, TRUE); + + // Remove subtitle shape from page + if( bUndo ) + pUndoManager->AddUndoAction(pModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pSourceObj)); + + rPage.RemoveObject( pSourceObj->GetOrdNum() ); + + if( !bUndo ) + SdrObject::Free( pSourceObj ); + } + } + else if((eObjKind == PRESOBJ_OUTLINE) && (pSourceObj->GetObjIdentifier() != OBJ_OUTLINETEXT) ) + { + switch( pSourceObj->GetObjIdentifier() ) + { + case OBJ_TABLE: eObjKind = PRESOBJ_TABLE; break; + case OBJ_MEDIA: eObjKind = PRESOBJ_MEDIA; break; + case OBJ_GRAF: eObjKind = PRESOBJ_GRAPHIC; break; + case OBJ_OLE2: eObjKind = PRESOBJ_OBJECT; break; + } + } + + return pNewObj; +} + +/** reuses or creates a presentation shape for an auto layout that fits the given parameter + + @param eObjKind + The kind of presentation shape we like to have + @param nIndex + If > 1 we skip the first nIndex-1 shapes with the presentation shape kind eObjKind while + looking for an existing presentation shape + @param bVertical + If true, the shape is created vertical if bInit is true + @param aRect + The rectangle that should be used to transform the shape + @param bInit + If true the shape is created if not found + @returns + A presentation shape that was either found or created with the given parameters +*/ +SdrObject* SdPage::InsertAutoLayoutShape( SdrObject* pObj, PresObjKind eObjKind, bool bVertical, Rectangle aRect, bool bInit ) +{ + sd::UndoManager* pUndoManager = pModel ? static_cast<SdDrawDocument*>(pModel)->GetUndoManager() : 0; + const bool bUndo = pUndoManager && pUndoManager->isInListAction() && IsInserted(); + + if (!pObj && bInit) + { + pObj = CreatePresObj(eObjKind, bVertical, aRect); + } + else if ( pObj && (pObj->GetUserCall() || bInit) ) + { + // convert object if shape type does not match kind (f.e. converting outline text to subtitle text) + if( bInit ) + pObj = convertPresentationObjectImpl( *this, pObj, eObjKind, bVertical, aRect ); + + if( bUndo ) + { + pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) ); + pUndoManager->AddUndoAction( pModel->GetSdrUndoFactory().CreateUndoAttrObject( *pObj, TRUE, TRUE ) ); + pUndoManager->AddUndoAction( new UndoObjectUserCall( *pObj ) ); + } + +// if ( pObj->ISA(SdrGrafObj) && !pObj->IsEmptyPresObj() ) + ( /*(SdrGrafObj*)*/ pObj)->AdjustToMaxRect( aRect ); +// else +// SetLogicRect( pObj, aRect ); + + pObj->SetUserCall(this); + + SdrTextObj* pTextObject = dynamic_cast< SdrTextObj* >(pObj); + if( pTextObject ) + { + if( pTextObject->IsVerticalWriting() != (bVertical ? sal_True : sal_False) ) + { + pTextObject->SetVerticalWriting( bVertical ); + + // #94826# here make sure the correct anchoring is used when the object + // is re-used but orientation is changed + if(PRESOBJ_OUTLINE == eObjKind) + pTextObject->SetMergedItem(SdrTextHorzAdjustItem( bVertical ? SDRTEXTHORZADJUST_RIGHT : SDRTEXTHORZADJUST_BLOCK )); + } + + if( !mbMaster && (pTextObject->GetObjIdentifier() != OBJ_TABLE) ) + { + if ( pTextObject->IsAutoGrowHeight() ) + { + // switch off AutoGrowHeight, set new MinHeight + SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); + SdrTextMinFrameHeightItem aMinHeight( aRect.GetSize().Height() ); + aTempAttr.Put( aMinHeight ); + aTempAttr.Put( SdrTextAutoGrowHeightItem(FALSE) ); + pTextObject->SetMergedItemSet(aTempAttr); + pTextObject->SetLogicRect(aRect); + + // switch on AutoGrowHeight + SfxItemSet aAttr( ((SdDrawDocument*) pModel)->GetPool() ); + aAttr.Put( SdrTextAutoGrowHeightItem(TRUE) ); + + pTextObject->SetMergedItemSet(aAttr); + } + + if ( pTextObject->IsAutoGrowWidth() ) + { + // switch off AutoGrowWidth , set new MinWidth + SfxItemSet aTempAttr( ((SdDrawDocument*) pModel)->GetPool() ); + SdrTextMinFrameWidthItem aMinWidth( aRect.GetSize().Width() ); + aTempAttr.Put( aMinWidth ); + aTempAttr.Put( SdrTextAutoGrowWidthItem(FALSE) ); + pTextObject->SetMergedItemSet(aTempAttr); + pTextObject->SetLogicRect(aRect); + + // switch on AutoGrowWidth + SfxItemSet aAttr( ((SdDrawDocument*) pModel)->GetPool() ); + aAttr.Put( SdrTextAutoGrowWidthItem(TRUE) ); + pTextObject->SetMergedItemSet(aAttr); + } + } + } + } + + if(pObj && bInit ) + { + if( !IsPresObj( pObj ) ) + { + if( bUndo ) + pUndoManager->AddUndoAction( new UndoObjectPresentationKind( *pObj ) ); + + InsertPresObj( pObj, eObjKind ); + } + + // make adjustments for vertical title and outline shapes + if( bVertical && (( eObjKind == PRESOBJ_TITLE) || (eObjKind == PRESOBJ_OUTLINE))) + { + SfxItemSet aNewSet(pObj->GetMergedItemSet()); + aNewSet.Put( SdrTextAutoGrowWidthItem(TRUE) ); + aNewSet.Put( SdrTextAutoGrowHeightItem(FALSE) ); + if( eObjKind == PRESOBJ_OUTLINE ) + { + aNewSet.Put( SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP) ); + aNewSet.Put( SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT) ); + } + pObj->SetMergedItemSet(aNewSet); + } + } + + if ( pObj && (pObj->GetUserCall() || bInit) && ( pObj->IsEmptyPresObj() || !pObj->ISA(SdrGrafObj) ) ) + pObj->AdjustToMaxRect( aRect ); + + return pObj; +} + + +/************************************************************************* +|* +|* Liefert den PresObjKind eines Objektes zurueck +|* +\************************************************************************/ + +PresObjKind SdPage::GetPresObjKind(SdrObject* pObj) const +{ + PresObjKind eKind = PRESOBJ_NONE; + if( (pObj != 0) && (maPresentationShapeList.hasShape(*pObj)) ) + { + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj); + if( pInfo ) + eKind = pInfo->mePresObjKind; + } + + return eKind; +} + +bool SdPage::IsPresObj(const SdrObject* pObj) +{ + return pObj && maPresentationShapeList.hasShape( const_cast<SdrObject&>(*pObj) ); +} + +void SdPage::RemovePresObj(const SdrObject* pObj) +{ + if( pObj && maPresentationShapeList.hasShape(const_cast<SdrObject&>(*pObj)) ) + { + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(const_cast<SdrObject&>(*pObj)); + if( pInfo ) + pInfo->mePresObjKind = PRESOBJ_NONE; + maPresentationShapeList.removeShape(const_cast<SdrObject&>(*pObj)); + } +} + +void SdPage::InsertPresObj(SdrObject* pObj, PresObjKind eKind ) +{ + DBG_ASSERT( pObj, "sd::SdPage::InsertPresObj(), invalid presentation object inserted!" ); + DBG_ASSERT( !IsPresObj(pObj), "sd::SdPage::InsertPresObj(), presentation object inserted twice!" ); + if( pObj ) + { + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pObj, true); + if( pInfo ) + pInfo->mePresObjKind = eKind; + maPresentationShapeList.addShape(*pObj); + } +} + +/************************************************************************* +|* +|* Text des Objektes setzen +|* +\************************************************************************/ + +void SdPage::SetObjText(SdrTextObj* pObj, SdrOutliner* pOutliner, PresObjKind eObjKind, const String& rString ) +{ + if ( pObj ) + { + DBG_ASSERT( pObj->ISA(SdrTextObj), "SetObjText: Kein SdrTextObj!" ); + ::Outliner* pOutl = pOutliner; + + if (!pOutliner) + { + SfxItemPool* pPool = ((SdDrawDocument*) GetModel())->GetDrawOutliner().GetEmptyItemSet().GetPool(); + pOutl = new ::Outliner( pPool, OUTLINERMODE_OUTLINEOBJECT ); + pOutl->SetRefDevice( SD_MOD()->GetRefDevice( *( (SdDrawDocument*) GetModel() )->GetDocSh() ) ); + pOutl->SetEditTextObjectPool(pPool); + pOutl->SetStyleSheetPool((SfxStyleSheetPool*)GetModel()->GetStyleSheetPool()); + pOutl->EnableUndo(FALSE); + pOutl->SetUpdateMode( FALSE ); + } + + USHORT nOutlMode = pOutl->GetMode(); + Size aPaperSize = pOutl->GetPaperSize(); + BOOL bUpdateMode = pOutl->GetUpdateMode(); + pOutl->SetUpdateMode(FALSE); + pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() ); + + // #95114# Always set the object's StyleSheet at the Outliner to + // use the current objects StyleSheet. Thus it's the same as in + // SetText(...). + // #95114# Moved this implementation from where SetObjText(...) was called + // to inside this method to work even when outliner is fetched here. + pOutl->SetStyleSheet(0, pObj->GetStyleSheet()); + + String aString; + + switch( eObjKind ) + { + case PRESOBJ_OUTLINE: + { + pOutl->Init( OUTLINERMODE_OUTLINEOBJECT ); + + aString += sal_Unicode( '\t' ); + aString += rString; + + if (mbMaster) + { + pOutl->SetStyleSheet( 0, GetStyleSheetForPresObj(eObjKind) ); + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER2 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER3 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER4 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER5 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER6 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER7 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER8 ) ); + + aString += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "\n\t\t\t\t\t\t\t\t\t" )); + aString += String ( SdResId( STR_PRESOBJ_MPOUTLLAYER9 ) ); + } + } + break; + + case PRESOBJ_TITLE: + { + pOutl->Init( OUTLINERMODE_TITLEOBJECT ); + aString += rString; + } + break; + + default: + { + pOutl->Init( OUTLINERMODE_TEXTOBJECT ); + aString += rString; + + // check if we need to add a text field + SvxFieldData* pData = NULL; + + switch( eObjKind ) + { + case PRESOBJ_HEADER: + pData = new SvxHeaderField(); + break; + case PRESOBJ_FOOTER: + pData = new SvxFooterField(); + break; + case PRESOBJ_SLIDENUMBER: + pData = new SvxPageField(); + break; + case PRESOBJ_DATETIME: + pData = new SvxDateTimeField(); + break; + default: + break; + } + + if( pData ) + { + ESelection e; + SvxFieldItem aField( *pData, EE_FEATURE_FIELD ); + pOutl->QuickInsertField(aField,e); + delete pData; + } + } + break; + } + + pOutl->SetPaperSize( pObj->GetLogicRect().GetSize() ); + + if( aString.Len() ) + pOutl->SetText( aString, pOutl->GetParagraph( 0 ) ); + + ( (SdrTextObj*) pObj)->SetOutlinerParaObject( pOutl->CreateParaObject() ); + + if (!pOutliner) + { + delete pOutl; + pOutl = NULL; + } + else + { + // Outliner restaurieren + pOutl->Init( nOutlMode ); + pOutl->SetParaAttribs( 0, pOutl->GetEmptyItemSet() ); + pOutl->SetUpdateMode( bUpdateMode ); + pOutl->SetPaperSize( aPaperSize ); + } + } +} + +/************************************************************************* +|* +|* Link & Daten von einem VControl empfangen +|* +\************************************************************************/ + +void SdPage::SetLinkData(const String&, const String& ) +{ +} + +/************************************************************************* +|* +|* Layoutname setzen +|* +\************************************************************************/ +void SdPage::SetLayoutName(String aName) +{ + maLayoutName = aName; + + if( mbMaster ) + { + String aSep( RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR) ); + USHORT nPos = maLayoutName.Search( aSep ); + if ( nPos != STRING_NOTFOUND ) + { + FmFormPage::SetName(maLayoutName.Copy(0, nPos)); + } + } +} + + +/************************************************************************* +|* +|* Seitenname zurueckgeben und ggf. generieren +|* +\************************************************************************/ + +const String& SdPage::GetName() const +{ + String aCreatedPageName( maCreatedPageName ); + if (GetRealName().Len() == 0) + { + if ((mePageKind == PK_STANDARD || mePageKind == PK_NOTES) && !mbMaster) + { + // default name for handout pages + USHORT nNum = (GetPageNum() + 1) / 2; + + aCreatedPageName = String(SdResId(STR_PAGE)); + aCreatedPageName += sal_Unicode( ' ' ); + if( GetModel()->GetPageNumType() == SVX_NUMBER_NONE ) + { + // if the document has number none as a formating + // for page numbers we still default to arabic numbering + // to keep the default page names unique + aCreatedPageName += String::CreateFromInt32( (sal_Int32)nNum ); + } + else + { + aCreatedPageName += ((SdDrawDocument*) GetModel())->CreatePageNumValue(nNum); + } + } + else + { + /****************************************************************** + * Defaultname fuer Handzettelseiten + ******************************************************************/ + aCreatedPageName = String(SdResId(STR_LAYOUT_DEFAULT_NAME)); + } + } + else + { + aCreatedPageName = GetRealName(); + } + + if (mePageKind == PK_NOTES) + { + aCreatedPageName += sal_Unicode( ' ' ); + aCreatedPageName += String(SdResId(STR_NOTES)); + } + else if (mePageKind == PK_HANDOUT && mbMaster) + { + aCreatedPageName += String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( " (" )); + aCreatedPageName += String(SdResId(STR_HANDOUT)); + aCreatedPageName += sal_Unicode( ')' ); + } + + const_cast< SdPage* >(this)->maCreatedPageName = aCreatedPageName; + return maCreatedPageName; +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void SdPage::SetOrientation( Orientation eOrient) +{ + meOrientation = eOrient; +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +Orientation SdPage::GetOrientation() const +{ + return meOrientation; +} + +/************************************************************************* +|* +|* Liefert den Default-Text eines PresObjektes zurueck +|* +\************************************************************************/ + +String SdPage::GetPresObjText(PresObjKind eObjKind) const +{ + String aString; + + if (eObjKind == PRESOBJ_TITLE) + { + if (mbMaster) + { + if (mePageKind != PK_NOTES) + { + aString = String ( SdResId( STR_PRESOBJ_MPTITLE ) ); + } + else + { + aString = String ( SdResId( STR_PRESOBJ_MPNOTESTITLE ) ); + } + } + else + { + aString = String ( SdResId( STR_PRESOBJ_TITLE ) ); + } + } + else if (eObjKind == PRESOBJ_OUTLINE) + { + if (mbMaster) + { + aString = String ( SdResId( STR_PRESOBJ_MPOUTLINE ) ); + } + else + { + aString = String ( SdResId( STR_PRESOBJ_OUTLINE ) ); + } + } + else if (eObjKind == PRESOBJ_NOTES) + { + if (mbMaster) + { + aString = String ( SdResId( STR_PRESOBJ_MPNOTESTEXT ) ); + } + else + { + aString = String ( SdResId( STR_PRESOBJ_NOTESTEXT ) ); + } + } + else if (eObjKind == PRESOBJ_TEXT) + { + aString = String ( SdResId( STR_PRESOBJ_TEXT ) ); + } + else if (eObjKind == PRESOBJ_GRAPHIC) + { + aString = String ( SdResId( STR_PRESOBJ_GRAPHIC ) ); + } + else if (eObjKind == PRESOBJ_OBJECT) + { + aString = String ( SdResId( STR_PRESOBJ_OBJECT ) ); + } + else if (eObjKind == PRESOBJ_CHART) + { + aString = String ( SdResId( STR_PRESOBJ_CHART ) ); + } + else if (eObjKind == PRESOBJ_ORGCHART) + { + aString = String ( SdResId( STR_PRESOBJ_ORGCHART ) ); + } + else if (eObjKind == PRESOBJ_CALC) + { + aString = String ( SdResId( STR_PRESOBJ_TABLE ) ); + } + + return(aString); +} + +extern uno::Reference< uno::XInterface > createUnoPageImpl( SdPage* pPage ); + +uno::Reference< uno::XInterface > SdPage::createUnoPage() +{ + return createUnoPageImpl( this ); +} + +/** returns the SdPage implementation for the given XDrawPage or 0 if not available */ +SdPage* SdPage::getImplementation( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xPage ) +{ + try + { + ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( xPage, ::com::sun::star::uno::UNO_QUERY ); + if( xUnoTunnel.is() ) + { + SvxDrawPage* pUnoPage = reinterpret_cast<SvxDrawPage*>(sal::static_int_cast<sal_uIntPtr>(xUnoTunnel->getSomething( SvxDrawPage::getUnoTunnelId()) ) ); + if( pUnoPage ) + return static_cast< SdPage* >( pUnoPage->GetSdrPage() ); + } + } + catch( ::com::sun::star::uno::Exception& e ) + { + (void)e; + DBG_ERROR("sd::SdPage::getImplementation(), exception cathced!" ); + } + + return 0; +} + +void SdPage::SetName (const String& rName) +{ + String aOldName = GetName(); + FmFormPage::SetName (rName); + static_cast<SdDrawDocument*>(pModel)->UpdatePageRelativeURLs(aOldName, rName); + ActionChanged(); +} + +const HeaderFooterSettings& SdPage::getHeaderFooterSettings() const +{ + if( mePageKind == PK_HANDOUT && !mbMaster ) + { + return (((SdPage&)TRG_GetMasterPage()).maHeaderFooterSettings); + } + else + { + return maHeaderFooterSettings; + } +} + +void SdPage::setHeaderFooterSettings( const sd::HeaderFooterSettings& rNewSettings ) +{ + if( mePageKind == PK_HANDOUT && !mbMaster ) + { + (((SdPage&)TRG_GetMasterPage()).maHeaderFooterSettings) = rNewSettings; + } + else + { + maHeaderFooterSettings = rNewSettings; + } + + SetChanged(); + if(TRG_HasMasterPage()) + { + TRG_GetMasterPageDescriptorViewContact().ActionChanged(); + } +} + +bool SdPage::checkVisibility( + const sdr::contact::ViewObjectContact& rOriginal, + const sdr::contact::DisplayInfo& rDisplayInfo, + bool bEdit ) +{ + if( !FmFormPage::checkVisibility( rOriginal, rDisplayInfo, bEdit ) ) + return false; + + SdrObject* pObj = rOriginal.GetViewContact().TryToGetSdrObject(); + if( pObj == NULL ) + return false; + + const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage()); + const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter() || rOriginal.GetObjectContact().isOutputToPDFFile()); + const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView(); + const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage); + + // empty presentation objects only visible during edit mode + if( (bIsPrinting || !bEdit || bIsInsidePageObj ) && pObj->IsEmptyPresObj() ) + { + if( (pObj->GetObjInventor() != SdrInventor) || ( (pObj->GetObjIdentifier() != OBJ_RECT) && (pObj->GetObjIdentifier() != OBJ_PAGE) ) ) + return false; + } + + if( ( pObj->GetObjInventor() == SdrInventor ) && ( pObj->GetObjIdentifier() == OBJ_TEXT ) ) + { + const SdPage* pCheckPage = dynamic_cast< const SdPage* >(pObj->GetPage()); + + if( pCheckPage ) + { + PresObjKind eKind = pCheckPage->GetPresObjKind(pObj); + + if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) ) + { + const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive()); + + if( bSubContentProcessing || ( pCheckPage->GetPageKind() == PK_HANDOUT && bIsPrinting ) ) + { + // use the page that is currently processed + const SdPage* pVisualizedSdPage = dynamic_cast< const SdPage* >(pVisualizedPage); + + if( pVisualizedSdPage ) + { + // if we are not on a masterpage, see if we have to draw this header&footer object at all + const sd::HeaderFooterSettings& rSettings = pVisualizedSdPage->getHeaderFooterSettings(); + + switch( eKind ) + { + case PRESOBJ_FOOTER: + return rSettings.mbFooterVisible; + case PRESOBJ_HEADER: + return rSettings.mbHeaderVisible; + case PRESOBJ_DATETIME: + return rSettings.mbDateTimeVisible; + case PRESOBJ_SLIDENUMBER: + return rSettings.mbSlideNumberVisible; + default: + break; + } + } + } + } // check for placeholders on master + else if( (eKind != PRESOBJ_NONE) && pCheckPage->IsMasterPage() && ( pVisualizedPage != pCheckPage ) ) + { + // presentation objects on master slide are always invisible if slide is shown. + return false; + } + } + } + + // i63977, do not print SdrpageObjs from master pages + if( ( pObj->GetObjInventor() == SdrInventor ) && ( pObj->GetObjIdentifier() == OBJ_PAGE ) ) + { + if( pObj->GetPage() && pObj->GetPage()->IsMasterPage() ) + return false; + } + + return true; +} + +bool SdPage::RestoreDefaultText( SdrObject* pObj ) +{ + bool bRet = false; + + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj ); + + if( pTextObj ) + { + PresObjKind ePresObjKind = GetPresObjKind(pTextObj); + + if (ePresObjKind == PRESOBJ_TITLE || + ePresObjKind == PRESOBJ_OUTLINE || + ePresObjKind == PRESOBJ_NOTES || + ePresObjKind == PRESOBJ_TEXT) + { + String aString( GetPresObjText(ePresObjKind) ); + + if (aString.Len()) + { + BOOL bVertical = FALSE; + OutlinerParaObject* pOldPara = pTextObj->GetOutlinerParaObject(); + if( pOldPara ) + bVertical = pOldPara->IsVertical(); // is old para object vertical? + + SetObjText( pTextObj, 0, ePresObjKind, aString ); + + if( pOldPara ) + { + //pTextObj->SetVerticalWriting( bVertical ); + // + // #94826# Here, only the vertical flag for the + // OutlinerParaObjects needs to be changed. The + // AutoGrowWidth/Height items still exist in the + // not changed object. + if(pTextObj + && pTextObj->GetOutlinerParaObject() + && pTextObj->GetOutlinerParaObject()->IsVertical() != (bool)bVertical) + { + Rectangle aObjectRect = pTextObj->GetSnapRect(); + pTextObj->GetOutlinerParaObject()->SetVertical(bVertical); + pTextObj->SetSnapRect(aObjectRect); + } + } + + pTextObj->SetTextEditOutliner( NULL ); // to make stylesheet settings work + pTextObj->NbcSetStyleSheet( GetStyleSheetForPresObj(ePresObjKind), TRUE ); + pTextObj->SetEmptyPresObj(TRUE); + bRet = true; + } + } + } + return bRet; +} + +void SdPage::CalculateHandoutAreas( SdDrawDocument& rModel, AutoLayout eLayout, bool bHorizontal, std::vector< Rectangle >& rAreas ) +{ + SdPage& rHandoutMaster = *rModel.GetMasterSdPage( 0, PK_HANDOUT ); + + if( eLayout == AUTOLAYOUT_NONE ) + { + // use layout from handout master + SdrObjListIter aShapeIter (rHandoutMaster); + while (aShapeIter.IsMore()) + { + SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next()); + if (pPageObj) + rAreas.push_back( pPageObj->GetCurrentBoundRect() ); + } + } + else + { + Size aArea = rHandoutMaster.GetSize(); + + const long nGapW = 1000; // gap is 1cm + const long nGapH = 1000; + + long nLeftBorder = rHandoutMaster.GetLftBorder(); + long nRightBorder = rHandoutMaster.GetRgtBorder(); + long nTopBorder = rHandoutMaster.GetUppBorder(); + long nBottomBorder = rHandoutMaster.GetLwrBorder(); + + const long nHeaderFooterHeight = static_cast< long >( (aArea.Height() - nTopBorder - nLeftBorder) * 0.05 ); + + nTopBorder += nHeaderFooterHeight; + nBottomBorder += nHeaderFooterHeight; + + long nX = nGapW + nLeftBorder; + long nY = nGapH + nTopBorder; + + aArea.Width() -= nGapW * 2 + nLeftBorder + nRightBorder; + aArea.Height() -= nGapH * 2 + nTopBorder + nBottomBorder; + + const bool bLandscape = aArea.Width() > aArea.Height(); + + static sal_uInt16 aOffsets[5][9] = + { + { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, // AUTOLAYOUT_HANDOUT9, Portrait, Horizontal order + { 0, 2, 4, 1, 3, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT3, Landscape, Vertical + { 0, 2, 1, 3, 0, 0, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Landscape, Vertical + { 0, 3, 1, 4, 2, 5, 0, 0, 0 }, // AUTOLAYOUT_HANDOUT4, Portrait, Vertical + { 0, 3, 6, 1, 4, 7, 2, 5, 8 }, // AUTOLAYOUT_HANDOUT9, Landscape, Vertical + }; + + sal_uInt16* pOffsets = aOffsets[0]; + USHORT nColCnt = 0, nRowCnt = 0; + switch ( eLayout ) + { + case AUTOLAYOUT_HANDOUT1: + nColCnt = 1; nRowCnt = 1; + break; + + case AUTOLAYOUT_HANDOUT2: + if( bLandscape ) + { + nColCnt = 2; nRowCnt = 1; + } + else + { + nColCnt = 1; nRowCnt = 2; + } + break; + + case AUTOLAYOUT_HANDOUT3: + if( bLandscape ) + { + nColCnt = 3; nRowCnt = 2; + } + else + { + nColCnt = 2; nRowCnt = 3; + } + pOffsets = aOffsets[ bLandscape ? 1 : 0 ]; + break; + + case AUTOLAYOUT_HANDOUT4: + nColCnt = 2; nRowCnt = 2; + pOffsets = aOffsets[ bHorizontal ? 0 : 2 ]; + break; + + case AUTOLAYOUT_HANDOUT6: + if( bLandscape ) + { + nColCnt = 3; nRowCnt = 2; + } + else + { + nColCnt = 2; nRowCnt = 3; + } + if( !bHorizontal ) + pOffsets = aOffsets[ bLandscape ? 1 : 3 ]; + break; + + default: + case AUTOLAYOUT_HANDOUT9: + nColCnt = 3; nRowCnt = 3; + + if( !bHorizontal ) + pOffsets = aOffsets[4]; + break; + } + + rAreas.resize( nColCnt * nRowCnt ); + + Size aPartArea, aSize; + aPartArea.Width() = ((aArea.Width() - ((nColCnt-1) * nGapW) ) / nColCnt); + aPartArea.Height() = ((aArea.Height() - ((nRowCnt-1) * nGapH) ) / nRowCnt); + + SdrPage* pFirstPage = rModel.GetMasterSdPage(0, PK_STANDARD); + if ( pFirstPage ) + { + // scale actual size into handout rect + double fScale = (double)aPartArea.Width() / (double)pFirstPage->GetWdt(); + + aSize.Height() = (long)(fScale * pFirstPage->GetHgt() ); + if( aSize.Height() > aPartArea.Height() ) + { + fScale = (double)aPartArea.Height() / (double)pFirstPage->GetHgt(); + aSize.Height() = aPartArea.Height(); + aSize.Width() = (long)(fScale * pFirstPage->GetWdt()); + } + else + { + aSize.Width() = aPartArea.Width(); + } + + nX += (aPartArea.Width() - aSize.Width()) / 2; + nY += (aPartArea.Height()- aSize.Height())/ 2; + } + else + { + aSize = aPartArea; + } + + Point aPos( nX, nY ); + + const bool bRTL = rModel.GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB; + + const long nOffsetX = (aPartArea.Width() + nGapW) * (bRTL ? -1 : 1); + const long nOffsetY = aPartArea.Height() + nGapH; + const long nStartX = bRTL ? nOffsetX*(1 - nColCnt) - nX : nX; + + for(sal_uInt16 nRow = 0; nRow < nRowCnt; nRow++) + { + aPos.X() = nStartX; + for(sal_uInt16 nCol = 0; nCol < nColCnt; nCol++) + { + rAreas[*pOffsets++] = Rectangle(aPos, aSize); + aPos.X() += nOffsetX; + } + + aPos.Y() += nOffsetY; + } + } +} + + + + +void SdPage::SetPrecious (const bool bIsPrecious) +{ + mbIsPrecious = bIsPrecious; +} + + + + +bool SdPage::IsPrecious (void) const +{ + return mbIsPrecious; +} + + + + +HeaderFooterSettings::HeaderFooterSettings() +{ + mbHeaderVisible = true; + mbFooterVisible = true; + mbSlideNumberVisible = false; + mbDateTimeVisible = true; + mbDateTimeIsFixed = true; + meDateTimeFormat = SVXDATEFORMAT_A; +} + +bool HeaderFooterSettings::operator==( const HeaderFooterSettings& rSettings ) const +{ + return (mbHeaderVisible == rSettings.mbHeaderVisible) && + (maHeaderText == rSettings.maHeaderText) && + (mbFooterVisible == rSettings.mbFooterVisible) && + (maFooterText == rSettings.maFooterText) && + (mbSlideNumberVisible == rSettings.mbSlideNumberVisible) && + (mbDateTimeVisible == rSettings.mbDateTimeVisible) && + (mbDateTimeIsFixed == rSettings.mbDateTimeIsFixed) && + (meDateTimeFormat == rSettings.meDateTimeFormat) && + (maDateTimeText == rSettings.maDateTimeText); +} + |