/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
// disconnect the UserCall link, so we don't get calls // back into this dying object when the child objects die
SdrObjListIter aIter( this, SdrIterMode::DeepWithGroups ); while( aIter.IsMore() )
{
SdrObject* pChild = aIter.Next(); if( pChild->GetUserCall() == this )
pChild->SetUserCall(nullptr);
}
}
/** 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;
// 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 drawing::FillStyle_NONE
OSL_FAIL("No Style for MasterPageBackground fill found (!)");
getSdrPageProperties().PutItem(XFillStyleItem(drawing::FillStyle_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 ::tools::Rectangle& rRect )
{
SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager()); constbool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
rtl::Reference<SdrObject> pSdrObj;
bool bForceText = false; // forces the shape text to be set even if it's empty bool bEmptyPresObj = true;
switch( eObjKind )
{ case PresObjKind::Title:
{
pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::TitleText);
if (mbMaster)
{
pSdrObj->SetNotVisibleAsMaster(true);
}
} break;
case PresObjKind::Outline:
{
pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::OutlineText);
if (mbMaster)
{
pSdrObj->SetNotVisibleAsMaster(true);
}
} break;
case PresObjKind::Notes:
{
pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
if (mbMaster)
{
pSdrObj->SetNotVisibleAsMaster(true);
}
} break;
case PresObjKind::Text:
{
pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
} break;
case PresObjKind::Media: case PresObjKind::Object:
{
pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage());
BitmapEx aBmpEx(BMP_PRESOBJ_OBJECT);
Graphic aGraphic( aBmpEx ); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetGraphic(aGraphic);
} break;
case PresObjKind::Chart:
{
pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage()); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetProgName( u"StarChart"_ustr );
BitmapEx aBmpEx(BMP_PRESOBJ_CHART);
Graphic aGraphic( aBmpEx ); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetGraphic(aGraphic);
} break;
case PresObjKind::OrgChart:
{
pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage()); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetProgName( u"StarOrg"_ustr );
BitmapEx aBmpEx(BMP_PRESOBJ_ORGCHART);
Graphic aGraphic( aBmpEx ); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetGraphic(aGraphic);
} break;
case PresObjKind::Table: case PresObjKind::Calc:
{
pSdrObj = new SdrOle2Obj(getSdrModelFromSdrPage()); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetProgName( u"StarCalc"_ustr );
BitmapEx aBmpEx(BMP_PRESOBJ_TABLE);
Graphic aGraphic( aBmpEx ); static_cast<SdrOle2Obj*>(pSdrObj.get())->SetGraphic(aGraphic);
} break;
case PresObjKind::Handout:
{ // Save the first standard page at SdrPageObj // #i105146# We want no content to be displayed for PageKind::Handout, // so just never set a page as content
pSdrObj = new SdrPageObj(getSdrModelFromSdrPage(), nullptr);
} break;
case PresObjKind::Page:
{ // Save note pages at SdrPageObj
sal_uInt16 nDestPageNum(GetPageNum());
if(nDestPageNum)
{ // decrement only when != 0, else we get a 0xffff
nDestPageNum -= 1;
}
if (nDestPageNum < getSdrModelFromSdrPage().GetPageCount())
{
pSdrObj = new SdrPageObj(getSdrModelFromSdrPage(), getSdrModelFromSdrPage().GetPage(nDestPageNum));
} else
{
pSdrObj = new SdrPageObj(getSdrModelFromSdrPage());
}
pSdrObj->SetResizeProtect(true);
} break;
case PresObjKind::Header: case PresObjKind::Footer: case PresObjKind::DateTime: case PresObjKind::SlideNumber:
{
pSdrObj = new SdrRectObj(getSdrModelFromSdrPage(), SdrObjKind::Text);
bEmptyPresObj = false;
bForceText = true;
} break; default: break;
}
if (pSdrObj)
{
pSdrObj->SetEmptyPresObj(bEmptyPresObj);
pSdrObj->SetLogicRect(rRect);
InsertObject(pSdrObj.get());
if ( auto pTextObj = DynCastSdrTextObj( pSdrObj.get() ) )
{ // Tell the object EARLY that it is vertical to have the // defaults for AutoGrowWidth/Height reversed if(bVertical)
pTextObj->SetVerticalWriting(true);
if (eObjKind == PresObjKind::Notes)
aTempAttr.Put(makeSdrTextAutoGrowHeightItem(false));
if (mbMaster)
{ // The size of presentation objects on the master page have to // be freely selectable by the user.
// potential problem: This action was still NOT // adapted for vertical text. This sure needs to be done. if(bVertical)
aTempAttr.Put(makeSdrTextAutoGrowWidthItem(false)); else
aTempAttr.Put(makeSdrTextAutoGrowHeightItem(false));
}
// check if we need another vertical adjustment than the default
SdrTextVertAdjust eV = SDRTEXTVERTADJUST_TOP;
if (mbMaster)
{
SdrLayerAdmin& rLayerAdmin(getSdrModelFromSdrPage().GetLayerAdmin());
// background objects of the master page
pSdrObj->SetLayer( rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects) );
}
// Subscribe object at the style sheet // Set style only when one was found (as in 5.2) if( mePageKind != PageKind::Handout )
{
SfxStyleSheet* pSheetForPresObj = GetStyleSheetForPresObj(eObjKind); if(pSheetForPresObj)
pSdrObj->SetStyleSheet(pSheetForPresObj, false);
}
if (eObjKind == PresObjKind::Outline)
{ for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++)
{
OUString aName( maLayoutName + " " + OUString::number( nLevel ) );
SfxStyleSheet* pSheet = static_cast<SfxStyleSheet*>(getSdrModelFromSdrPage().GetStyleSheetPool()->Find(aName, SfxStyleFamily::Page));
DBG_ASSERT(pSheet, "StyleSheet for outline object not found"); if (pSheet)
pSdrObj->StartListening(*pSheet, DuplicateHandling::Allow);
}
}
/************************************************************************* |* |* Creates presentation objects on the master page. |* All presentation objects get a UserCall to the page. |*
\************************************************************************/
case PresObjKind::Title:
aName += STR_LAYOUT_TITLE; break;
case PresObjKind::Notes:
aName += STR_LAYOUT_NOTES; break;
case PresObjKind::Text:
aName += STR_LAYOUT_SUBTITLE; break;
case PresObjKind::Header: case PresObjKind::Footer: case PresObjKind::DateTime: case PresObjKind::SlideNumber:
aName += STR_LAYOUT_BACKGROUNDOBJECTS; break;
/** returns the presentation style with the given helpid from this masterpage or this
slides masterpage */
SdStyleSheet* SdPage::getPresentationStyle( sal_uInt32 nHelpId ) const
{
OUString aStyleName( GetLayoutName() ); const OUString aSep( SD_LT_SEPARATOR );
sal_Int32 nIndex = aStyleName.indexOf(aSep); if( nIndex != -1 )
aStyleName = aStyleName.copy(0, nIndex + aSep.getLength());
OUString pNameId; bool bOutline = false; switch( nHelpId )
{ case HID_PSEUDOSHEET_TITLE: pNameId = STR_LAYOUT_TITLE; break; case HID_PSEUDOSHEET_SUBTITLE: pNameId = 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: pNameId = STR_LAYOUT_OUTLINE; bOutline = true; break; case HID_PSEUDOSHEET_BACKGROUNDOBJECTS: pNameId = STR_LAYOUT_BACKGROUNDOBJECTS; break; case HID_PSEUDOSHEET_BACKGROUND: pNameId = STR_LAYOUT_BACKGROUND; break; case HID_PSEUDOSHEET_NOTES: pNameId = STR_LAYOUT_NOTES; break;
/************************************************************************* |* |* The presentation object rObj has changed and is no longer referenced by the |* presentation object of the master page. |* The UserCall is deleted. |*
\************************************************************************/
if (bUndo)
pUndoManager->AddUndoAction(
std::make_unique<UndoObjectUserCall>(_rObj));
// Object was resized by user and does not listen to its slide anymore
_rObj.SetUserCall(nullptr);
}
} else
{ // Object of the master page changed, therefore adjust // object on all pages
sal_uInt16 nPageCount = static_cast<SdDrawDocument&>(getSdrModelFromSdrPage())
.GetSdPageCount(mePageKind);
for (sal_uInt16 i = 0; i < nPageCount; i++)
{
SdPage* pLoopPage = static_cast<SdDrawDocument&>(getSdrModelFromSdrPage())
.GetSdPage(i, mePageKind);
if (pLoopPage && this == &(pLoopPage->TRG_GetMasterPage()))
{ // Page listens to this master page, therefore // adjust AutoLayout
pLoopPage->SetAutoLayout(pLoopPage->GetAutoLayout());
}
}
}
} break;
case SdrUserCallType::Delete: case SdrUserCallType::Removed: default: break;
}
}
/************************************************************************* |* |* Creates on a master page: background, title- and layout area |*
\************************************************************************/
while( iter != aAreas.end() )
{
SdrPageObj* pPageObj = static_cast<SdrPageObj*>(pMasterPage->CreatePresObj(PresObjKind::Handout, false, (*iter++)) ); // #i105146# We want no content to be displayed for PageKind::Handout, // so just never set a page as content
pPageObj->SetReferencedPage(nullptr);
/************************************************************************* |* |* return title area |*
\************************************************************************/
// get the attribute value of layout (i.e it's type)
OUString sLayoutAttName = layoutAttrList->getNamedItem(u"type"_ustr)->getNodeValue(); return sLayoutAttName == sLayoutType;
}); if (aIter == layoutInfo.end()) return;
staticvoid findAutoLayoutShapesImpl( SdPage& rPage, const LayoutDescriptor& rDescriptor, std::array<SdrObject*, MAX_PRESOBJS>& rShapes, bool bInit, bool bSwitchLayout )
{ // init list of indexes for each presentation shape kind // this is used to find subsequent shapes with the same presentation shape kind
o3tl::enumarray<PresObjKind,int> PresObjIndex;
PresObjIndex.fill(1);
bool bMissing = false;
// for each entry in the layoutdescriptor, arrange a presentation shape for (int i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PresObjKind::NONE); i++)
{
PresObjKind eKind = rDescriptor.meKind[i];
SdrObject* pObj = nullptr; while( (pObj = rPage.GetPresObj( eKind, PresObjIndex[eKind], true )) != nullptr )
{
PresObjIndex[eKind]++; // on next search for eKind, find next shape with same eKind
// for each entry in the layoutdescriptor, look for an alternative shape for (int i = 0; (i < MAX_PRESOBJS) && (rDescriptor.meKind[i] != PresObjKind::NONE); i++)
{ if( rShapes[i] ) continue;
// 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, nothing to do return;
}
// for each entry in the layoutdescriptor, arrange a presentation shape for (int i = 0; (i < MAX_PRESOBJS) && (aDescriptor.meKind[i] != PresObjKind::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 ) return;
RemoveObject( pObj->GetOrdNum() );
pObj.clear();
} /* #i108541# keep non empty pres obj as pres obj even if they are not part of the current layout */
}
}
}
// Also override ReplaceObject methods to realize when // objects are removed with this mechanism instead of RemoveObject
rtl::Reference<SdrObject> SdPage::ReplaceObject(SdrObject* pNewObj, size_t nObjNum)
{
onRemoveObject(GetObj( nObjNum )); return FmFormPage::ReplaceObject(pNewObj, nObjNum);
}
// called after a shape is removed or replaced from this slide
void SdPage::NotifyPagePropertyChanges()
{ // Send the new size info to views, snapping to grid feature uses this info (maybe some others in the future).
::tools::JsonWriter jsonWriter;
jsonWriter.put("commandName", ".uno:PageSetup");
GetPageInfo(jsonWriter);
OString out = jsonWriter.finishAndGetAsOString(); if (SfxViewShell* pViewShell = SfxViewShell::Current())
{
pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, out);
pViewShell->NotifyOtherViews(LOK_CALLBACK_STATE_CHANGED, ".uno:PageSetup"_ostr, out);
}
}
/************************************************************************* |* |* Adjust all objects to new page size. |* |* bScaleAllObj: all objects are scaled into the new area within the page |* margins. We scale the position and size. For presentation objects on the |* master page, we also scale the font height of the presentation template. |*
\************************************************************************/
if (mbMaster && IsPresObj(pObj.get()))
{ // There is a presentation object on the master page
bIsPresObjOnMaster = true;
}
if (pObj)
{ // remember aTopLeft as original TopLeft
Point aTopLeft(pObj->GetCurrentBoundRect().TopLeft());
if (!pObj->IsEdgeObj())
{ /************************************************************** * Scale objects
**************************************************************/ if (mbScaleObjects)
{ // use aTopLeft as original TopLeft
aRefPnt = aTopLeft;
}
pObj->Resize(aRefPnt, aFractX, aFractY);
if (mbScaleObjects)
{
SdrObjKind eObjKind = pObj->GetObjIdentifier();
if (bIsPresObjOnMaster)
{ /********************************************************** * presentation template: adjust test height
**********************************************************/
if (pObj == GetPresObj(PresObjKind::Title, 0))
{
SfxStyleSheet* pTitleSheet = GetStyleSheetForPresObj(PresObjKind::Title);
if (pTitleSheet)
{
SfxItemSet& rSet = pTitleSheet->GetItemSet();
// Special treatment: reset the INVALIDS to // NULL pointer (otherwise we have INVALID's // or pointer to the DefaultItems in the // template; both would suppress the // attribute inheritance)
aTempSet.ClearInvalidItems();
// Special treatment: only the valid parts // of the BulletItems if (aTempSet.GetItemState(EE_PARA_BULLET) == SfxItemState::DEFAULT)
{
SvxBulletItem aOldBulItem( pOutlineSheet->GetItemSet().Get(EE_PARA_BULLET) ); const SvxBulletItem& rNewBulItem = aTempSet.Get(EE_PARA_BULLET);
aOldBulItem.CopyValidProperties(rNewBulItem);
aTempSet.Put(aOldBulItem);
}
// use more modern method to scale the text height
sal_uInt32 nFontHeight = static_cast<const SvxFontHeightItem&>(pObj->GetMergedItem(nWhich)).GetHeight();
sal_uInt32 nNewFontHeight = sal_uInt32(static_cast<double>(nFontHeight) * static_cast<double>(aFractY));
if (mbScaleObjects && !pObj->IsEdgeObj())
{ /************************************************************** * scale object position
**************************************************************/
Point aNewPos;
// corrected scaling; only distances may be scaled // use aTopLeft as original TopLeft
aNewPos.setX( ::tools::Long((aTopLeft.X() - GetLeftBorder()) * static_cast<double>(aFractX)) + nLeft );
aNewPos.setY( ::tools::Long((aTopLeft.Y() - GetUpperBorder()) * static_cast<double>(aFractY)) + nUpper );
// Remove outline shape from page
rPage.RemoveObject( pSourceObj->GetOrdNum() );
}
} elseif((eObjKind == PresObjKind::Text) && (pSourceObj->GetObjIdentifier() == SdrObjKind::OutlineText) )
{ // is there an outline shape we can use to replace empty subtitle shape?
pNewObj = rPage.CreatePresObj(PresObjKind::Text, bVertical, rRect);
// Set text of the outline object into PRESOBJ_TITLE
OutlinerParaObject* pOutlParaObj = pSourceObj->GetOutlinerParaObject();
/** 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 rRect 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* pObj1, PresObjKind eObjKind, boolbVertical, const ::tools::Rectangle& rRect, bool bInit)
{
rtl::Reference<SdrObject> pObj = pObj1;
SfxUndoManager* pUndoManager(static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetUndoManager()); constbool bUndo = pUndoManager && pUndoManager->IsInListAction() && IsInserted();
if (!pObj && bInit)
{
pObj = CreatePresObj(eObjKind, bVertical, rRect);
} elseif ( 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.get(), eObjKind, bVertical, rRect);
// here make sure the correct anchoring is used when the object // is re-used but orientation is changed if(PresObjKind::Outline == eObjKind)
pTextObject->SetMergedItem(SdrTextHorzAdjustItem( bVertical ? SDRTEXTHORZADJUST_RIGHT : SDRTEXTHORZADJUST_BLOCK ));
}
if( !mbMaster && (pTextObject->GetObjIdentifier() != SdrObjKind::Table) )
{ if ( pTextObject->IsAutoGrowHeight() )
{ // switch off AutoGrowHeight, set new MinHeight
SfxItemSet aTempAttr( static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).GetPool() );
SdrMetricItem aMinHeight( makeSdrTextMinFrameHeightItem(rRect.GetSize().Height()) );
aTempAttr.Put( aMinHeight );
aTempAttr.Put( makeSdrTextAutoGrowHeightItem(false) );
pTextObject->SetMergedItemSet(aTempAttr);
pTextObject->SetLogicRect(rRect);
/************************************************************************* |* |* Returns the PresObjKind of an object |*
\************************************************************************/
/************************************************************************* |* |* Set the text of an object |*
\************************************************************************/
// Always set the object's StyleSheet at the Outliner to // use the current objects StyleSheet. Thus it's the same as in // SetText(...). // 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());
OUString aString;
switch( eObjKind )
{ case PresObjKind::Outline:
{
pOutl->Init( OutlinerMode::OutlineObject );
/************************************************************************* |* |* Set the name of the layout |*
\************************************************************************/ void SdPage::SetLayoutName(const OUString& aName)
{
maLayoutName = aName;
/************************************************************************* |* |* Return the page name and generates it if necessary |*
\************************************************************************/
const OUString& SdPage::GetName() const
{
OUString aCreatedPageName( maCreatedPageName ); if (GetRealName().isEmpty())
{ if ((mePageKind == PageKind::Standard || mePageKind == PageKind::Notes) && !mbMaster)
{ // default name for handout pages
sal_uInt16 nNum = (GetPageNum() + 1) / 2;
if( getSdrModelFromSdrPage().GetPageNumType() == css::style::NumberingType::NUMBER_NONE )
{ // if the document has number none as a formatting // for page numbers we still default to arabic numbering // to keep the default page names unique
aCreatedPageName += OUString::number( static_cast<sal_Int32>(nNum) );
} else
{
aCreatedPageName += static_cast< SdDrawDocument& >(getSdrModelFromSdrPage()).CreatePageNumValue(nNum);
}
} else
{ /****************************************************************** * default name for note pages
******************************************************************/
aCreatedPageName = SdResId(STR_LAYOUT_DEFAULT_NAME);
}
} else
{
aCreatedPageName = GetRealName();
}
/************************************************************************* |* |* returns the default text of a PresObjektes |*
\************************************************************************/
// #i119056# For HeaderFooterSettings SdrObjects are used, but the properties // used are not part of their model data, but kept in SD. This data is applied // using a 'backdoor' on primitive creation. Thus, the normal mechanism to detect // object changes does not work here. It is necessary to trigger updates here // directly. BroadcastObjectChange used for PagePreview invalidations, // flushViewObjectContacts used to invalidate and flush all visualizations in // edit views.
SdPage* pMasterPage = dynamic_cast< SdPage* >(&TRG_GetMasterPage());
if( bSubContentProcessing || ( pCheckPage->GetPageKind() == PageKind::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 PresObjKind::Footer: return rSettings.mbFooterVisible; case PresObjKind::Header: return rSettings.mbHeaderVisible; case PresObjKind::DateTime: return rSettings.mbDateTimeVisible; case PresObjKind::SlideNumber: return rSettings.mbSlideNumberVisible; default: break;
}
}
}
} // check for placeholders on master elseif( (eKind != PresObjKind::NONE) && pCheckPage->IsMasterPage() && ( pVisualizedPage != pCheckPage ) )
{ // presentation objects on master slide are always invisible if slide is shown. returnfalse;
}
}
}
// i63977, do not print SdrpageObjs from master pages if( ( pObj->GetObjInventor() == SdrInventor::Default ) && ( pObj->GetObjIdentifier() == SdrObjKind::Page ) )
{ if( pObj->getSdrPageFromSdrObject() && pObj->getSdrPageFromSdrObject()->IsMasterPage() ) returnfalse;
}
if( pOldPara )
{ // 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->GetOutlinerParaObject()
&& pTextObj->GetOutlinerParaObject()->IsEffectivelyVertical() != bVertical)
{
::tools::Rectangle aObjectRect = pTextObj->GetSnapRect();
pTextObj->GetOutlinerParaObject()->SetVertical(bVertical);
pTextObj->SetSnapRect(aObjectRect);
}
}
pTextObj->SetTextEditOutliner( nullptr ); // to make stylesheet settings work
pTextObj->NbcSetStyleSheet( GetStyleSheetForPresObj(ePresObjKind), true );
pTextObj->SetEmptyPresObj(true);
bRet = true;
}
}
} return bRet;
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
