/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
 *
 * 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.
 *
 ************************************************************************/

// HACK
#ifdef SVX_LIGHT
#define _IPOBJ_HXX
#endif

#include <sot/clsids.hxx>
#include "svdview.hxx"
#include <string.h>
#ifndef _STRING_H
#define _STRING_H
#endif
#include <bf_so3/ipobj.hxx>

#include "svdetc.hxx"
#include "svdio.hxx"
#include "svdograf.hxx" // fuer SwapInAll()
#include "svdoole2.hxx" // Sonderbehandlung OLE beim SdrExchangeFormat
#include "svditer.hxx"
#include "svdpagv.hxx"
#include "polysc3d.hxx"
#include "fmdpage.hxx"
#include "xoutx.hxx"
#include <bf_tools/string.hxx>

namespace binfilter {

using namespace ::com::sun::star;

/*N*/ DBG_NAME(SdrObjList)

/*N*/ TYPEINIT0(SdrObjList);

/*N*/ SdrObjList::SdrObjList(SdrModel* pNewModel, SdrPage* pNewPage, SdrObjList* pNewUpList):
/*N*/   aList(1024,64,64)
/*N*/ {
/*N*/   DBG_CTOR(SdrObjList,NULL);
/*N*/   pModel=pNewModel;
/*N*/   pPage=pNewPage;
/*N*/   pUpList=pNewUpList;
/*N*/   bObjOrdNumsDirty=FALSE;
/*N*/   bRectsDirty=FALSE;
/*N*/   pOwnerObj=NULL;
/*N*/   eListKind=SDROBJLIST_UNKNOWN;
/*N*/ }

/*?*/ SdrObjList::SdrObjList(const SdrObjList& rSrcList):
/*?*/   aList(1024,64,64)
/*?*/ {
/*?*/   DBG_CTOR(SdrObjList,NULL);
/*?*/   pModel=NULL;
/*?*/   pPage=NULL;
/*?*/   pUpList=NULL;
/*?*/   bObjOrdNumsDirty=FALSE;
/*?*/   bRectsDirty=FALSE;
/*?*/   pOwnerObj=NULL;
/*?*/   eListKind=SDROBJLIST_UNKNOWN;
/*?*/   *this=rSrcList;
/*?*/ }

/*N*/ SdrObjList::~SdrObjList()
/*N*/ {
/*N*/   DBG_DTOR(SdrObjList,NULL);
/*N*/   Clear(); // Containerinhalt loeschen!
/*N*/ }

/*N*/ void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
/*N*/ {
/*N*/   Clear();
/*N*/   bObjOrdNumsDirty=FALSE;
/*N*/   bRectsDirty     =FALSE;
/*N*/   ULONG nCloneErrCnt=0;
/*N*/   ULONG nAnz=rSrcList.GetObjCount();
/*N*/   SdrInsertReason aReason(SDRREASON_COPY);
/*N*/   ULONG no;
/*N*/   for (no=0; no<nAnz; no++) {
/*N*/       SdrObject* pSO=rSrcList.GetObj(no);
/*N*/       SdrObject* pDO=pSO->Clone(pPage,pModel);
/*N*/       if (pDO!=NULL) {
/*N*/           NbcInsertObject(pDO,CONTAINER_APPEND,&aReason);
/*N*/       } else {
/*N*/           nCloneErrCnt++;
/*N*/       }
/*N*/   }
/*N*/   // und nun zu den Konnektoren
/*N*/   // Die neuen Objekte werden auf die der rSrcList abgebildet
/*N*/   // und so die Objektverbindungen hergestellt.
/*N*/   // Aehnliche Implementation an folgenden Stellen:
/*N*/   //    void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
/*N*/   //    SdrModel* SdrExchangeView::GetMarkedObjModel() const
/*N*/   //    bool SdrExchangeView::Paste(const SdrModel& rMod,...)
/*N*/   //    void SdrEditView::CopyMarked()
/*N*/   if (nCloneErrCnt==0) {
/*N*/       for (no=0; no<nAnz; no++) {
/*N*/           const SdrObject* pSrcOb=rSrcList.GetObj(no);
/*N*/           SdrEdgeObj* pSrcEdge=PTR_CAST(SdrEdgeObj,pSrcOb);
/*N*/           if (pSrcEdge!=NULL) {
/*?*/               SdrObject* pSrcNode1=pSrcEdge->GetConnectedNode(TRUE);
/*?*/               SdrObject* pSrcNode2=pSrcEdge->GetConnectedNode(FALSE);
/*?*/               if (pSrcNode1!=NULL && pSrcNode1->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode1=NULL; // Listenuebergreifend
/*?*/               if (pSrcNode2!=NULL && pSrcNode2->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode2=NULL; // ist (noch) nicht
/*?*/               if (pSrcNode1!=NULL || pSrcNode2!=NULL) {
/*?*/                   SdrObject* pEdgeObjTmp=GetObj(no);
/*?*/                   SdrEdgeObj* pDstEdge=PTR_CAST(SdrEdgeObj,pEdgeObjTmp);
/*?*/                   if (pDstEdge!=NULL) {
/*?*/                       if (pSrcNode1!=NULL) {
/*?*/                           ULONG nDstNode1=pSrcNode1->GetOrdNum();
/*?*/                           SdrObject* pDstNode1=GetObj(nDstNode1);
/*?*/                           if (pDstNode1!=NULL) { // Sonst grober Fehler!
/*?*/                               pDstEdge->ConnectToNode(TRUE,pDstNode1);
/*?*/                           } else {
/*?*/                               OSL_FAIL("SdrObjList::operator=(): pDstNode1==NULL!");
/*?*/                           }
/*?*/                       }
/*?*/                       if (pSrcNode2!=NULL) {
/*?*/                           ULONG nDstNode2=pSrcNode2->GetOrdNum();
/*?*/                           SdrObject* pDstNode2=GetObj(nDstNode2);
/*?*/                           if (pDstNode2!=NULL) { // Node war sonst wohl nicht markiert
/*?*/                               pDstEdge->ConnectToNode(FALSE,pDstNode2);
/*?*/                           } else {
/*?*/                               OSL_FAIL("SdrObjList::operator=(): pDstNode2==NULL!");
/*?*/                           }
/*?*/                       }
/*?*/                   } else {
/*?*/                       OSL_FAIL("SdrObjList::operator=(): pDstEdge==NULL!");
/*?*/                   }
/*?*/               }
/*N*/           }
/*N*/       }
/*N*/   } else {
/*N*/ #ifdef DBG_UTIL
/*?*/       ByteString aStr("SdrObjList::operator=(): Fehler beim Clonen ");
/*?*/
/*?*/       if(nCloneErrCnt == 1)
/*?*/       {
/*?*/           aStr += "eines Zeichenobjekts.";
/*?*/       }
/*?*/       else
/*?*/       {
/*?*/           aStr += "von ";
/*?*/           aStr += ByteString::CreateFromInt32( nCloneErrCnt );
/*?*/           aStr += " Zeichenobjekten.";
/*?*/       }
/*?*/
/*?*/       aStr += " Objektverbindungen werden nicht mitkopiert.";
/*?*/
/*?*/       OSL_FAIL(aStr.GetBuffer());
/*?*/ #endif
/*N*/   }
/*N*/ }

/*N*/ void SdrObjList::Clear()
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/
/*N*/   if(pModel!=NULL && nAnz!=0)
/*N*/   {
/*N*/       SdrHint aHint(HINT_OBJLISTCLEAR);
/*N*/       aHint.SetPage(pPage);
/*N*/       aHint.SetObjList(this);
/*N*/       pModel->Broadcast(aHint);
/*N*/   }
/*N*/
/*N*/   for (ULONG no=0; no<nAnz; no++) {
/*N*/       SdrObject* pObj=GetObj(no);
/*N*/       delete pObj;
/*N*/   }
/*N*/   aList.Clear();
/*N*/   if (pModel!=NULL && nAnz!=0)
/*N*/   {
/*N*/       pModel->SetChanged();
/*N*/       SdrHint aHint(HINT_OBJLISTCLEARED);
/*N*/       aHint.SetPage(pPage);
/*N*/       aHint.SetObjList(this);
/*N*/       pModel->Broadcast(aHint);
/*N*/   }
/*N*/ }

/*N*/ SdrPage* SdrObjList::GetPage() const
/*N*/ {
/*N*/   return pPage;
/*N*/ }

/*N*/ void SdrObjList::SetPage(SdrPage* pNewPage)
/*N*/ {
/*N*/   if (pPage!=pNewPage) {
/*N*/       pPage=pNewPage;
/*N*/       ULONG nAnz=GetObjCount();
/*N*/       for (ULONG no=0; no<nAnz; no++) {
/*N*/           SdrObject* pObj=GetObj(no);
/*N*/           pObj->SetPage(pPage);
/*N*/       }
/*N*/   }
/*N*/ }

/*N*/ SdrModel* SdrObjList::GetModel() const
/*N*/ {
/*N*/   return pModel;
/*N*/ }

/*N*/ void SdrObjList::SetModel(SdrModel* pNewModel)
/*N*/ {
/*N*/   if (pModel!=pNewModel) {
/*N*/       pModel=pNewModel;
/*N*/       ULONG nAnz=GetObjCount();
/*N*/       for (ULONG i=0; i<nAnz; i++) {
/*N*/           SdrObject* pObj=GetObj(i);
/*N*/           pObj->SetModel(pModel);
/*N*/       }
/*N*/   }
/*N*/ }

/*N*/ void SdrObjList::RecalcObjOrdNums()
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   for (ULONG no=0; no<nAnz; no++) {
/*N*/       SdrObject* pObj=GetObj(no);
/*N*/       pObj->SetOrdNum(no);
/*N*/   }
/*N*/   bObjOrdNumsDirty=FALSE;
/*N*/ }

/*N*/ void SdrObjList::RecalcRects()
/*N*/ {
/*N*/   aOutRect=Rectangle();
/*N*/   aSnapRect=aOutRect;
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   ULONG i;
/*N*/   for (i=0; i<nAnz; i++) {
/*N*/       SdrObject* pObj=GetObj(i);
/*N*/       if (i==0) {
/*N*/           aOutRect=pObj->GetBoundRect();
/*N*/           aSnapRect=pObj->GetSnapRect();
/*N*/       } else {
/*N*/           aOutRect.Union(pObj->GetBoundRect());
/*N*/           aSnapRect.Union(pObj->GetSnapRect());
/*N*/       }
/*N*/   }
/*N*/ }

/*N*/ void SdrObjList::SetRectsDirty()
/*N*/ {
/*N*/   bRectsDirty=TRUE;
/*N*/   if (pUpList!=NULL) pUpList->SetRectsDirty();
/*N*/ }

/*N*/ void SdrObjList::NbcInsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* /*pReason*/)
/*N*/ {
/*N*/   DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcInsertObject(NULL)");
/*N*/   if (pObj!=NULL) {
/*N*/       DBG_ASSERT(!pObj->IsInserted(),"ZObjekt hat bereits Inserted-Status");
/*N*/       ULONG nAnz=GetObjCount();
/*N*/       if (nPos>nAnz) nPos=nAnz;
/*N*/       aList.Insert(pObj,nPos);
/*N*/       if (nPos<nAnz) bObjOrdNumsDirty=TRUE;
/*N*/       pObj->SetOrdNum(nPos);
/*N*/       pObj->SetObjList(this);
/*N*/       pObj->SetPage(pPage);
/*N*/       if (!bRectsDirty) {
/*N*/           aOutRect.Union(pObj->GetBoundRect());
/*N*/           aSnapRect.Union(pObj->GetSnapRect());
/*N*/       }
/*N*/       pObj->SetInserted(TRUE); // Ruft u.a. den UserCall
/*N*/   }
/*N*/ }

/*N*/ void SdrObjList::InsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* pReason)
/*N*/ {
/*N*/   DBG_ASSERT(pObj!=NULL,"SdrObjList::InsertObject(NULL)");
/*N*/
/*N*/   if(pObj)
/*N*/   {
/*N*/       if(pOwnerObj && !GetObjCount())
/*N*/       {
/*N*/           // damit der graue Rahmen des leeren Gruppenobjekts korrekt weggemalt wird
/*N*/           pOwnerObj->SendRepaintBroadcast();
/*N*/       }
/*N*/
/*N*/       // #69055# if anchor is used, reset it before grouping
/*N*/       if(GetOwnerObj())
/*N*/       {
/*N*/           const Point& rAnchorPos = pObj->GetAnchorPos();
/*N*/           if(rAnchorPos.X() || rAnchorPos.Y())
/*N*/               pObj->NbcSetAnchorPos(Point());
/*N*/       }
/*N*/
/*N*/       // do insert to new group
/*N*/       NbcInsertObject(pObj, nPos, pReason);
/*N*/
/*N*/       // Falls das Objekt in eine Gruppe eingefuegt wird
/*N*/       // und nicht mit seinen Bruedern ueberlappt, muss es
/*N*/       // einen eigenen Redraw bekommen
/*N*/       if(pOwnerObj)
/*N*/       {
/*N*/           pOwnerObj->SendRepaintBroadcast();
/*N*/       }
/*N*/
/*N*/       if(pModel)
/*N*/       {
/*N*/           // Hier muss ein anderer Broadcast her!
/*N*/           // Repaint ab Objekt Nummer ... (Achtung: GroupObj)
/*N*/           if(pObj->GetPage())
/*N*/           {
/*N*/               SdrHint aHint(*pObj);
/*N*/
/*N*/               aHint.SetKind(HINT_OBJINSERTED);
/*N*/               pModel->Broadcast(aHint);
/*N*/           }
/*N*/
/*N*/           pModel->SetChanged();
/*N*/       }
/*N*/   }
/*N*/ }

/*N*/ SdrObject* SdrObjList::RemoveObject(ULONG nObjNum)
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   SdrObject* pObj=(SdrObject*)aList.Remove(nObjNum);
/*N*/   DBG_ASSERT(pObj!=NULL,"Object zum Removen nicht gefunden");
/*N*/   if (pObj!=NULL) {
/*N*/       DBG_ASSERT(pObj->IsInserted(),"ZObjekt hat keinen Inserted-Status");
/*N*/       if (pModel!=NULL) {
/*N*/           // Hier muss ein anderer Broadcast her!
/*N*/           if (pObj->GetPage()!=NULL) {
/*N*/               SdrHint aHint(*pObj);
/*N*/               aHint.SetKind(HINT_OBJREMOVED);
/*N*/               pModel->Broadcast(aHint);
/*N*/           }
/*N*/           pModel->SetChanged();
/*N*/       }
/*N*/       pObj->SetInserted(FALSE); // Ruft u.a. den UserCall
/*N*/       pObj->SetObjList(NULL);
/*N*/       pObj->SetPage(NULL);
/*N*/       if (!bObjOrdNumsDirty) { // Optimierung fuer den Fall, dass das letzte Obj rausgenommen wird
/*N*/           if (nObjNum!=ULONG(nAnz-1)) {
/*N*/               bObjOrdNumsDirty=TRUE;
/*N*/           }
/*N*/       }
/*N*/       SetRectsDirty();
/*N*/       if (pOwnerObj!=NULL && GetObjCount()==0) {
/*N*/           // damit der graue Rahmen des leeren Gruppenobjekts korrekt gemalt wird
/*N*/           pOwnerObj->SendRepaintBroadcast();
/*N*/       }
/*N*/   }
/*N*/   return pObj;
/*N*/ }


/*N*/ SdrObject* SdrObjList::ReplaceObject(SdrObject* pNewObj, ULONG nObjNum)
/*N*/ {
/*N*/   //ULONG nAnz=GetObjCount();
/*N*/   SdrObject* pObj=(SdrObject*)aList.GetObject(nObjNum);
/*N*/   DBG_ASSERT(pObj!=NULL,"SdrObjList::ReplaceObject: Object zum Removen nicht gefunden");
/*N*/   if (pObj!=NULL) {
/*N*/       DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: ZObjekt hat keinen Inserted-Status");
/*N*/       if (pModel!=NULL) {
/*N*/           // Hier muss ein anderer Broadcast her!
/*N*/           if (pObj->GetPage()!=NULL) {
/*N*/               SdrHint aHint(*pObj);
/*N*/               aHint.SetKind(HINT_OBJREMOVED);
/*N*/               pModel->Broadcast(aHint);
/*N*/           }
/*N*/       }
/*N*/       pObj->SetInserted(FALSE);
/*N*/       pObj->SetObjList(NULL);
/*N*/       pObj->SetPage(NULL);
/*N*/       aList.Replace(pNewObj,nObjNum);
/*N*/       pNewObj->SetOrdNum(nObjNum);
/*N*/       pNewObj->SetObjList(this);
/*N*/       pNewObj->SetPage(pPage);
/*N*/       pNewObj->SetInserted(TRUE);
/*N*/       if (pModel!=NULL) {
/*N*/           // Hier muss ein anderer Broadcast her!
/*N*/           if (pNewObj->GetPage()!=NULL) {
/*N*/               SdrHint aHint(*pNewObj);
/*N*/               aHint.SetKind(HINT_OBJINSERTED);
/*N*/               pModel->Broadcast(aHint);
/*N*/           }
/*N*/           pModel->SetChanged();
/*N*/       }
/*N*/       SetRectsDirty();
/*N*/   }
/*N*/   return pObj;
/*N*/ }

/*N*/ SdrObject* SdrObjList::NbcSetObjectOrdNum(ULONG nOldObjNum, ULONG nNewObjNum)
/*N*/ {
/*N*/   SdrObject* pObj=(SdrObject*)aList.GetObject(nOldObjNum);
/*N*/   if (nOldObjNum==nNewObjNum) return pObj;
/*N*/   DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcSetObjectOrdNum: Object nicht gefunden");
/*N*/   if (pObj!=NULL) {
/*N*/       DBG_ASSERT(pObj->IsInserted(),"SdrObjList::NbcSetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
/*N*/       aList.Remove(nOldObjNum);
/*N*/       aList.Insert(pObj,nNewObjNum);
/*N*/       pObj->SetOrdNum(nNewObjNum);
/*N*/       bObjOrdNumsDirty=TRUE;
/*N*/   }
/*N*/   return pObj;
/*N*/ }

/*N*/ SdrObject* SdrObjList::SetObjectOrdNum(ULONG nOldObjNum, ULONG nNewObjNum)
/*N*/ {
/*N*/   SdrObject* pObj=(SdrObject*)aList.GetObject(nOldObjNum);
/*N*/   if (nOldObjNum==nNewObjNum) return pObj;
/*N*/   DBG_ASSERT(pObj!=NULL,"SdrObjList::SetObjectOrdNum: Object nicht gefunden");
/*N*/   if (pObj!=NULL) {
/*N*/       DBG_ASSERT(pObj->IsInserted(),"SdrObjList::SetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
/*N*/       aList.Remove(nOldObjNum);
/*N*/       aList.Insert(pObj,nNewObjNum);
/*N*/       pObj->SetOrdNum(nNewObjNum);
/*N*/       bObjOrdNumsDirty=TRUE;
/*N*/       if (pModel!=NULL) {
/*N*/           // Hier muss ein anderer Broadcast her!
/*N*/           if (pObj->GetPage()!=NULL) pModel->Broadcast(SdrHint(*pObj));
/*N*/           pModel->SetChanged();
/*N*/       }
/*N*/   }
/*N*/   return pObj;
/*N*/ }

/*N*/ const Rectangle& SdrObjList::GetAllObjSnapRect() const
/*N*/ {
/*N*/   if (bRectsDirty) {
/*N*/       ((SdrObjList*)this)->RecalcRects();
/*N*/       ((SdrObjList*)this)->bRectsDirty=FALSE;
/*N*/   }
/*N*/   return aSnapRect;
/*N*/ }

/*N*/ const Rectangle& SdrObjList::GetAllObjBoundRect() const
/*N*/ {
/*N*/   if (bRectsDirty) {
/*N*/       ((SdrObjList*)this)->RecalcRects();
/*N*/       ((SdrObjList*)this)->bRectsDirty=FALSE;
/*N*/   }
/*N*/   return aOutRect;
/*N*/ }

/*N*/ bool SdrObjList::Paint(ExtOutputDevice& rXOut, const SdrPaintInfoRec& rInfoRec, bool bRestoreColors) const
/*N*/ {
/*N*/   BOOL bOk(TRUE);
/*N*/   BOOL bWasNotActive = rInfoRec.bNotActive;
/*N*/   BOOL bIsEnteredGroup(FALSE);
/*N*/   UINT32 nWasDrawMode = rXOut.GetOutDev()->GetDrawMode();
/*N*/
/*N*/   if(!rInfoRec.bOriginalDrawModeSet)
/*N*/   {
/*N*/       // Original-Paintmode retten
/*N*/       ((SdrPaintInfoRec&)rInfoRec).bOriginalDrawModeSet = TRUE;
/*N*/       ((SdrPaintInfoRec&)rInfoRec).nOriginalDrawMode = rXOut.GetOutDev()->GetDrawMode();
/*N*/   }
/*N*/
/*N*/   if((rInfoRec.pPV && rInfoRec.pPV->GetObjList() == this)
/*N*/       || (rInfoRec.nPaintMode & SDRPAINTMODE_MASTERPAGE))
/*N*/   {
/*N*/       bIsEnteredGroup = TRUE;
/*N*/   }
/*N*/
/*N*/   if(bIsEnteredGroup && bWasNotActive)
/*N*/   {
/*N*/       // auf aktive Elemente schalten
/*?*/       ((SdrPaintInfoRec&)rInfoRec).bNotActive = FALSE;
/*N*/   }
/*N*/
/*N*/   if(rInfoRec.pPV && rInfoRec.bNotActive)
/*N*/   {
/*?*/       rXOut.GetOutDev()->SetDrawMode( nWasDrawMode | (
/*?*/           DRAWMODE_GHOSTEDLINE|DRAWMODE_GHOSTEDFILL|DRAWMODE_GHOSTEDTEXT|DRAWMODE_GHOSTEDBITMAP|DRAWMODE_GHOSTEDGRADIENT));
/*N*/   }
/*N*/   else
/*N*/   {
/*N*/       // Darstellung normal
/*N*/       rXOut.GetOutDev()->SetDrawMode(rInfoRec.nOriginalDrawMode);
/*N*/   }
/*N*/
/*N*/   bOk = Paint(rXOut, rInfoRec, bRestoreColors, IMP_PAGEPAINT_NORMAL);
/*N*/
/*N*/   if(bIsEnteredGroup && bWasNotActive)
/*N*/   {
/*?*/       // Zurueck auf Ursprung, Zustand wieder verlassen
/*?*/       ((SdrPaintInfoRec&)rInfoRec).bNotActive = TRUE;
/*N*/   }
/*N*/
/*N*/   // Darstellung restaurieren
/*N*/   rXOut.GetOutDev()->SetDrawMode(nWasDrawMode);
/*N*/
/*N*/   return bOk;
/*N*/ }

/*N*/ bool SdrObjList::Paint(ExtOutputDevice& rXOut, const SdrPaintInfoRec& rInfoRec, bool bRestoreColors, USHORT nImpMode) const
/*N*/ {
/*N*/   bool bOk=TRUE;
/*N*/   bool bBrk=FALSE;
/*N*/   ULONG nObjAnz=GetObjCount();
/*N*/   if (nObjAnz==0) return TRUE;
/*N*/   USHORT nEvent=rInfoRec.nBrkEvent;
/*N*/   const SetOfByte* pVisiLayer=&rInfoRec.aPaintLayer;
/*N*/   bool bPrinter=rInfoRec.bPrinter;
/*N*/   OutputDevice* pOut=rXOut.GetOutDev();
/*N*/   Rectangle aCheckRect(rInfoRec.aCheckRect);
/*N*/   bool bDrawAll=aCheckRect.IsEmpty();
/*N*/   ImpSdrHdcMerk aHDCMerk(*pOut,SDRHDC_SAVEPENANDBRUSHANDFONT,bRestoreColors);
/*N*/   bool bColorsDirty=FALSE;
/*N*/   if (bDrawAll || aCheckRect.IsOver(GetAllObjBoundRect())) {
/*N*/       Application* pAppPtr=NULL;
/*N*/       if (nEvent!=0) pAppPtr=GetpApp();
/*N*/       SetOfByte aPaintLayer(*pVisiLayer);
/*N*/       USHORT nPaintCycles = 1;
/*N*/       SdrLayerID nLayerId = 0;
/*N*/
/*N*/       // #85670# if pModel is NULL, try to get model of list owner
/*N*/       SdrModel *pLocalModel = pModel;
/*N*/       if(!pLocalModel && GetOwnerObj())
/*N*/           pLocalModel = GetOwnerObj()->GetModel();
/*N*/
/*N*/       // #85670# use correct model to get layer ID
/*N*/       if(pLocalModel)
/*N*/       {
/*N*/           const SdrLayerAdmin& rLayerAdmin = pLocalModel->GetLayerAdmin();
/*N*/           nLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName(), FALSE);
/*N*/       }
/*N*/
/*N*/       if( pPage == NULL || ( !pPage->IsMasterPage() && aPaintLayer.IsSet( nLayerId ) ) )
/*N*/       {
/*N*/           // Der ControlLayer soll gezeichnet werden
/*N*/           // Wenn Controls existieren, wird der ControlLayer als letztes gezeichnet
/*N*/           SetOfByte aTestLayerSet = aPaintLayer;
/*N*/           aTestLayerSet.Clear(nLayerId);
/*N*/
/*N*/           if (!aTestLayerSet.IsEmpty())
/*N*/           {
/*N*/               // Es soll nicht nur der ControlLayer gezeichnet werden
/*N*/               ULONG nObjNum=0;
/*N*/               while (nObjNum<nObjAnz && nPaintCycles < 2)
/*N*/               {
/*N*/                   if (GetObj(nObjNum)->GetLayer() == nLayerId)
/*N*/                   {
/*N*/                       // Objekt auf ControlLayer gefunden
/*?*/                       // Der ControlLayer wird ersteinmal unsichtbar geschaltet
/*?*/                       nPaintCycles = 2;
/*?*/                       aPaintLayer.Clear(nLayerId);
/*N*/                   }
/*N*/
/*N*/                   nObjNum++;
/*N*/               }
/*N*/           }
/*N*/       }
/*N*/
/*N*/       for (USHORT nCycle = 1; nCycle <= nPaintCycles; nCycle++)
/*N*/       {
/*N*/           USHORT      nPaintImpMode = nImpMode;
/*N*/           bool    bNormal = ( nPaintImpMode == IMP_PAGEPAINT_NORMAL );
/*N*/           bool    bCachePrepare = ( nPaintImpMode == IMP_PAGEPAINT_PREPARE_CACHE );
/*N*/           bool    bBGCachePrepare = ( nPaintImpMode == IMP_PAGEPAINT_PREPARE_BG_CACHE );
/*N*/           bool    bCachePaint = ( nPaintImpMode == IMP_PAGEPAINT_PAINT_CACHE );
/*N*/           bool    bBGCachePaint = ( nPaintImpMode == IMP_PAGEPAINT_PAINT_BG_CACHE );
/*N*/           bool    bPaintFlag = ( bNormal || bCachePrepare || bBGCachePrepare );
/*N*/
/*N*/           if( nCycle == 2 )
/*N*/           {
/*N*/               // Im zweiten Durchgang nur den ControlLayer zeichnen
/*?*/               aPaintLayer.ClearAll();
/*?*/               aPaintLayer.Set(nLayerId);
/*N*/           }
/*N*/
/*N*/           ULONG nObjNum = 0UL;
/*N*/
/*N*/           while( ( nObjNum < nObjAnz ) && !bBrk )
/*N*/           {
/*N*/               SdrObject* pObj = GetObj( nObjNum );
/*N*/
/*N*/               if( nObjNum == 0 && eListKind == SDROBJLIST_MASTERPAGE &&
/*N*/                   pPage && pPage->IsMasterPage() && rInfoRec.pPV )
/*N*/               {
/*?*/                   // painting pages background obj instead of masterpages background obj
/*?*/                   SdrPage* pPg = rInfoRec.pPV->GetPage();
/*?*/                   SdrObject* pBackgroundObj = pPg ? pPg->GetBackgroundObj() : NULL;
/*?*/                   if( pBackgroundObj )
/*?*/                   {
/*?*/                       if( rXOut.GetOutDev()->GetDrawMode() == DRAWMODE_DEFAULT )
/*?*/                       {
/*?*/                           pObj = pBackgroundObj;
/*?*/                           Point aPos ( pPage->GetLftBorder(), pPage->GetUppBorder() );
/*?*/                           Size aSize ( pPage->GetSize() );
/*?*/                           aSize.Width()  -= pPage->GetLftBorder() + pPage->GetRgtBorder() - 1;
/*?*/                           aSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder() - 1;
/*?*/                           Rectangle aLogicRect( aPos, aSize );
/*?*/
/*?*/                           if( pBackgroundObj->GetLogicRect() != aLogicRect )
/*?*/                           {
/*?*/                               pBackgroundObj->SetLogicRect( aLogicRect );
/*?*/                               pBackgroundObj->RecalcBoundRect();
/*?*/                           }
/*?*/                       }
/*?*/                       else
/*?*/                           pObj = NULL;
/*?*/
/*?*/                   }
/*N*/               }

/*N*/               if( pObj && ( bDrawAll || aCheckRect.IsOver( pObj->GetBoundRect() ) ) )
/*N*/               {
/*N*/                   SdrObjList* pSubList = pObj->GetSubList();
/*N*/
/*N*/                   // Gruppenobjekte beruecksichtigen sichtbare Layer selbst (Ansonsten nur Painten, wenn Layer sichtbar)
/*N*/                   if( pSubList!=NULL || ((!bPrinter || pObj->IsPrintable()) && aPaintLayer.IsSet(pObj->GetLayer())) )
/*N*/                   {
/*N*/                       // #108937#
/*N*/                       // IsMasterCachable() does not visit groups automatically. Since
/*N*/                       // this mechanism should be changed to set information at the page
/*N*/                       // (counter?) later, i will fix that with a SdrObjListIter here.
/*N*/                       sal_Bool bHierarchyIsMasterPageCachable(pObj->IsMasterCachable());
/*N*/
/*N*/                       if(bHierarchyIsMasterPageCachable && pObj->IsGroupObject())
/*N*/                       {
/*N*/                           SdrObjListIter aIter(*pObj, IM_DEEPNOGROUPS);
/*N*/
/*N*/                           while(bHierarchyIsMasterPageCachable && aIter.IsMore())
/*N*/                           {
/*N*/                               SdrObject* pNestedObj = aIter.Next();
/*N*/
/*N*/                               if(!pNestedObj->IsMasterCachable())
/*N*/                               {
/*N*/                                   bHierarchyIsMasterPageCachable = sal_False;
/*N*/                               }
/*N*/                           }
/*N*/                       }
/*N*/
/*N*/                       if( !bNormal && !bHierarchyIsMasterPageCachable)
/*N*/                       {
/*?*/                           if( bCachePrepare || bBGCachePrepare )
/*?*/                               bBrk = TRUE, bPaintFlag = FALSE;
/*?*/                           else if( bCachePaint || bBGCachePaint )
/*?*/                           {
/*?*/                               bPaintFlag = bNormal = TRUE;
/*N*/                           }
/*N*/                       }
/*N*/
/*N*/                       if( bPaintFlag )
/*N*/                       {
/*N*/                           if( !pObj->IsNeedColorRestore() )
/*N*/                               bColorsDirty=TRUE; // andere aendern die Farben
/*N*/
/*N*/                           if( rInfoRec.pPaintProc!=NULL )
/*N*/                           {
/*?*/                               SdrPaintProcRec aRec(pObj,rXOut,rInfoRec);
/*?*/                               Link aLink(*rInfoRec.pPaintProc);
/*?*/                               aLink.Call(&aRec); // sollte mal 'nen ReturnCode liefern
/*N*/                           }
/*N*/                           else
/*N*/                           {
/*N*/                               bOk=pObj->Paint(rXOut,rInfoRec);
/*N*/                           }
/*N*/
/*N*/                           // nach dem ersten Objekt bei reinem Hintergrundcache
/*N*/                           // sollen die folgenden Objekte natuerlich nicht gezeichnet werden
/*N*/                           if( bBGCachePrepare )
/*N*/                               bPaintFlag = FALSE;
/*N*/                       }
/*N*/                       else if( bBGCachePaint )
/*N*/                           bPaintFlag = TRUE;
/*N*/                   }
/*N*/
/*N*/                   if( bOk && nEvent != 0 )
/*?*/                       bOk = !pAppPtr->AnyInput( nEvent );
/*N*/
/*N*/                   if( !bOk )
/*N*/                       bBrk = TRUE;
/*N*/               }
/*N*/               nObjNum++;
/*N*/           }
/*N*/       }
/*N*/   }
/*N*/
/*N*/   if (bColorsDirty && bRestoreColors)
/*N*/       aHDCMerk.Restore(*pOut);
/*N*/
/*N*/   return bOk;
/*N*/ }



/*N*/ void SdrObjList::ReformatAllTextObjects()
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   ULONG nNum=0;
/*N*/
/*N*/   Printer* pPrinter = NULL;
/*N*/
/*N*/   if (pModel)
/*N*/   {
/*N*/       if (pModel->GetRefDevice() && pModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER)
/*N*/       {
/*N*/           // Kein RefDevice oder RefDevice kein Printer
/*N*/           pPrinter = (Printer*) pModel->GetRefDevice();
/*N*/       }
/*N*/   }
/*N*/
/*N*/   while (nNum<nAnz)
/*N*/   {
/*N*/       SdrObject* pObj = GetObj(nNum);
/*N*/
/*N*/ #ifndef SVX_LIGHT
/*N*/       if (pPrinter &&
/*N*/           pObj->GetObjInventor() == SdrInventor &&
/*N*/           pObj->GetObjIdentifier() == OBJ_OLE2  &&
/*N*/           !( (SdrOle2Obj*) pObj )->IsEmpty() )
/*N*/       {
/*?*/           const SvInPlaceObjectRef& xObjRef = ((SdrOle2Obj*) pObj)->GetObjRef();
/*?*/
/*?*/           if( xObjRef.Is() && ( xObjRef->GetMiscStatus() & SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE ) )
/*?*/               xObjRef->OnDocumentPrinterChanged(pPrinter);
/*N*/       }
/*N*/ #endif
/*N*/
/*N*/       pObj->ReformatText();
/*N*/       nAnz=GetObjCount();             // ReformatText may delete an object
/*N*/       nNum++;
/*N*/   }
/*N*/ }

/** steps over all available objects and reformats all
    edge objects that are connected to other objects so that
    they may reposition itselfs.
    #103122#
*/
/*N*/ void SdrObjList::ReformatAllEdgeObjects()
/*N*/ {
/*N*/   const sal_uInt32 nCount=GetObjCount();
/*N*/   sal_uInt32 nObj;
/*N*/
/*N*/   for( nObj = 0; nObj < nCount; nObj++ )
/*N*/   {
/*N*/       SdrObject* pObj = GetObj(nObj);
/*N*/       if( pObj->ISA(SdrEdgeObj) )
/*N*/           static_cast<SdrEdgeObj*>(pObj)->Reformat();
/*N*/   }
/*N*/ }



/*N*/ void SdrObjList::RestartAllAnimations(SdrPageView* pPageView) const
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   ULONG nNum=0;
/*N*/   while (nNum<nAnz) {
/*N*/       GetObj(nNum)->RestartAnimation(pPageView);
/*N*/       nNum++;
/*N*/   }
/*N*/ }

/*N*/ ULONG SdrObjList::CountAllObjects() const
/*N*/ {
/*N*/   ULONG nCnt=GetObjCount();
/*N*/   ULONG nAnz=nCnt;
/*N*/   for (USHORT nNum=0; nNum<nAnz; nNum++) {
/*N*/       SdrObjList* pSubOL=GetObj(nNum)->GetSubList();
/*N*/       if (pSubOL!=NULL) {
/*N*/           nCnt+=pSubOL->CountAllObjects();
/*N*/       }
/*N*/   }
/*N*/   return nCnt;
/*N*/ }

/*N*/ void SdrObjList::Load(SvStream& rIn, SdrPage& rPage)
/*N*/ {
/*N*/   Clear();
/*N*/
/*N*/   if (rIn.GetError()!=0)
/*N*/       return;
/*N*/
/*N*/   SdrInsertReason aReason(SDRREASON_STREAMING);
/*N*/   bool        bEnde=FALSE;
/*N*/
/*N*/   while( rIn.GetError()==0 && !rIn.IsEof() && !bEnde )
/*N*/   {
/*N*/       SdrObjIOHeaderLookAhead aHead(rIn,STREAM_READ);
/*N*/
/*N*/       if (!aHead.IsEnde())
/*N*/       {
/*N*/           SdrObject* pObj=SdrObjFactory::MakeNewObject(aHead.nInventor,aHead.nIdentifier,&rPage);
/*N*/
/*N*/           if( pObj!=NULL )
/*N*/           {
/*N*/               rIn >> *pObj;
/*N*/
/*N*/ #ifndef SVX_LIGHT
/*N*/               if( ( pObj->GetObjIdentifier() == OBJ_OLE2 ) && ( pObj->GetObjInventor() == SdrInventor ) )
/*N*/               {
/*N*/                   // convert StarImage OLE objects to normal graphic objects
/*N*/                   SdrOle2Obj* pOLEObj = (SdrOle2Obj*) pObj;
/*N*/                   BOOL        bImageOLE = FALSE;
/*N*/
/*N*/                   if( pOLEObj->GetProgName() == String( RTL_CONSTASCII_USTRINGPARAM( "StarImage" ) ) )
/*N*/                       bImageOLE = TRUE;
/*N*/                   else if( pModel->GetPersist() )
/*N*/                   {
/*N*/                       SvInfoObjectRef     xInfo( pModel->GetPersist()->Find( pOLEObj->GetPersistName() ) );
/*N*/                       const SvGlobalName  aSim30Name( BF_SO3_SIM_CLASSID_30 );
/*N*/                       const SvGlobalName  aSim40Name( BF_SO3_SIM_CLASSID_40 );
/*N*/                       const SvGlobalName  aSim50Name( BF_SO3_SIM_CLASSID_50 );
/*N*/
/*N*/                       if( xInfo.Is() &&
/*N*/                           ( xInfo->GetClassName() == aSim30Name ||
/*N*/                             xInfo->GetClassName() == aSim40Name ||
/*N*/                             xInfo->GetClassName() == aSim50Name ) )
/*N*/                       {
/*N*/                           bImageOLE = TRUE;
/*N*/                       }
/*N*/                   }
/*N*/
/*N*/                   if( bImageOLE && pOLEObj->GetPersistName().Len() )
/*N*/                   {
/*?*/                       SotStorage*     pModelStorage = pModel->GetModelStorage();
/*?*/                       const String    aSimStorageName( pOLEObj->GetPersistName() );
/*?*/
/*?*/                       if( pModelStorage && pModelStorage->IsStorage( aSimStorageName ) )
/*?*/                       {
/*?*/                           SotStorageRef xSimStorage( pModelStorage->OpenSotStorage( aSimStorageName ) );
/*?*/
/*?*/                           if( xSimStorage.Is() )
/*?*/                           {
/*?*/                               String aStmName( RTL_CONSTASCII_USTRINGPARAM( "StarImageDocument" ) );
/*?*/
/*?*/                               if( xSimStorage->IsStream( aStmName ) ||
/*?*/                                   xSimStorage->IsStream( aStmName = String( RTL_CONSTASCII_USTRINGPARAM( "StarImageDocument 4.0" ) ) ) )
/*?*/                               {
/*?*/                                   SotStorageStreamRef xSimStm( xSimStorage->OpenSotStream( aStmName ) );
/*?*/
/*?*/                                   if( xSimStm.Is() && !xSimStm->GetError() )
/*?*/                                   {
/*?*/                                       Graphic aGraphic;
/*?*/
/*?*/                                       xSimStm->SetBufferSize( 32768 );
/*?*/                                       xSimStm->SetCryptMaskKey( xSimStorage->GetKey() );
/*?*/                                       *xSimStm >> aGraphic;
/*?*/                                       xSimStm->SetBufferSize( 0 );
/*?*/
/*?*/                                       SdrGrafObj* pNewObj = (SdrGrafObj*) SdrObjFactory::MakeNewObject( SdrInventor, OBJ_GRAF, &rPage );
/*?*/
/*?*/                                       if( pNewObj )
/*?*/                                       {
/*?*/                                           pNewObj->SetGraphic( aGraphic );
/*?*/                                           pNewObj->SetLogicRect( pObj->GetLogicRect() );
/*?*/                                           delete pObj;
/*?*/                                           pObj = pNewObj;
/*?*/                                       }
/*?*/                                   }
/*?*/                               }
/*?*/                           }
/*?*/                       }
/*N*/                   }
/*N*/               }
#endif // SVX_LIGHT

/*N*/               InsertObject(pObj,CONTAINER_APPEND,&aReason);
/*N*/           }
/*N*/           else
/*N*/           { // aha, das wil keiner. Also ueberlesen.
/*N*/ #ifdef SVX_LIGHT
/*N*/               if( aHead.nInventor != FmFormInventor )
/*N*/               {
/*N*/ #endif
/*N*/
/*N*/ #ifdef DBG_UTIL
/*?*/               ByteString aStr("SdrObjList::Load(): Zeichenobjekt kann von der Factory nicht erzeugt werden:\n");
/*?*/               UINT32 nPos(GetObjCount());
/*?*/
/*?*/               aStr += "Listenposition: ";
/*?*/               aStr += ByteString::CreateFromInt32( nPos );
/*?*/               aStr += "\n";
/*?*/               aStr += "Inventor: ";
/*?*/                 sal_Int32 nInv = SWAPLONG( aHead.nInventor );
/*?*/                 aStr += ByteString::CreateFromInt32( nInv );
/*?*/               aStr += ", Identifier: ";
/*?*/               aStr += ByteString::CreateFromInt32( aHead.nIdentifier );
/*?*/               aStr += "\n";
/*?*/               aStr += "FilePos: ";
/*?*/               aStr += ByteString::CreateFromInt32( aHead.GetFilePos() );
/*?*/               aStr += ", BlockSize: ";
/*?*/               aStr += ByteString::CreateFromInt32( aHead.GetBlockSize() );
/*?*/
/*?*/               OSL_FAIL(aStr.GetBuffer());
/*?*/ #endif
/*?*/
/*?*/ #ifdef SVX_LIGHT
/*?*/               }
/*?*/ #endif
/*?*/               aHead.SkipRecord();
/*?*/           }
/*N*/       }
/*N*/       else
/*N*/       {
/*N*/           bEnde=TRUE;
/*N*/           aHead.SkipRecord(); // die Endemarke weglesen
/*N*/       }
/*N*/
/*N*/       SdrModel* pMd=pModel;
/*N*/
/*N*/       if (pMd==NULL)
/*N*/           pMd=rPage.GetModel();
/*N*/
/*N*/       if (pMd!=NULL)
/*N*/           pMd->DoProgress(rIn.Tell());
/*N*/   }
/*N*/ }

/*N*/ void SdrObjList::AfterRead()
/*N*/ {
/*N*/   ULONG nAnz=GetObjCount();
/*N*/   for (ULONG i=0; i<nAnz; i++) {
/*N*/       GetObj(i)->AfterRead();
/*N*/   }
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ SvStream& operator<<(SvStream& rOut, const SdrMasterPageDescriptor& rMDP)
/*N*/ {
/*N*/   SdrIOHeader aHead(rOut,STREAM_WRITE,SdrIOMPgDID);
/*N*/   rOut<<rMDP.nPgNum;
/*N*/   rOut<<rMDP.aVisLayers;
/*N*/   return rOut;
/*N*/ }

/*N*/ SvStream& operator>>(SvStream& rIn, SdrMasterPageDescriptor& rMDP)
/*N*/ {
/*N*/   if (rIn.GetError()!=0) return rIn;
/*N*/   SdrIOHeader aHead(rIn,STREAM_READ);
/*N*/   rIn>>rMDP.nPgNum;
/*N*/   rIn>>rMDP.aVisLayers;
/*N*/   return rIn;
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ void SdrMasterPageDescriptorList::Clear()
/*N*/ {
/*N*/   USHORT nAnz=GetCount();
/*N*/   for (USHORT i=0; i<nAnz; i++) {
/*N*/       delete GetObject(i);
/*N*/   }
/*N*/   aList.Clear();
/*N*/ }


/*N*/ SvStream& operator<<(SvStream& rOut, const SdrMasterPageDescriptorList& rMPDL)
/*N*/ {
/*N*/   SdrIOHeader aHead(rOut,STREAM_WRITE,SdrIOMPDLID);
/*N*/   USHORT nAnz=rMPDL.GetCount();
/*N*/   rOut<<nAnz;
/*N*/   for (USHORT i=0; i<nAnz; i++) {
/*N*/       rOut<<rMPDL[i];
/*N*/   }
/*N*/   return rOut;
/*N*/ }

/*N*/ SvStream& operator>>(SvStream& rIn, SdrMasterPageDescriptorList& rMPDL)
/*N*/ {
/*N*/   if (rIn.GetError()!=0) return rIn;
/*N*/   SdrIOHeader aHead(rIn,STREAM_READ);
/*N*/   rMPDL.Clear();
/*N*/   USHORT nAnz;
/*N*/   rIn>>nAnz;
/*N*/   for (USHORT i=0; i<nAnz; i++) {
/*N*/       SdrMasterPageDescriptor* pMPD=new SdrMasterPageDescriptor;
/*N*/       rIn>>*pMPD;
/*N*/       rMPDL.aList.Insert(pMPD,CONTAINER_APPEND);
/*N*/   }
/*N*/   return rIn;
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ TYPEINIT1(SdrPage,SdrObjList);

/*N*/ SdrPage::SdrPage(SdrModel& rNewModel, bool bMasterPage):
/*N*/   SdrObjList(&rNewModel,this),
/*N*/   pBackgroundObj( NULL )
/*N*/ {
/*N*/   pLayerAdmin=new SdrLayerAdmin(&rNewModel.GetLayerAdmin());
/*N*/   bMaster=bMasterPage;
/*N*/   bInserted=FALSE;
/*N*/   aPrefVisiLayers.SetAll();
/*N*/   nWdt=10;
/*N*/   nHgt=10;
/*N*/   nBordLft=0;
/*N*/   nBordUpp=0;
/*N*/   nBordRgt=0;
/*N*/   nBordLwr=0;
/*N*/   nPageNum=0;
/*N*/   eListKind=bMasterPage ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
/*N*/   bSwappingLocked=FALSE;
/*N*/   bObjectsNotPersistent=FALSE;
/*N*/ }

/*?*/ SdrPage::SdrPage(const SdrPage& rSrcPage):
/*?*/   SdrObjList(rSrcPage.pModel,this),
/*?*/   pBackgroundObj( NULL )
/*?*/ {
/*?*/   pLayerAdmin=new SdrLayerAdmin(rSrcPage.pModel->GetLayerAdmin());
/*?*/   *this=rSrcPage;
/*?*/   eListKind=bMaster ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
/*?*/ }

/*N*/ SdrPage::~SdrPage()
/*N*/ {
/*N*/   delete pBackgroundObj;
/*N*/   delete pLayerAdmin;
/*N*/ }

/*N*/ void SdrPage::SetSize(const Size& aSiz)
/*N*/ {
/*N*/   nWdt=aSiz.Width();
/*N*/   nHgt=aSiz.Height();
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ Size SdrPage::GetSize() const
/*N*/ {
/*N*/   return Size(nWdt,nHgt);
/*N*/ }

/*N*/ INT32 SdrPage::GetWdt() const
/*N*/ {
/*N*/   return nWdt;
/*N*/ }

/*N*/ INT32 SdrPage::GetHgt() const
/*N*/ {
/*N*/   return nHgt;
/*N*/ }

/*N*/ void  SdrPage::SetBorder(INT32 nLft, INT32 nUpp, INT32 nRgt, INT32 nLwr)
/*N*/ {
/*N*/   nBordLft=nLft;
/*N*/   nBordUpp=nUpp;
/*N*/   nBordRgt=nRgt;
/*N*/   nBordLwr=nLwr;
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ void  SdrPage::SetLftBorder(INT32 nBorder)
/*N*/ {
/*N*/   nBordLft=nBorder;
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ void  SdrPage::SetUppBorder(INT32 nBorder)
/*N*/ {
/*N*/   nBordUpp=nBorder;
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ void  SdrPage::SetRgtBorder(INT32 nBorder)
/*N*/ {
/*N*/   nBordRgt=nBorder;
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ void  SdrPage::SetLwrBorder(INT32 nBorder)
/*N*/ {
/*N*/   nBordLwr=nBorder;
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

/*N*/ INT32 SdrPage::GetLftBorder() const
/*N*/ {
/*N*/   return nBordLft;
/*N*/ }

/*N*/ INT32 SdrPage::GetUppBorder() const
/*N*/ {
/*N*/   return nBordUpp;
/*N*/ }

/*N*/ INT32 SdrPage::GetRgtBorder() const
/*N*/ {
/*N*/   return nBordRgt;
/*N*/ }

/*N*/ INT32 SdrPage::GetLwrBorder() const
/*N*/ {
/*N*/   return nBordLwr;
/*N*/ }

/*N*/ void SdrPage::SetModel(SdrModel* pNewModel)
/*N*/ {
/*N*/   SdrModel* pOldModel=pModel;
/*N*/   SdrObjList::SetModel(pNewModel);
/*N*/   if (pNewModel!=pOldModel)
/*N*/   {
/*?*/       if (pNewModel!=NULL) {
/*?*/           pLayerAdmin->SetParent(&pNewModel->GetLayerAdmin());
/*?*/       } else {
/*?*/           pLayerAdmin->SetParent(NULL);
/*?*/       }
/*?*/       pLayerAdmin->SetModel(pNewModel);
/*?*/
/*?*/       if( pBackgroundObj )
/*?*/           pBackgroundObj->SetModel( pNewModel );
/*N*/   }
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ USHORT SdrPage::GetPageNum() const
/*N*/ {
/*N*/   if (!bInserted) return 0;
/*N*/   if (bMaster) {
/*N*/       if (pModel && pModel->IsMPgNumsDirty())
/*N*/           ((SdrModel*)pModel)->RecalcPageNums(TRUE);
/*N*/   } else {
/*N*/       if (pModel && pModel->IsPagNumsDirty())
/*N*/           ((SdrModel*)pModel)->RecalcPageNums(FALSE);
/*N*/   }
/*N*/   return nPageNum;
/*N*/ }

/*N*/ void SdrPage::SetChanged()
/*N*/ {
/*N*/   if( pModel )
/*N*/       pModel->SetChanged();
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ void SdrPage::SendRepaintBroadcast() const
/*N*/ {
/*N*/   if (bInserted && pModel!=NULL) pModel->Broadcast(SdrHint(*this));
/*N*/ }


/*N*/ void SdrPage::InsertMasterPage(USHORT nPgNum, USHORT nPos)
/*N*/ {
/*N*/   aMasters.Insert(nPgNum,nPos);
/*N*/   SetChanged();
/*N*/   SendRepaintBroadcast();
/*N*/ }

/*?*/ void SdrPage::InsertMasterPage(const SdrMasterPageDescriptor& rMPD, USHORT nPos)
/*?*/ {
/*?*/   aMasters.Insert(rMPD,nPos);
/*?*/   SetChanged();
/*?*/   SendRepaintBroadcast();
/*?*/ }

/*N*/ void SdrPage::RemoveMasterPage(USHORT nPos)
/*N*/ {
/*N*/   if (nPos<aMasters.GetCount()) {
/*N*/       aMasters.Remove(nPos);
/*N*/       SetChanged();
/*N*/       SendRepaintBroadcast();
/*N*/   }
/*N*/ }

/*N*/ void SdrPage::MoveMasterPage(USHORT nPos, USHORT nNewPos)
/*N*/ {
/*N*/   if (nPos<aMasters.GetCount()) {
/*N*/       aMasters.Move(nPos,nNewPos);
/*N*/       SendRepaintBroadcast();
/*N*/   }
/*N*/ }

/*?*/ SdrPage* SdrPage::GetMasterPage(USHORT nPos) const
/*?*/ {
/*?*/   USHORT nPgNum=GetMasterPageNum(nPos);
/*?*/   SdrPage* pPg=NULL;
/*?*/   if( pModel )
/*?*/       pPg = pModel->GetMasterPage(nPgNum);
/*?*/   return pPg;
/*?*/ }


/*N*/ void SdrPage::SetMasterPageVisibleLayers(const SetOfByte& rVL, USHORT nPos)
/*N*/ {
/*N*/   aMasters[nPos].SetVisibleLayers(rVL);
/*N*/   SendRepaintBroadcast();
/*N*/ }



/*N*/ void SdrPage::ImpMasterPageRemoved(USHORT nMasterPageNum)
/*N*/ {
/*N*/   USHORT nMasterAnz=GetMasterPageCount();
/*N*/   for (USHORT nm=nMasterAnz; nm>0;) {
/*N*/       nm--;
/*N*/       USHORT nNum=aMasters[nm].GetPageNum();
/*N*/       if (nNum==nMasterPageNum) { RemoveMasterPage(nm); SendRepaintBroadcast(); }
/*N*/       if (nNum>nMasterPageNum) {
/*N*/           // Hintere anpassen wegen Verschiebung durch entfernen
/*?*/           aMasters[nm].SetPageNum(USHORT(nNum-1));
/*N*/       }
/*N*/   }
/*N*/ }


/*N*/ void SdrPage::ImpMasterPageMoved(USHORT nMasterPageNum, USHORT nNewMasterPageNum)
/*N*/ {
/*N*/   USHORT nMasterAnz=GetMasterPageCount();
/*N*/   for (USHORT nm=nMasterAnz; nm>0;) {
/*N*/       nm--;
/*N*/       USHORT nNum=aMasters[nm].GetPageNum();
/*N*/       if (nNum==nMasterPageNum) {
/*N*/           aMasters[nm].SetPageNum(nNewMasterPageNum);
/*N*/       } else {
/*N*/           // Hintere anpassen wegen Verschiebung durch entfernen und einfuegen
/*N*/           USHORT nNeuNum=nNum;
/*N*/           if (nNeuNum>nMasterPageNum) nNeuNum--;
/*N*/           if (nNeuNum>=nNewMasterPageNum) nNeuNum++;
/*N*/           aMasters[nm].SetPageNum(nNeuNum);
/*N*/       }
/*N*/   }
/*N*/ }

////////////////////////////////////////////////////////////////////////////////////////////////////

/*N*/ void SdrPage::ReadData(const SdrIOHeader& rHead, SvStream& rIn)
/*N*/ {
/*N*/   if (rIn.GetError()!=0) return;
/*N*/   SdrDownCompat aCompat(rIn,STREAM_READ); // Fuer Abwaertskompatibilitaet (Lesen neuer Daten mit altem Code)
/*N*/ #ifdef DBG_UTIL
/*N*/   aCompat.SetID("SdrPage");
/*N*/ #endif
/*N*/
/*N*/   if (rHead.GetVersion()>=11) {
/*N*/       // damit ich meine eigenen SubRecords erkenne (ab V11)
/*N*/       char cMagic[4];
/*N*/       if (rIn.Read(cMagic,4)!=4 || memcmp(cMagic,SdrIOJoeMagic,4)!=0) {
/*?*/           rIn.SetError(SVSTREAM_FILEFORMAT_ERROR);
/*?*/           return;
/*N*/       }
/*N*/   }
/*N*/
/*N*/   { // MiscellaneousData ab V11 eingepackt
/*N*/       SdrDownCompat* pPageMiscCompat=NULL;
/*N*/       if (rHead.GetVersion()>=11) {
/*N*/           pPageMiscCompat=new SdrDownCompat(rIn,STREAM_READ);
/*N*/ #ifdef DBG_UTIL
/*N*/           pPageMiscCompat->SetID("SdrPage(Miscellaneous)");
/*N*/ #endif
/*N*/       }
/*N*/       rIn>>nWdt;
/*N*/       rIn>>nHgt;
/*N*/       rIn>>nBordLft;
/*N*/       rIn>>nBordUpp;
/*N*/       rIn>>nBordRgt;
/*N*/       rIn>>nBordLwr;
/*N*/       USHORT n;
/*N*/       rIn>>n; //aName;
/*N*/       if (pPageMiscCompat!=NULL) {
/*N*/           delete pPageMiscCompat;
/*N*/       }
/*N*/   }
/*N*/
/*N*/   bool bEnde=FALSE;
/*N*/   while (rIn.GetError()==0 && !rIn.IsEof() && !bEnde) {
/*N*/       SdrIOHeaderLookAhead aHead(rIn);   // Layerdefinitionen lesen
/*N*/       if (aHead.IsID(SdrIOLayrID)) {
/*?*/           SdrLayer* pLay=new SdrLayer;       // Layerdefinition lesen
/*?*/           rIn>>*pLay;
/*?*/           pLayerAdmin->InsertLayer(pLay);
/*N*/       } else
/*N*/       if (aHead.IsID(SdrIOLSetID)) {
/*?*/           SdrLayerSet* pSet=new SdrLayerSet; // Layersetdefinition lesen
/*?*/           rIn>>*pSet;
/*?*/           pLayerAdmin->InsertLayerSet(pSet);
/*N*/       } else
/*N*/       // Fuer den Fall der Faelle kann hier ww. MPgDscr oder MPgDscrList stehen
/*N*/       if (aHead.IsID(SdrIOMPgDID)) { // Masterpagedescriptor
/*?*/           SdrMasterPageDescriptor aDscr;
/*?*/           rIn>>aDscr;
/*?*/           aMasters.Insert(aDscr);
/*N*/       } else
/*N*/       if (aHead.IsID(SdrIOMPDLID)) { // MasterpagedescriptorList
/*N*/           SdrMasterPageDescriptorList aDscrList;
/*N*/           rIn>>aDscrList;
/*N*/           USHORT nAnz=aDscrList.GetCount();
/*N*/           for (USHORT nNum=0; nNum<nAnz; nNum++) {
/*N*/               aMasters.Insert(aDscrList[nNum]);
/*N*/           }
/*N*/       } else bEnde=TRUE;
/*N*/   }
/*N*/
/*N*/   if (rHead.GetVersion()>=1) {
/*N*/   } else {
/*?*/       USHORT nMaAnz=0,i;
/*?*/       rIn>>nMaAnz;
/*?*/       for (i=0; i<nMaAnz; i++) {
/*?*/           USHORT nMaPgNum;
/*?*/           rIn>>nMaPgNum;
/*?*/           InsertMasterPage(nMaPgNum);
/*N*/       }
/*N*/   }
/*N*/   SdrObjList::Load(rIn,*this);  // Liste der Objekte lesen
/*N*/
/*N*/   if ( rHead.GetVersion() >= 16 )
/*N*/   {
/*N*/       BOOL bBackgroundObj = FALSE;
/*N*/       rIn >> bBackgroundObj;
/*N*/       if( bBackgroundObj )
/*N*/       {
/*N*/           SdrObjIOHeaderLookAhead aHead( rIn,STREAM_READ );
/*N*/           if ( !aHead.IsEnde() )
/*N*/           {
/*N*/               pBackgroundObj = SdrObjFactory::MakeNewObject( aHead.nInventor, aHead.nIdentifier, this );
/*N*/               if ( bBackgroundObj )
/*N*/                   rIn >> *pBackgroundObj;
/*N*/           }
/*N*/           else
/*?*/               aHead.SkipRecord(); // skip end mark
/*N*/       }
/*N*/   }
/*N*/
    // #88340#
/*N*/   if(!aMasters.GetCount() && !IsMasterPage())
/*N*/   {
/*N*/       if(pModel && pModel->GetMasterPageCount() > 2)
/*N*/       {
/*N*/           // This is not allowed. Create a dummy entry
/*N*/           // to compensate this error.
/*?*/           SdrMasterPageDescriptor aDscr(1/*PageMaster*/);
/*?*/           aMasters.Insert(aDscr);
/*N*/       }
/*N*/       else
/*N*/       {
/*N*/           SdrMasterPageDescriptor aDscr(0);
/*N*/           aMasters.Insert(aDscr);
/*N*/       }
/*N*/   }
/*N*/ }

/*N*/ SvStream& operator>>(SvStream& rIn, SdrPage& rPg)
/*N*/ {
/*N*/   if (rIn.GetError()!=0) return rIn;
/*N*/   SdrIOHeader aHead(rIn,STREAM_READ);
/*N*/   rPg.ReadData(aHead,rIn);
/*N*/   return rIn;
/*N*/ }

/*N*/ SvStream& operator<<(SvStream& rOut, const SdrPage& rPg)
/*N*/ {
/*N*/   SdrIOHeader aHead(rOut,STREAM_WRITE,!rPg.bMaster ? SdrIOPageID : SdrIOMaPgID);
/*N*/   return rOut;
/*N*/ }

/*N*/ XubString SdrPage::GetLayoutName() const
/*N*/ {
/*N*/   // Die wollte Dieter haben.
/*N*/   return String();
/*N*/ }

/*N*/ void SdrPage::SetBackgroundObj( SdrObject* pObj )
/*N*/ {
/*N*/   if ( pObj )
/*N*/   {
/*N*/       pObj->SetPage( this );
/*N*/       pObj->SetModel( pModel );
/*N*/       pObj->SetLayer( 1 );        // Nothing known about the backgroundlayer...
/*N*/   }
/*N*/   delete pBackgroundObj, pBackgroundObj = pObj;
/*N*/ }

/*N*/ void SdrPage::SetInserted( bool bIns )
/*N*/ {
/*N*/   if( bInserted != bIns )
/*N*/   {
/*N*/       bInserted = bIns;
/*N*/
/*N*/       SdrObjListIter aIter( *this, IM_FLAT );
/*N*/       while ( aIter.IsMore() )
/*N*/       {
/*N*/           SdrObject* pObj = aIter.Next();
/*N*/           if ( pObj->ISA(SdrOle2Obj) )
/*N*/           {
/*N*/               if( bInserted )
/*N*/                   ( (SdrOle2Obj*) pObj)->Connect();
/*N*/               else
/*N*/                   ( (SdrOle2Obj*) pObj)->Disconnect();
/*N*/           }
/*N*/       }
/*N*/   }
/*N*/ }


/*N*/ uno::Reference< uno::XInterface > SdrPage::getUnoPage()
/*N*/ {
/*N*/   // try weak reference first
/*N*/   uno::Reference< uno::XInterface > xPage( mxUnoPage );
/*N*/
/*N*/   if( !xPage.is() )
/*N*/   {
/*N*/       // create one
/*N*/       xPage = createUnoPage();
/*N*/
/*N*/       mxUnoPage = xPage;
/*N*/   }
/*N*/
/*N*/   return xPage;
/*N*/ }

/*N*/ uno::Reference< uno::XInterface > SdrPage::createUnoPage()
/*N*/ {
/*N*/   ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xInt =
/*N*/ #ifndef SVX_LIGHT
/*N*/       static_cast<cppu::OWeakObject*>( new SvxFmDrawPage( this ) );
/*N*/ #else
/*N*/       static_cast<cppu::OWeakObject*>( new SvxDrawPage( this ) );
/*N*/ #endif
/*N*/   return xInt;
/*N*/ }

/*N*/ SfxStyleSheet* SdrPage::GetTextStyleSheetForObject( SdrObject* pObj ) const
/*N*/ {
/*N*/   return pObj->GetStyleSheet();
/*N*/ }

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
