xref: /aoo42x/main/svx/source/svdraw/svdpage.cxx (revision 64024726)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26 
27 #include <svx/svdpage.hxx>
28 
29 // HACK
30 #include <sot/storage.hxx>
31 #include <sot/clsids.hxx>
32 #include <sot/storage.hxx>
33 #include <svx/svdview.hxx>
34 #include <string.h>
35 #ifndef _STRING_H
36 #define _STRING_H
37 #endif
38 #include <vcl/svapp.hxx>
39 
40 #include <tools/diagnose_ex.h>
41 
42 #include <svx/svdetc.hxx>
43 #include <svx/svdobj.hxx>
44 #include <svx/svdogrp.hxx>
45 #include <svx/svdograf.hxx> // fuer SwapInAll()
46 #include <svx/svdoedge.hxx> // Zum kopieren der Konnektoren
47 #include <svx/svdoole2.hxx> // Sonderbehandlung OLE beim SdrExchangeFormat
48 #include "svx/svditer.hxx"
49 #include <svx/svdmodel.hxx>
50 #include <svx/svdlayer.hxx>
51 #include <svx/svdotext.hxx>
52 #include <svx/svdpagv.hxx>
53 #include <svx/svdundo.hxx>
54 #include <svx/fmglob.hxx>
55 #include <svx/polysc3d.hxx>
56 
57 #include <svx/fmdpage.hxx>
58 
59 #include <sfx2/objsh.hxx>
60 #include <vcl/salbtype.hxx>		// FRound
61 #include <svx/sdr/contact/viewcontactofsdrpage.hxx>
62 #include <svx/sdr/contact/viewobjectcontact.hxx>
63 #include <svx/sdr/contact/displayinfo.hxx>
64 #include <algorithm>
65 #include <svl/smplhint.hxx>
66 
67 using namespace ::com::sun::star;
68 
69 namespace {
DumpObjectList(const::std::vector<SdrObjectWeakRef> & rContainer)70 void DumpObjectList (const ::std::vector<SdrObjectWeakRef>& rContainer)
71 {
72     ::std::vector<SdrObjectWeakRef>::const_iterator iObject (rContainer.begin());
73     ::std::vector<SdrObjectWeakRef>::const_iterator iEnd (rContainer.end());
74     for (int nIndex=0 ; iObject!=iEnd; ++iObject,++nIndex)
75     {
76         const SdrObject* pObject = iObject->get();
77         OSL_TRACE("%d : %x, %s", nIndex,
78             pObject,
79             ::rtl::OUStringToOString(pObject->GetName(),RTL_TEXTENCODING_UTF8).getStr());
80     }
81 }
82 }
83 
84 
85 class SdrObjList::WeakSdrObjectContainerType
86     : public ::std::vector<SdrObjectWeakRef>
87 {
88 public:
WeakSdrObjectContainerType(const sal_Int32 nInitialSize)89     WeakSdrObjectContainerType (const sal_Int32 nInitialSize)
90         : ::std::vector<SdrObjectWeakRef>(nInitialSize) {};
91 };
92 
93 
94 
95 static const sal_Int32 InitialObjectContainerCapacity (64);
96 DBG_NAME(SdrObjList)
97 
98 TYPEINIT0(SdrObjList);
99 
SdrObjList(SdrModel * pNewModel,SdrPage * pNewPage,SdrObjList * pNewUpList)100 SdrObjList::SdrObjList(SdrModel* pNewModel, SdrPage* pNewPage, SdrObjList* pNewUpList):
101 	maList(),
102     mpNavigationOrder(),
103     mbIsNavigationOrderDirty(false)
104 {
105 	DBG_CTOR(SdrObjList,NULL);
106 	maList.reserve(InitialObjectContainerCapacity);
107 	pModel=pNewModel;
108 	pPage=pNewPage;
109 	pUpList=pNewUpList;
110 	bObjOrdNumsDirty=sal_False;
111 	bRectsDirty=sal_False;
112 	pOwnerObj=NULL;
113 	eListKind=SDROBJLIST_UNKNOWN;
114 }
115 
SdrObjList(const SdrObjList & rSrcList)116 SdrObjList::SdrObjList(const SdrObjList& rSrcList):
117 	maList(),
118     mpNavigationOrder(),
119     mbIsNavigationOrderDirty(false)
120 {
121 	DBG_CTOR(SdrObjList,NULL);
122 	maList.reserve(InitialObjectContainerCapacity);
123 	pModel=NULL;
124 	pPage=NULL;
125 	pUpList=NULL;
126 	bObjOrdNumsDirty=sal_False;
127 	bRectsDirty=sal_False;
128 	pOwnerObj=NULL;
129 	eListKind=SDROBJLIST_UNKNOWN;
130 	*this=rSrcList;
131 }
132 
~SdrObjList()133 SdrObjList::~SdrObjList()
134 {
135 	DBG_DTOR(SdrObjList,NULL);
136 
137 	// #111111#
138 	// To avoid that the Clear() method will broadcast changes when in destruction
139 	// which would call virtual methos (not allowed in destructor), the model is set
140 	// to NULL here.
141 	pModel = 0L;
142 
143 	Clear(); // Containerinhalt loeschen!
144 }
145 
operator =(const SdrObjList & rSrcList)146 void SdrObjList::operator=(const SdrObjList& rSrcList)
147 {
148 	Clear();
149 	eListKind=rSrcList.eListKind;
150 	CopyObjects(rSrcList);
151 }
152 
CopyObjects(const SdrObjList & rSrcList)153 void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
154 {
155 	Clear();
156 	bObjOrdNumsDirty=sal_False;
157 	bRectsDirty     =sal_False;
158 	sal_uIntPtr nCloneErrCnt=0;
159 	sal_uIntPtr nAnz=rSrcList.GetObjCount();
160 	SdrInsertReason aReason(SDRREASON_COPY);
161 	sal_uIntPtr no;
162 	for (no=0; no<nAnz; no++) {
163 		SdrObject* pSO=rSrcList.GetObj(no);
164 
165 		// #116235#
166 		//SdrObject* pDO=pSO->Clone(pPage,pModel);
167 		SdrObject* pDO = pSO->Clone();
168 		pDO->SetModel(pModel);
169 		pDO->SetPage(pPage);
170 
171 		if (pDO!=NULL) {
172 			NbcInsertObject(pDO,CONTAINER_APPEND,&aReason);
173 		} else {
174 			nCloneErrCnt++;
175 		}
176 	}
177 	// und nun zu den Konnektoren
178 	// Die neuen Objekte werden auf die der rSrcList abgebildet
179 	// und so die Objektverbindungen hergestellt.
180 	// Aehnliche Implementation an folgenden Stellen:
181 	//    void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
182 	//    SdrModel* SdrExchangeView::GetMarkedObjModel() const
183 	//    FASTBOOL SdrExchangeView::Paste(const SdrModel& rMod,...)
184 	//    void SdrEditView::CopyMarked()
185 	if (nCloneErrCnt==0) {
186 		for (no=0; no<nAnz; no++) {
187 			const SdrObject* pSrcOb=rSrcList.GetObj(no);
188 			SdrEdgeObj* pSrcEdge=PTR_CAST(SdrEdgeObj,pSrcOb);
189 			if (pSrcEdge!=NULL) {
190 				SdrObject* pSrcNode1=pSrcEdge->GetConnectedNode(sal_True);
191 				SdrObject* pSrcNode2=pSrcEdge->GetConnectedNode(sal_False);
192 				if (pSrcNode1!=NULL && pSrcNode1->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode1=NULL; // Listenuebergreifend
193 				if (pSrcNode2!=NULL && pSrcNode2->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode2=NULL; // ist (noch) nicht
194 				if (pSrcNode1!=NULL || pSrcNode2!=NULL) {
195 					SdrObject* pEdgeObjTmp=GetObj(no);
196 					SdrEdgeObj* pDstEdge=PTR_CAST(SdrEdgeObj,pEdgeObjTmp);
197 					if (pDstEdge!=NULL) {
198 						if (pSrcNode1!=NULL) {
199 							sal_uIntPtr nDstNode1=pSrcNode1->GetOrdNum();
200 							SdrObject* pDstNode1=GetObj(nDstNode1);
201 							if (pDstNode1!=NULL) { // Sonst grober Fehler!
202 								pDstEdge->ConnectToNode(sal_True,pDstNode1);
203 							} else {
204 								DBG_ERROR("SdrObjList::operator=(): pDstNode1==NULL!");
205 							}
206 						}
207 						if (pSrcNode2!=NULL) {
208 							sal_uIntPtr nDstNode2=pSrcNode2->GetOrdNum();
209 							SdrObject* pDstNode2=GetObj(nDstNode2);
210 							if (pDstNode2!=NULL) { // Node war sonst wohl nicht markiert
211 								pDstEdge->ConnectToNode(sal_False,pDstNode2);
212 							} else {
213 								DBG_ERROR("SdrObjList::operator=(): pDstNode2==NULL!");
214 							}
215 						}
216 					} else {
217 						DBG_ERROR("SdrObjList::operator=(): pDstEdge==NULL!");
218 					}
219 				}
220 			}
221 		}
222 	} else {
223 #ifdef DBG_UTIL
224 		ByteString aStr("SdrObjList::operator=(): Fehler beim Clonen ");
225 
226 		if(nCloneErrCnt == 1)
227 		{
228 			aStr += "eines Zeichenobjekts.";
229 		}
230 		else
231 		{
232 			aStr += "von ";
233 			aStr += ByteString::CreateFromInt32( nCloneErrCnt );
234 			aStr += " Zeichenobjekten.";
235 		}
236 
237 		aStr += " Objektverbindungen werden nicht mitkopiert.";
238 
239 		DBG_ERROR(aStr.GetBuffer());
240 #endif
241 	}
242 }
243 
Clear()244 void SdrObjList::Clear()
245 {
246 	sal_Bool bObjectsRemoved(sal_False);
247 
248 	while( ! maList.empty())
249 	{
250 		// remove last object from list
251 		SdrObject* pObj = maList.back();
252         RemoveObjectFromContainer(maList.size()-1);
253 
254 		// flushViewObjectContacts() is done since SdrObject::Free is not guaranteed
255 		// to delete the object and thus refresh visualisations
256         pObj->GetViewContact().flushViewObjectContacts(true);
257 
258 		bObjectsRemoved = sal_True;
259 
260 		// sent remove hint (after removal, see RemoveObject())
261 		if(pModel)
262 		{
263 			SdrHint aHint(*pObj);
264 			aHint.SetKind(HINT_OBJREMOVED);
265 			aHint.SetPage(pPage);
266 			pModel->Broadcast(aHint);
267 		}
268 
269 		// delete the object itself
270 		SdrObject::Free( pObj );
271 	}
272 
273 	if(pModel && bObjectsRemoved)
274 	{
275 		pModel->SetChanged();
276 	}
277 }
278 
GetPage() const279 SdrPage* SdrObjList::GetPage() const
280 {
281 	return pPage;
282 }
283 
SetPage(SdrPage * pNewPage)284 void SdrObjList::SetPage(SdrPage* pNewPage)
285 {
286 	if (pPage!=pNewPage) {
287 		pPage=pNewPage;
288 		sal_uIntPtr nAnz=GetObjCount();
289 		for (sal_uIntPtr no=0; no<nAnz; no++) {
290 			SdrObject* pObj=GetObj(no);
291 			pObj->SetPage(pPage);
292 		}
293 	}
294 }
295 
GetModel() const296 SdrModel* SdrObjList::GetModel() const
297 {
298 	return pModel;
299 }
300 
SetModel(SdrModel * pNewModel)301 void SdrObjList::SetModel(SdrModel* pNewModel)
302 {
303 	if (pModel!=pNewModel) {
304 		pModel=pNewModel;
305 		sal_uIntPtr nAnz=GetObjCount();
306 		for (sal_uIntPtr i=0; i<nAnz; i++) {
307 			SdrObject* pObj=GetObj(i);
308 			pObj->SetModel(pModel);
309 		}
310 	}
311 }
312 
RecalcObjOrdNums()313 void SdrObjList::RecalcObjOrdNums()
314 {
315 	sal_uIntPtr nAnz=GetObjCount();
316 	for (sal_uIntPtr no=0; no<nAnz; no++) {
317 		SdrObject* pObj=GetObj(no);
318 		pObj->SetOrdNum(no);
319 	}
320 	bObjOrdNumsDirty=sal_False;
321 }
322 
RecalcRects()323 void SdrObjList::RecalcRects()
324 {
325 	aOutRect=Rectangle();
326 	aSnapRect=aOutRect;
327 	sal_uIntPtr nAnz=GetObjCount();
328 	sal_uIntPtr i;
329 	for (i=0; i<nAnz; i++) {
330 		SdrObject* pObj=GetObj(i);
331 		if (i==0) {
332 			aOutRect=pObj->GetCurrentBoundRect();
333 			aSnapRect=pObj->GetSnapRect();
334 		} else {
335 			aOutRect.Union(pObj->GetCurrentBoundRect());
336 			aSnapRect.Union(pObj->GetSnapRect());
337 		}
338 	}
339 }
340 
SetRectsDirty()341 void SdrObjList::SetRectsDirty()
342 {
343 	bRectsDirty=sal_True;
344 	if (pUpList!=NULL) pUpList->SetRectsDirty();
345 }
346 
impChildInserted(SdrObject & rChild) const347 void SdrObjList::impChildInserted(SdrObject& rChild) const
348 {
349 	sdr::contact::ViewContact* pParent = rChild.GetViewContact().GetParentContact();
350 
351 	if(pParent)
352 	{
353 		pParent->ActionChildInserted(rChild.GetViewContact());
354 	}
355 }
356 
NbcInsertObject(SdrObject * pObj,sal_uIntPtr nPos,const SdrInsertReason *)357 void SdrObjList::NbcInsertObject(SdrObject* pObj, sal_uIntPtr nPos, const SdrInsertReason* /*pReason*/)
358 {
359 	DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcInsertObject(NULL)");
360 	if (pObj!=NULL) {
361 		DBG_ASSERT(!pObj->IsInserted(),"ZObjekt hat bereits Inserted-Status");
362 		sal_uIntPtr nAnz=GetObjCount();
363 		if (nPos>nAnz) nPos=nAnz;
364         InsertObjectIntoContainer(*pObj,nPos);
365 
366 		if (nPos<nAnz) bObjOrdNumsDirty=sal_True;
367 		pObj->SetOrdNum(nPos);
368 		pObj->SetObjList(this);
369 		pObj->SetPage(pPage);
370 
371 		// #110094# Inform the parent about change to allow invalidations at
372 		// evtl. existing parent visualisations
373 		impChildInserted(*pObj);
374 
375 		if (!bRectsDirty) {
376 			aOutRect.Union(pObj->GetCurrentBoundRect());
377 			aSnapRect.Union(pObj->GetSnapRect());
378 		}
379 		pObj->SetInserted(sal_True); // Ruft u.a. den UserCall
380 	}
381 }
382 
InsertObject(SdrObject * pObj,sal_uIntPtr nPos,const SdrInsertReason * pReason)383 void SdrObjList::InsertObject(SdrObject* pObj, sal_uIntPtr nPos, const SdrInsertReason* pReason)
384 {
385 	DBG_ASSERT(pObj!=NULL,"SdrObjList::InsertObject(NULL)");
386 
387 	if(pObj)
388 	{
389 		// #69055# if anchor is used, reset it before grouping
390 		if(GetOwnerObj())
391 		{
392 			const Point& rAnchorPos = pObj->GetAnchorPos();
393 			if(rAnchorPos.X() || rAnchorPos.Y())
394 				pObj->NbcSetAnchorPos(Point());
395 		}
396 
397 		// do insert to new group
398 		NbcInsertObject(pObj, nPos, pReason);
399 
400 		// Falls das Objekt in eine Gruppe eingefuegt wird
401 		// und nicht mit seinen Bruedern ueberlappt, muss es
402 		// einen eigenen Redraw bekommen
403 		if(pOwnerObj)
404 		{
405 			// only repaint here
406 			pOwnerObj->ActionChanged();
407 		}
408 
409 		if(pModel)
410 		{
411 			// Hier muss ein anderer Broadcast her!
412 			// Repaint ab Objekt Nummer ... (Achtung: GroupObj)
413 			if(pObj->GetPage())
414 			{
415 				SdrHint aHint(*pObj);
416 
417 				aHint.SetKind(HINT_OBJINSERTED);
418 				pModel->Broadcast(aHint);
419 			}
420 
421 			pModel->SetChanged();
422 		}
423 	}
424 }
425 
NbcRemoveObject(sal_uIntPtr nObjNum)426 SdrObject* SdrObjList::NbcRemoveObject(sal_uIntPtr nObjNum)
427 {
428     if (nObjNum >= maList.size())
429     {
430         OSL_ASSERT(nObjNum<maList.size());
431         return NULL;
432     }
433 
434 	sal_uIntPtr nAnz=GetObjCount();
435 	SdrObject* pObj=maList[nObjNum];
436     RemoveObjectFromContainer(nObjNum);
437 
438 	// flushViewObjectContacts() clears the VOC's and those invalidate
439     pObj->GetViewContact().flushViewObjectContacts(true);
440 
441 	DBG_ASSERT(pObj!=NULL,"Object zum Removen nicht gefunden");
442 	if (pObj!=NULL) {
443 		DBG_ASSERT(pObj->IsInserted(),"ZObjekt hat keinen Inserted-Status");
444 		pObj->SetInserted(sal_False); // Ruft u.a. den UserCall
445 		pObj->SetObjList(NULL);
446 		pObj->SetPage(NULL);
447 		if (!bObjOrdNumsDirty) { // Optimierung fuer den Fall, dass das letzte Obj rausgenommen wird
448 			if (nObjNum!=sal_uIntPtr(nAnz-1)) {
449 				bObjOrdNumsDirty=sal_True;
450 			}
451 		}
452 		SetRectsDirty();
453 	}
454 	return pObj;
455 }
456 
RemoveObject(sal_uIntPtr nObjNum)457 SdrObject* SdrObjList::RemoveObject(sal_uIntPtr nObjNum)
458 {
459     if (nObjNum >= maList.size())
460     {
461         OSL_ASSERT(nObjNum<maList.size());
462         return NULL;
463     }
464 
465 	sal_uIntPtr nAnz=GetObjCount();
466 	SdrObject* pObj=maList[nObjNum];
467     RemoveObjectFromContainer(nObjNum);
468 
469 	DBG_ASSERT(pObj!=NULL,"Object zum Removen nicht gefunden");
470 	if(pObj)
471 	{
472 		// flushViewObjectContacts() clears the VOC's and those invalidate
473         pObj->GetViewContact().flushViewObjectContacts(true);
474 
475 		DBG_ASSERT(pObj->IsInserted(),"ZObjekt hat keinen Inserted-Status");
476 		if (pModel!=NULL) {
477 			// Hier muss ein anderer Broadcast her!
478 			if (pObj->GetPage()!=NULL) {
479 				SdrHint aHint(*pObj);
480 				aHint.SetKind(HINT_OBJREMOVED);
481 				pModel->Broadcast(aHint);
482 			}
483 			pModel->SetChanged();
484 		}
485 		pObj->SetInserted(sal_False); // Ruft u.a. den UserCall
486 		pObj->SetObjList(NULL);
487 		pObj->SetPage(NULL);
488 		if (!bObjOrdNumsDirty) { // Optimierung fuer den Fall, dass das letzte Obj rausgenommen wird
489 			if (nObjNum!=sal_uIntPtr(nAnz-1)) {
490 				bObjOrdNumsDirty=sal_True;
491 			}
492 		}
493 		SetRectsDirty();
494 
495 		if(pOwnerObj && !GetObjCount())
496 		{
497 			// empty group created; it needs to be repainted since it's
498 			// visualisation changes
499 			pOwnerObj->ActionChanged();
500 		}
501 	}
502 	return pObj;
503 }
504 
NbcReplaceObject(SdrObject * pNewObj,sal_uIntPtr nObjNum)505 SdrObject* SdrObjList::NbcReplaceObject(SdrObject* pNewObj, sal_uIntPtr nObjNum)
506 {
507     if (nObjNum >= maList.size() || pNewObj == NULL)
508     {
509         OSL_ASSERT(nObjNum<maList.size());
510         OSL_ASSERT(pNewObj!=NULL);
511         return NULL;
512     }
513 
514 	SdrObject* pObj=maList[nObjNum];
515 	DBG_ASSERT(pObj!=NULL,"SdrObjList::ReplaceObject: Object zum Removen nicht gefunden");
516 	if (pObj!=NULL) {
517 		DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: ZObjekt hat keinen Inserted-Status");
518 		pObj->SetInserted(sal_False);
519 		pObj->SetObjList(NULL);
520 		pObj->SetPage(NULL);
521         ReplaceObjectInContainer(*pNewObj,nObjNum);
522 
523 		// flushViewObjectContacts() clears the VOC's and those invalidate
524         pObj->GetViewContact().flushViewObjectContacts(true);
525 
526 		pNewObj->SetOrdNum(nObjNum);
527 		pNewObj->SetObjList(this);
528 		pNewObj->SetPage(pPage);
529 
530 		// #110094#  Inform the parent about change to allow invalidations at
531 		// evtl. existing parent visualisations
532 		impChildInserted(*pNewObj);
533 
534 		pNewObj->SetInserted(sal_True);
535 		SetRectsDirty();
536 	}
537 	return pObj;
538 }
539 
ReplaceObject(SdrObject * pNewObj,sal_uIntPtr nObjNum)540 SdrObject* SdrObjList::ReplaceObject(SdrObject* pNewObj, sal_uIntPtr nObjNum)
541 {
542 	if (nObjNum >= maList.size())
543     {
544         OSL_ASSERT(nObjNum<maList.size());
545         return NULL;
546     }
547     if (pNewObj == NULL)
548     {
549         OSL_ASSERT(pNewObj!=NULL);
550         return NULL;
551     }
552 
553 	SdrObject* pObj=maList[nObjNum];
554 	DBG_ASSERT(pObj!=NULL,"SdrObjList::ReplaceObject: Object zum Removen nicht gefunden");
555 	if (pObj!=NULL) {
556 		DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: ZObjekt hat keinen Inserted-Status");
557 		if (pModel!=NULL) {
558 			// Hier muss ein anderer Broadcast her!
559 			if (pObj->GetPage()!=NULL) {
560 				SdrHint aHint(*pObj);
561 				aHint.SetKind(HINT_OBJREMOVED);
562 				pModel->Broadcast(aHint);
563 			}
564 		}
565 		pObj->SetInserted(sal_False);
566 		pObj->SetObjList(NULL);
567 		pObj->SetPage(NULL);
568 		ReplaceObjectInContainer(*pNewObj,nObjNum);
569 
570 		// flushViewObjectContacts() clears the VOC's and those invalidate
571         pObj->GetViewContact().flushViewObjectContacts(true);
572 
573 		pNewObj->SetOrdNum(nObjNum);
574 		pNewObj->SetObjList(this);
575 		pNewObj->SetPage(pPage);
576 
577 		// #110094#  Inform the parent about change to allow invalidations at
578 		// evtl. existing parent visualisations
579 		impChildInserted(*pNewObj);
580 
581 		pNewObj->SetInserted(sal_True);
582 		if (pModel!=NULL) {
583 			// Hier muss ein anderer Broadcast her!
584 			if (pNewObj->GetPage()!=NULL) {
585 				SdrHint aHint(*pNewObj);
586 				aHint.SetKind(HINT_OBJINSERTED);
587 				pModel->Broadcast(aHint);
588 			}
589 			pModel->SetChanged();
590 		}
591 		SetRectsDirty();
592 	}
593 	return pObj;
594 }
595 
NbcSetObjectOrdNum(sal_uIntPtr nOldObjNum,sal_uIntPtr nNewObjNum)596 SdrObject* SdrObjList::NbcSetObjectOrdNum(sal_uIntPtr nOldObjNum, sal_uIntPtr nNewObjNum)
597 {
598     if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size())
599     {
600         OSL_ASSERT(nOldObjNum<maList.size());
601         OSL_ASSERT(nNewObjNum<maList.size());
602         return NULL;
603     }
604 
605 	SdrObject* pObj=maList[nOldObjNum];
606 	if (nOldObjNum==nNewObjNum) return pObj;
607 	DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcSetObjectOrdNum: Object nicht gefunden");
608 	if (pObj!=NULL) {
609 		DBG_ASSERT(pObj->IsInserted(),"SdrObjList::NbcSetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
610         RemoveObjectFromContainer(nOldObjNum);
611 
612         InsertObjectIntoContainer(*pObj,nNewObjNum);
613 
614 		// #110094# No need to delete visualisation data since same object
615 		// gets inserted again. Also a single ActionChanged is enough
616 		pObj->ActionChanged();
617 
618 		pObj->SetOrdNum(nNewObjNum);
619 		bObjOrdNumsDirty=sal_True;
620 	}
621 	return pObj;
622 }
623 
SetObjectOrdNum(sal_uIntPtr nOldObjNum,sal_uIntPtr nNewObjNum)624 SdrObject* SdrObjList::SetObjectOrdNum(sal_uIntPtr nOldObjNum, sal_uIntPtr nNewObjNum)
625 {
626     if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size())
627     {
628         OSL_ASSERT(nOldObjNum<maList.size());
629         OSL_ASSERT(nNewObjNum<maList.size());
630         return NULL;
631     }
632 
633 	SdrObject* pObj=maList[nOldObjNum];
634 	if (nOldObjNum==nNewObjNum) return pObj;
635 	DBG_ASSERT(pObj!=NULL,"SdrObjList::SetObjectOrdNum: Object nicht gefunden");
636 	if (pObj!=NULL) {
637 		DBG_ASSERT(pObj->IsInserted(),"SdrObjList::SetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
638 		RemoveObjectFromContainer(nOldObjNum);
639 		InsertObjectIntoContainer(*pObj,nNewObjNum);
640 
641 		// #110094#No need to delete visualisation data since same object
642 		// gets inserted again. Also a single ActionChanged is enough
643 		pObj->ActionChanged();
644 
645 		pObj->SetOrdNum(nNewObjNum);
646 		bObjOrdNumsDirty=sal_True;
647 		if (pModel!=NULL)
648 		{
649 			// Hier muss ein anderer Broadcast her!
650 			if (pObj->GetPage()!=NULL) pModel->Broadcast(SdrHint(*pObj));
651 			pModel->SetChanged();
652 		}
653 	}
654 	return pObj;
655 }
656 
GetAllObjSnapRect() const657 const Rectangle& SdrObjList::GetAllObjSnapRect() const
658 {
659 	if (bRectsDirty) {
660 		((SdrObjList*)this)->RecalcRects();
661 		((SdrObjList*)this)->bRectsDirty=sal_False;
662 	}
663 	return aSnapRect;
664 }
665 
GetAllObjBoundRect() const666 const Rectangle& SdrObjList::GetAllObjBoundRect() const
667 {
668     // #i106183# for deep group hierarchies like in chart2, the invalidates
669     // through the hierarchy are not correct; use a 2nd hint for the needed
670     // recalculation. Future versions will have no bool flag at all, but
671     // just aOutRect in empty state to representate an invalid state, thus
672     // it's a step in the right direction.
673 	if (bRectsDirty || aOutRect.IsEmpty())
674     {
675 		((SdrObjList*)this)->RecalcRects();
676 		((SdrObjList*)this)->bRectsDirty=sal_False;
677 	}
678 	return aOutRect;
679 }
680 
NbcReformatAllTextObjects()681 void SdrObjList::NbcReformatAllTextObjects()
682 {
683 	sal_uIntPtr nAnz=GetObjCount();
684 	sal_uIntPtr nNum=0;
685 
686 	Printer* pPrinter = NULL;
687 
688 	if (pModel)
689 	{
690 		if (pModel->GetRefDevice() && pModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER)
691 		{
692 			// Kein RefDevice oder RefDevice kein Printer
693 			pPrinter = (Printer*) pModel->GetRefDevice();
694 		}
695 	}
696 
697 	while (nNum<nAnz)
698 	{
699 		SdrObject* pObj = GetObj(nNum);
700 		if (pPrinter &&
701 			pObj->GetObjInventor() == SdrInventor &&
702 			pObj->GetObjIdentifier() == OBJ_OLE2  &&
703 			!( (SdrOle2Obj*) pObj )->IsEmpty() )
704 		{
705 			//const SvInPlaceObjectRef& xObjRef = ((SdrOle2Obj*) pObj)->GetObjRef();
706             //TODO/LATER: PrinterChangeNotification needed
707 			//if( xObjRef.Is() && ( xObjRef->GetMiscStatus() & SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE ) )
708 			//	xObjRef->OnDocumentPrinterChanged(pPrinter);
709 		}
710 
711 		pObj->NbcReformatText();
712 		nAnz=GetObjCount();			    // ReformatText may delete an object
713 		nNum++;
714 	}
715 
716 }
717 
ReformatAllTextObjects()718 void SdrObjList::ReformatAllTextObjects()
719 {
720     NbcReformatAllTextObjects();
721 }
722 
723 /** steps over all available objects and reformats all
724 	edge objects that are connected to other objects so that
725 	they may reposition itselfs.
726 	#103122#
727 */
ReformatAllEdgeObjects()728 void SdrObjList::ReformatAllEdgeObjects()
729 {
730     // #120437# go over whole hierarchy, not only over object level null (seen from grouping)
731 	SdrObjListIter aIter(*this, IM_DEEPNOGROUPS);
732 
733     while(aIter.IsMore())
734 	{
735 		SdrEdgeObj* pSdrEdgeObj = dynamic_cast< SdrEdgeObj* >(aIter.Next());
736 
737         if(pSdrEdgeObj)
738         {
739 			pSdrEdgeObj->Reformat();
740         }
741 	}
742 }
743 
BurnInStyleSheetAttributes()744 void SdrObjList::BurnInStyleSheetAttributes()
745 {
746 	for(sal_uInt32 a(0L); a < GetObjCount(); a++)
747 	{
748 		GetObj(a)->BurnInStyleSheetAttributes();
749 	}
750 }
751 
GetObjCount() const752 sal_uIntPtr SdrObjList::GetObjCount() const
753 {
754     return maList.size();
755 }
756 
757 
758 
759 
GetObj(sal_uIntPtr nNum) const760 SdrObject* SdrObjList::GetObj(sal_uIntPtr nNum) const
761 {
762     if (nNum >= maList.size())
763     {
764         OSL_ASSERT(nNum<maList.size());
765         return NULL;
766     }
767     else
768         return maList[nNum];
769 }
770 
771 
772 
773 
IsReadOnly() const774 FASTBOOL SdrObjList::IsReadOnly() const
775 {
776 	FASTBOOL bRet=sal_False;
777 	if (pPage!=NULL && pPage!=this) bRet=pPage->IsReadOnly();
778 	return bRet;
779 }
780 
CountAllObjects() const781 sal_uIntPtr SdrObjList::CountAllObjects() const
782 {
783 	sal_uIntPtr nCnt=GetObjCount();
784 	sal_uIntPtr nAnz=nCnt;
785 	for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) {
786 		SdrObjList* pSubOL=GetObj(nNum)->GetSubList();
787 		if (pSubOL!=NULL) {
788 			nCnt+=pSubOL->CountAllObjects();
789 		}
790 	}
791 	return nCnt;
792 }
793 
ForceSwapInObjects() const794 void SdrObjList::ForceSwapInObjects() const
795 {
796 	sal_uIntPtr nObjAnz=GetObjCount();
797 	for (sal_uIntPtr nObjNum=nObjAnz; nObjNum>0;) {
798 		SdrObject* pObj=GetObj(--nObjNum);
799 		SdrGrafObj* pGrafObj=PTR_CAST(SdrGrafObj,pObj);
800 		if (pGrafObj!=NULL) {
801 			pGrafObj->ForceSwapIn();
802 		}
803 		SdrObjList* pOL=pObj->GetSubList();
804 		if (pOL!=NULL) {
805 			pOL->ForceSwapInObjects();
806 		}
807 	}
808 }
809 
ForceSwapOutObjects() const810 void SdrObjList::ForceSwapOutObjects() const
811 {
812 	sal_uIntPtr nObjAnz=GetObjCount();
813 	for (sal_uIntPtr nObjNum=nObjAnz; nObjNum>0;) {
814 		SdrObject* pObj=GetObj(--nObjNum);
815 		SdrGrafObj* pGrafObj=PTR_CAST(SdrGrafObj,pObj);
816 		if (pGrafObj!=NULL) {
817 			pGrafObj->ForceSwapOut();
818 		}
819 		SdrObjList* pOL=pObj->GetSubList();
820 		if (pOL!=NULL) {
821 			pOL->ForceSwapOutObjects();
822 		}
823 	}
824 }
825 
FlattenGroups()826 void SdrObjList::FlattenGroups()
827 {
828     sal_Int32 nObj = GetObjCount();
829     sal_Int32 i;
830     for( i=nObj-1; i>=0; --i)
831         UnGroupObj(i);
832 }
833 
UnGroupObj(sal_uIntPtr nObjNum)834 void SdrObjList::UnGroupObj( sal_uIntPtr nObjNum )
835 {
836     // if the given object is no group, this method is a noop
837     SdrObject* pUngroupObj = GetObj( nObjNum );
838     if( pUngroupObj )
839     {
840         SdrObjList* pSrcLst = pUngroupObj->GetSubList();
841         //sal_Int32 nCount( 0 );
842         if( pUngroupObj->ISA( SdrObjGroup ) && pSrcLst )
843         {
844             SdrObjGroup* pUngroupGroup = static_cast< SdrObjGroup* > (pUngroupObj);
845 
846             // ungroup recursively (has to be head recursion,
847             // otherwise our indices will get trashed when doing it in
848             // the loop)
849             pSrcLst->FlattenGroups();
850 
851             // the position at which we insert the members of rUngroupGroup
852             sal_Int32 nInsertPos( pUngroupGroup->GetOrdNum() );
853 
854             SdrObject* pObj;
855             sal_Int32 i, nAnz = pSrcLst->GetObjCount();
856             for( i=0; i<nAnz; ++i )
857             {
858                 pObj = pSrcLst->RemoveObject(0);
859                 SdrInsertReason aReason(SDRREASON_VIEWCALL, pUngroupGroup);
860                 InsertObject(pObj, nInsertPos, &aReason);
861                 ++nInsertPos;
862             }
863 
864             RemoveObject(nInsertPos);
865         }
866     }
867 #ifdef DBG_UTIL
868     else
869         DBG_ERROR("SdrObjList::UnGroupObj: object index invalid");
870 #endif
871 }
872 
873 
874 
875 
HasObjectNavigationOrder(void) const876 bool SdrObjList::HasObjectNavigationOrder (void) const
877 {
878     return mpNavigationOrder.get() != NULL;
879 }
880 
881 
882 
883 
SetObjectNavigationPosition(SdrObject & rObject,const sal_uInt32 nNewPosition)884 void SdrObjList::SetObjectNavigationPosition (
885     SdrObject& rObject,
886     const sal_uInt32 nNewPosition)
887 {
888     // When the navigation order container has not yet been created then
889     // create one now.  It is initialized with the z-order taken from
890     // maList.
891     if (mpNavigationOrder.get() == NULL)
892     {
893         mpNavigationOrder.reset(new WeakSdrObjectContainerType(maList.size()));
894         ::std::copy(
895             maList.begin(),
896             maList.end(),
897             mpNavigationOrder->begin());
898     }
899     OSL_ASSERT(mpNavigationOrder.get()!=NULL);
900     OSL_ASSERT( mpNavigationOrder->size() == maList.size());
901 
902     SdrObjectWeakRef aReference (&rObject);
903 
904     // Look up the object whose navigation position is to be changed.
905     WeakSdrObjectContainerType::iterator iObject (::std::find(
906         mpNavigationOrder->begin(),
907         mpNavigationOrder->end(),
908         aReference));
909     if (iObject == mpNavigationOrder->end())
910     {
911         // The given object is not a member of the navigation order.
912         return;
913     }
914 
915     // Move the object to its new position.
916     const sal_uInt32 nOldPosition = ::std::distance(mpNavigationOrder->begin(), iObject);
917     if (nOldPosition != nNewPosition)
918     {
919         mpNavigationOrder->erase(iObject);
920         sal_uInt32 nInsertPosition (nNewPosition);
921         // Adapt insertion position for the just erased object.
922         if (nNewPosition >= nOldPosition)
923             nInsertPosition -= 1;
924         if (nInsertPosition >= mpNavigationOrder->size())
925             mpNavigationOrder->push_back(aReference);
926         else
927             mpNavigationOrder->insert(mpNavigationOrder->begin()+nInsertPosition, aReference);
928 
929         mbIsNavigationOrderDirty = true;
930 
931         // The navigation order is written out to file so mark the model as modified.
932         if (pModel != NULL)
933             pModel->SetChanged();
934     }
935 }
936 
937 
938 
939 
GetObjectForNavigationPosition(const sal_uInt32 nNavigationPosition) const940 SdrObject* SdrObjList::GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const
941 {
942     if (HasObjectNavigationOrder())
943     {
944         // There is a user defined navigation order.  Make sure the object
945         // index is correct and look up the object in mpNavigationOrder.
946         if (nNavigationPosition >= mpNavigationOrder->size())
947         {
948             OSL_ASSERT(nNavigationPosition < mpNavigationOrder->size());
949         }
950         else
951             return (*mpNavigationOrder)[nNavigationPosition].get();
952     }
953     else
954     {
955         // There is no user defined navigation order.  Use the z-order
956         // instead.
957         if (nNavigationPosition >= maList.size())
958         {
959             OSL_ASSERT(nNavigationPosition < maList.size());
960         }
961         else
962             return maList[nNavigationPosition];
963     }
964     return NULL;
965 }
966 
967 
968 
969 
ClearObjectNavigationOrder(void)970 void SdrObjList::ClearObjectNavigationOrder (void)
971 {
972     mpNavigationOrder.reset();
973     mbIsNavigationOrderDirty = true;
974 }
975 
976 
977 
978 
RecalcNavigationPositions(void)979 bool SdrObjList::RecalcNavigationPositions (void)
980 {
981     bool bUpToDate (false);
982 
983     if (mbIsNavigationOrderDirty)
984     {
985         if (mpNavigationOrder.get() != NULL)
986         {
987             mbIsNavigationOrderDirty = false;
988 
989             WeakSdrObjectContainerType::iterator iObject;
990             WeakSdrObjectContainerType::const_iterator iEnd (mpNavigationOrder->end());
991             sal_uInt32 nIndex (0);
992             for (iObject=mpNavigationOrder->begin(); iObject!=iEnd; ++iObject,++nIndex)
993                 (*iObject)->SetNavigationPosition(nIndex);
994 
995             bUpToDate = true;
996         }
997     }
998 
999     return mpNavigationOrder.get() != NULL;
1000 }
1001 
1002 
1003 
1004 
SetNavigationOrder(const uno::Reference<container::XIndexAccess> & rxOrder)1005 void SdrObjList::SetNavigationOrder (const uno::Reference<container::XIndexAccess>& rxOrder)
1006 {
1007     if (rxOrder.is())
1008     {
1009         const sal_Int32 nCount = rxOrder->getCount();
1010         if ((sal_uInt32)nCount != maList.size())
1011             return;
1012 
1013         if (mpNavigationOrder.get() == NULL)
1014             mpNavigationOrder.reset(new WeakSdrObjectContainerType(nCount));
1015 
1016         for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
1017         {
1018             uno::Reference<uno::XInterface> xShape (rxOrder->getByIndex(nIndex), uno::UNO_QUERY);
1019             SdrObject* pObject = SdrObject::getSdrObjectFromXShape(xShape);
1020             if (pObject == NULL)
1021                 break;
1022             (*mpNavigationOrder)[nIndex] = pObject;
1023         }
1024 
1025         mbIsNavigationOrderDirty = true;
1026     }
1027     else
1028         ClearObjectNavigationOrder();
1029 }
1030 
1031 
1032 
1033 
InsertObjectIntoContainer(SdrObject & rObject,const sal_uInt32 nInsertPosition)1034 void SdrObjList::InsertObjectIntoContainer (
1035     SdrObject& rObject,
1036     const sal_uInt32 nInsertPosition)
1037 {
1038     OSL_ASSERT(nInsertPosition<=maList.size());
1039 
1040     // Update the navigation positions.
1041     if (HasObjectNavigationOrder())
1042     {
1043         // The new object does not have a user defined position so append it
1044         // to the list.
1045         rObject.SetNavigationPosition(mpNavigationOrder->size());
1046         mpNavigationOrder->push_back(&rObject);
1047     }
1048 
1049     // Insert object into object list.  Because the insert() method requires
1050     // a valid iterator as insertion position, we have to use push_back() to
1051     // insert at the end of the list.
1052     if (nInsertPosition >= maList.size())
1053         maList.push_back(&rObject);
1054     else
1055         maList.insert(maList.begin()+nInsertPosition, &rObject);
1056     bObjOrdNumsDirty=sal_True;
1057 }
1058 
1059 
1060 
1061 
ReplaceObjectInContainer(SdrObject & rNewObject,const sal_uInt32 nObjectPosition)1062 void SdrObjList::ReplaceObjectInContainer (
1063     SdrObject& rNewObject,
1064     const sal_uInt32 nObjectPosition)
1065 {
1066     if (nObjectPosition >= maList.size())
1067     {
1068         OSL_ASSERT(nObjectPosition<maList.size());
1069         return;
1070     }
1071 
1072     // Update the navigation positions.
1073     if (HasObjectNavigationOrder())
1074     {
1075         // A user defined position of the object that is to be replaced is
1076         // not transferred to the new object so erase the former and append
1077         // the later object from/to the navigation order.
1078         OSL_ASSERT(nObjectPosition < maList.size());
1079         SdrObjectWeakRef aReference (maList[nObjectPosition]);
1080         WeakSdrObjectContainerType::iterator iObject (::std::find(
1081             mpNavigationOrder->begin(),
1082             mpNavigationOrder->end(),
1083             aReference));
1084         if (iObject != mpNavigationOrder->end())
1085             mpNavigationOrder->erase(iObject);
1086 
1087         mpNavigationOrder->push_back(&rNewObject);
1088 
1089         mbIsNavigationOrderDirty = true;
1090     }
1091 
1092     maList[nObjectPosition] = &rNewObject;
1093     bObjOrdNumsDirty=sal_True;
1094 }
1095 
1096 
1097 
1098 
RemoveObjectFromContainer(const sal_uInt32 nObjectPosition)1099 void SdrObjList::RemoveObjectFromContainer (
1100     const sal_uInt32 nObjectPosition)
1101 {
1102     if (nObjectPosition >= maList.size())
1103     {
1104         OSL_ASSERT(nObjectPosition<maList.size());
1105         return;
1106     }
1107 
1108     // Update the navigation positions.
1109     if (HasObjectNavigationOrder())
1110     {
1111         SdrObjectWeakRef aReference (maList[nObjectPosition]);
1112         WeakSdrObjectContainerType::iterator iObject (::std::find(
1113             mpNavigationOrder->begin(),
1114             mpNavigationOrder->end(),
1115             aReference));
1116         if (iObject != mpNavigationOrder->end())
1117             mpNavigationOrder->erase(iObject);
1118         mbIsNavigationOrderDirty = true;
1119     }
1120 
1121     maList.erase(maList.begin()+nObjectPosition);
1122     bObjOrdNumsDirty=sal_True;
1123 }
1124 
1125 
1126 
1127 
1128 ////////////////////////////////////////////////////////////////////////////////////////////////////
1129 
Clear()1130 void SdrPageGridFrameList::Clear()
1131 {
1132 	sal_uInt16 nAnz=GetCount();
1133 	for (sal_uInt16 i=0; i<nAnz; i++) {
1134 		delete GetObject(i);
1135 	}
1136 	aList.Clear();
1137 }
1138 
1139 //////////////////////////////////////////////////////////////////////////////
1140 // #111111# PageUser section
1141 
AddPageUser(sdr::PageUser & rNewUser)1142 void SdrPage::AddPageUser(sdr::PageUser& rNewUser)
1143 {
1144 	maPageUsers.push_back(&rNewUser);
1145 }
1146 
RemovePageUser(sdr::PageUser & rOldUser)1147 void SdrPage::RemovePageUser(sdr::PageUser& rOldUser)
1148 {
1149 	const ::sdr::PageUserVector::iterator aFindResult = ::std::find(maPageUsers.begin(), maPageUsers.end(), &rOldUser);
1150 	if(aFindResult != maPageUsers.end())
1151 	{
1152 		maPageUsers.erase(aFindResult);
1153 	}
1154 }
1155 
1156 //////////////////////////////////////////////////////////////////////////////
1157 // #110094# DrawContact section
1158 
CreateObjectSpecificViewContact()1159 sdr::contact::ViewContact* SdrPage::CreateObjectSpecificViewContact()
1160 {
1161 	return new sdr::contact::ViewContactOfSdrPage(*this);
1162 }
1163 
GetViewContact() const1164 sdr::contact::ViewContact& SdrPage::GetViewContact() const
1165 {
1166 	if(!mpViewContact)
1167 	{
1168 		const_cast< SdrPage* >(this)->mpViewContact =
1169             const_cast< SdrPage* >(this)->CreateObjectSpecificViewContact();
1170 	}
1171 
1172 	return *mpViewContact;
1173 }
1174 
1175 ////////////////////////////////////////////////////////////////////////////////////////////////////
1176 
ImpRemoveStyleSheet()1177 void SdrPageProperties::ImpRemoveStyleSheet()
1178 {
1179     if(mpStyleSheet)
1180     {
1181 		EndListening(*mpStyleSheet);
1182         mpProperties->SetParent(0);
1183         mpStyleSheet = 0;
1184     }
1185 }
1186 
ImpAddStyleSheet(SfxStyleSheet & rNewStyleSheet)1187 void SdrPageProperties::ImpAddStyleSheet(SfxStyleSheet& rNewStyleSheet)
1188 {
1189     if(mpStyleSheet != &rNewStyleSheet)
1190     {
1191     	ImpRemoveStyleSheet();
1192         mpStyleSheet = &rNewStyleSheet;
1193 	    StartListening(rNewStyleSheet);
1194 	    mpProperties->SetParent(&rNewStyleSheet.GetItemSet());
1195     }
1196 }
1197 
ImpPageChange(SdrPage & rSdrPage)1198 void ImpPageChange(SdrPage& rSdrPage)
1199 {
1200     rSdrPage.ActionChanged();
1201 
1202     if(rSdrPage.GetModel())
1203     {
1204         rSdrPage.GetModel()->SetChanged(true);
1205         SdrHint aHint(HINT_PAGEORDERCHG);
1206         aHint.SetPage(&rSdrPage);
1207         rSdrPage.GetModel()->Broadcast(aHint);
1208     }
1209 }
1210 
SdrPageProperties(SdrPage & rSdrPage)1211 SdrPageProperties::SdrPageProperties(SdrPage& rSdrPage)
1212 :   SfxListener(),
1213     mpSdrPage(&rSdrPage),
1214     mpStyleSheet(0),
1215     mpProperties(new SfxItemSet(mpSdrPage->GetModel()->GetItemPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST))
1216 {
1217     if(!rSdrPage.IsMasterPage())
1218     {
1219         mpProperties->Put(XFillStyleItem(XFILL_NONE));
1220     }
1221 }
1222 
~SdrPageProperties()1223 SdrPageProperties::~SdrPageProperties()
1224 {
1225 	ImpRemoveStyleSheet();
1226     delete mpProperties;
1227 }
1228 
Notify(SfxBroadcaster &,const SfxHint & rHint)1229 void SdrPageProperties::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
1230 {
1231 	const SfxSimpleHint* pSimpleHint = dynamic_cast< const SfxSimpleHint* >(&rHint);
1232 
1233 	if(pSimpleHint)
1234 	{
1235 		switch(pSimpleHint->GetId())
1236 		{
1237 			case SFX_HINT_DATACHANGED :
1238 			{
1239 				// notify change, broadcast
1240                 ImpPageChange(*mpSdrPage);
1241 				break;
1242 			}
1243 			case SFX_HINT_DYING :
1244 			{
1245 				// Style needs to be forgotten
1246             	ImpRemoveStyleSheet();
1247 				break;
1248 			}
1249 		}
1250     }
1251 }
1252 
GetItemSet() const1253 const SfxItemSet& SdrPageProperties::GetItemSet() const
1254 {
1255     return *mpProperties;
1256 }
1257 
PutItemSet(const SfxItemSet & rSet)1258 void SdrPageProperties::PutItemSet(const SfxItemSet& rSet)
1259 {
1260     OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)");
1261     mpProperties->Put(rSet);
1262     ImpPageChange(*mpSdrPage);
1263 }
1264 
PutItem(const SfxPoolItem & rItem)1265 void SdrPageProperties::PutItem(const SfxPoolItem& rItem)
1266 {
1267     OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)");
1268     mpProperties->Put(rItem);
1269     ImpPageChange(*mpSdrPage);
1270 }
1271 
ClearItem(const sal_uInt16 nWhich)1272 void SdrPageProperties::ClearItem(const sal_uInt16 nWhich)
1273 {
1274     mpProperties->ClearItem(nWhich);
1275     ImpPageChange(*mpSdrPage);
1276 }
1277 
SetStyleSheet(SfxStyleSheet * pStyleSheet)1278 void SdrPageProperties::SetStyleSheet(SfxStyleSheet* pStyleSheet)
1279 {
1280     if(pStyleSheet)
1281     {
1282         ImpAddStyleSheet(*pStyleSheet);
1283     }
1284     else
1285     {
1286         ImpRemoveStyleSheet();
1287     }
1288 
1289     ImpPageChange(*mpSdrPage);
1290 }
1291 
GetStyleSheet() const1292 SfxStyleSheet* SdrPageProperties::GetStyleSheet() const
1293 {
1294     return mpStyleSheet;
1295 }
1296 
1297 ////////////////////////////////////////////////////////////////////////////////////////////////////
1298 
1299 TYPEINIT1(SdrPage,SdrObjList);
DBG_NAME(SdrPage)1300 DBG_NAME(SdrPage)
1301 SdrPage::SdrPage(SdrModel& rNewModel, bool bMasterPage)
1302 :	SdrObjList(&rNewModel, this),
1303 	mpViewContact(0L),
1304 	nWdt(10L),
1305 	nHgt(10L),
1306 	nBordLft(0L),
1307 	nBordUpp(0L),
1308 	nBordRgt(0L),
1309 	nBordLwr(0L),
1310 	pLayerAdmin(new SdrLayerAdmin(&rNewModel.GetLayerAdmin())),
1311     mpSdrPageProperties(0),
1312 	mpMasterPageDescriptor(0L),
1313 	nPageNum(0L),
1314 	mbMaster(bMasterPage),
1315 	mbInserted(false),
1316 	mbObjectsNotPersistent(false),
1317 	mbSwappingLocked(false),
1318     mbPageBorderOnlyLeftRight(false)
1319 {
1320     DBG_CTOR(SdrPage,NULL);
1321 	aPrefVisiLayers.SetAll();
1322 	eListKind = (bMasterPage) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1323 
1324     mpSdrPageProperties = new SdrPageProperties(*this);
1325 }
1326 
SdrPage(const SdrPage & rSrcPage)1327 SdrPage::SdrPage(const SdrPage& rSrcPage)
1328 :	SdrObjList(rSrcPage.pModel, this),
1329 	tools::WeakBase< SdrPage >(),
1330 	mpViewContact(0L),
1331 	nWdt(rSrcPage.nWdt),
1332 	nHgt(rSrcPage.nHgt),
1333 	nBordLft(rSrcPage.nBordLft),
1334 	nBordUpp(rSrcPage.nBordUpp),
1335 	nBordRgt(rSrcPage.nBordRgt),
1336 	nBordLwr(rSrcPage.nBordLwr),
1337 	pLayerAdmin(new SdrLayerAdmin(rSrcPage.pModel->GetLayerAdmin())),
1338     mpSdrPageProperties(0),
1339 	mpMasterPageDescriptor(0L),
1340 	nPageNum(rSrcPage.nPageNum),
1341 	mbMaster(rSrcPage.mbMaster),
1342 	mbInserted(false),
1343 	mbObjectsNotPersistent(rSrcPage.mbObjectsNotPersistent),
1344 	mbSwappingLocked(rSrcPage.mbSwappingLocked),
1345     mbPageBorderOnlyLeftRight(rSrcPage.mbPageBorderOnlyLeftRight)
1346 {
1347     DBG_CTOR(SdrPage,NULL);
1348 	aPrefVisiLayers.SetAll();
1349 	eListKind = (mbMaster) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1350 
1351 	// copy things from source
1352     // Warning: this leads to slicing (see issue 93186) and has to be
1353     // removed as soon as possible.
1354 	*this = rSrcPage;
1355     OSL_ENSURE(mpSdrPageProperties,
1356         "SdrPage::SdrPage: operator= did not create needed SdrPageProperties (!)");
1357 
1358 	// be careful and correct eListKind, a member of SdrObjList which
1359 	// will be changed by the SdrOIbjList::operator= before...
1360 	eListKind = (mbMaster) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1361 
1362     // The previous assignment to *this may have resulted in a call to
1363     // createUnoPage at a partially initialized (sliced) SdrPage object.
1364     // Due to the vtable being not yet fully set-up at this stage,
1365     // createUnoPage() may have been called at the wrong class.
1366     // To force a call to the right createUnoPage() at a later time when the
1367     // new object is full constructed mxUnoPage is disposed now.
1368     uno::Reference<lang::XComponent> xComponent (mxUnoPage, uno::UNO_QUERY);
1369     if (xComponent.is())
1370     {
1371         mxUnoPage = NULL;
1372         xComponent->dispose();
1373     }
1374 }
1375 
~SdrPage()1376 SdrPage::~SdrPage()
1377 {
1378     if( mxUnoPage.is() ) try
1379     {
1380         uno::Reference< lang::XComponent > xPageComponent( mxUnoPage, uno::UNO_QUERY_THROW );
1381         mxUnoPage.clear();
1382 	    xPageComponent->dispose();
1383     }
1384     catch( const uno::Exception& )
1385     {
1386     	DBG_UNHANDLED_EXCEPTION();
1387     }
1388 
1389 	// #111111#
1390 	// tell all the registered PageUsers that the page is in destruction
1391     // This causes some (all?) PageUsers to remove themselves from the list
1392     // of page users.  Therefore we have to use a copy of the list for the
1393     // iteration.
1394 	::sdr::PageUserVector aListCopy (maPageUsers.begin(), maPageUsers.end());
1395 	for(::sdr::PageUserVector::iterator aIterator = aListCopy.begin(); aIterator != aListCopy.end(); aIterator++)
1396 	{
1397 		sdr::PageUser* pPageUser = *aIterator;
1398 		DBG_ASSERT(pPageUser, "SdrPage::~SdrPage: corrupt PageUser list (!)");
1399 		pPageUser->PageInDestruction(*this);
1400 	}
1401 
1402 	// #111111#
1403 	// Clear the vector. This means that user do not need to call RemovePageUser()
1404 	// when they get called from PageInDestruction().
1405 	maPageUsers.clear();
1406 
1407 	delete pLayerAdmin;
1408 
1409 	TRG_ClearMasterPage();
1410 
1411 	// #110094#
1412 	if(mpViewContact)
1413 	{
1414 		delete mpViewContact;
1415 		mpViewContact = 0L;
1416 	}
1417 
1418     {
1419         delete mpSdrPageProperties;
1420         mpSdrPageProperties = 0;
1421     }
1422 
1423 	DBG_DTOR(SdrPage,NULL);
1424 }
1425 
operator =(const SdrPage & rSrcPage)1426 void SdrPage::operator=(const SdrPage& rSrcPage)
1427 {
1428 	if(mpViewContact)
1429 	{
1430 		delete mpViewContact;
1431 		mpViewContact = 0L;
1432 	}
1433 
1434 	// Joe also sets some parameters for the class this one
1435 	// is derived from. SdrObjList does the same bad handling of
1436 	// copy constructor and operator=, so i better let it stand here.
1437 	pPage = this;
1438 
1439 	// copy all the local parameters to make this instance
1440 	// a valid copy od source page before copying and inserting
1441 	// the contained objects
1442 	mbMaster = rSrcPage.mbMaster;
1443 	mbSwappingLocked = rSrcPage.mbSwappingLocked;
1444     mbPageBorderOnlyLeftRight = rSrcPage.mbPageBorderOnlyLeftRight;
1445 	aPrefVisiLayers = rSrcPage.aPrefVisiLayers;
1446 	nWdt = rSrcPage.nWdt;
1447 	nHgt = rSrcPage.nHgt;
1448 	nBordLft = rSrcPage.nBordLft;
1449 	nBordUpp = rSrcPage.nBordUpp;
1450 	nBordRgt = rSrcPage.nBordRgt;
1451 	nBordLwr = rSrcPage.nBordLwr;
1452 	nPageNum = rSrcPage.nPageNum;
1453 
1454 	if(rSrcPage.TRG_HasMasterPage())
1455 	{
1456 		TRG_SetMasterPage(rSrcPage.TRG_GetMasterPage());
1457 		TRG_SetMasterPageVisibleLayers(rSrcPage.TRG_GetMasterPageVisibleLayers());
1458 	}
1459 	else
1460 	{
1461 		TRG_ClearMasterPage();
1462 	}
1463 	//aMasters = rSrcPage.aMasters;
1464 
1465 	mbObjectsNotPersistent = rSrcPage.mbObjectsNotPersistent;
1466 
1467     {
1468         // #i111122# delete SdrPageProperties when model is different
1469         if(mpSdrPageProperties && GetModel() != rSrcPage.GetModel())
1470         {
1471             delete mpSdrPageProperties;
1472             mpSdrPageProperties = 0;
1473         }
1474 
1475         if(!mpSdrPageProperties)
1476         {
1477             mpSdrPageProperties = new SdrPageProperties(*this);
1478         }
1479         else
1480         {
1481             mpSdrPageProperties->ClearItem(0);
1482         }
1483 
1484         if(!IsMasterPage())
1485         {
1486             mpSdrPageProperties->PutItemSet(rSrcPage.getSdrPageProperties().GetItemSet());
1487         }
1488 
1489         mpSdrPageProperties->SetStyleSheet(rSrcPage.getSdrPageProperties().GetStyleSheet());
1490     }
1491 
1492     // Now copy the contained obejcts (by cloning them)
1493 	SdrObjList::operator=(rSrcPage);
1494 }
1495 
Clone() const1496 SdrPage* SdrPage::Clone() const
1497 {
1498 	return Clone(NULL);
1499 }
1500 
Clone(SdrModel * pNewModel) const1501 SdrPage* SdrPage::Clone(SdrModel* pNewModel) const
1502 {
1503 	if (pNewModel==NULL) pNewModel=pModel;
1504 	SdrPage* pPage2=new SdrPage(*pNewModel);
1505 	*pPage2=*this;
1506 	return pPage2;
1507 }
1508 
SetSize(const Size & aSiz)1509 void SdrPage::SetSize(const Size& aSiz)
1510 {
1511     bool bChanged(false);
1512 
1513     if(aSiz.Width() != nWdt)
1514     {
1515     	nWdt = aSiz.Width();
1516         bChanged = true;
1517     }
1518 
1519     if(aSiz.Height() != nHgt)
1520     {
1521     	nHgt = aSiz.Height();
1522         bChanged = true;
1523     }
1524 
1525     if(bChanged)
1526     {
1527     	SetChanged();
1528     }
1529 }
1530 
GetSize() const1531 Size SdrPage::GetSize() const
1532 {
1533 	return Size(nWdt,nHgt);
1534 }
1535 
GetWdt() const1536 sal_Int32 SdrPage::GetWdt() const
1537 {
1538 	return nWdt;
1539 }
1540 
SetOrientation(Orientation eOri)1541 void SdrPage::SetOrientation(Orientation eOri)
1542 {
1543 	// Quadratisch ist und bleibt immer Portrait
1544 	Size aSiz(GetSize());
1545 	if (aSiz.Width()!=aSiz.Height()) {
1546 		if ((eOri==ORIENTATION_PORTRAIT) == (aSiz.Width()>aSiz.Height())) {
1547 			SetSize(Size(aSiz.Height(),aSiz.Width()));
1548 		}
1549 	}
1550 }
1551 
GetOrientation() const1552 Orientation SdrPage::GetOrientation() const
1553 {
1554 	// Quadratisch ist Portrait
1555 	Orientation eRet=ORIENTATION_PORTRAIT;
1556 	Size aSiz(GetSize());
1557 	if (aSiz.Width()>aSiz.Height()) eRet=ORIENTATION_LANDSCAPE;
1558 	return eRet;
1559 }
1560 
GetHgt() const1561 sal_Int32 SdrPage::GetHgt() const
1562 {
1563 	return nHgt;
1564 }
1565 
SetBorder(sal_Int32 nLft,sal_Int32 nUpp,sal_Int32 nRgt,sal_Int32 nLwr)1566 void  SdrPage::SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 nLwr)
1567 {
1568     bool bChanged(false);
1569 
1570     if(nBordLft != nLft)
1571     {
1572         nBordLft = nLft;
1573         bChanged = true;
1574     }
1575 
1576 	if(nBordUpp != nUpp)
1577     {
1578     	nBordUpp = nUpp;
1579         bChanged = true;
1580     }
1581 
1582 	if(nBordRgt != nRgt)
1583     {
1584 	    nBordRgt = nRgt;
1585         bChanged = true;
1586     }
1587 
1588 	if(nBordLwr != nLwr)
1589     {
1590 	    nBordLwr =  nLwr;
1591         bChanged = true;
1592     }
1593 
1594     if(bChanged)
1595     {
1596     	SetChanged();
1597     }
1598 }
1599 
SetLftBorder(sal_Int32 nBorder)1600 void  SdrPage::SetLftBorder(sal_Int32 nBorder)
1601 {
1602 	if(nBordLft != nBorder)
1603     {
1604     	nBordLft = nBorder;
1605 	    SetChanged();
1606     }
1607 }
1608 
SetUppBorder(sal_Int32 nBorder)1609 void  SdrPage::SetUppBorder(sal_Int32 nBorder)
1610 {
1611 	if(nBordUpp != nBorder)
1612     {
1613     	nBordUpp = nBorder;
1614 	    SetChanged();
1615     }
1616 }
1617 
SetRgtBorder(sal_Int32 nBorder)1618 void  SdrPage::SetRgtBorder(sal_Int32 nBorder)
1619 {
1620 	if(nBordRgt != nBorder)
1621     {
1622     	nBordRgt=nBorder;
1623 	    SetChanged();
1624     }
1625 }
1626 
SetLwrBorder(sal_Int32 nBorder)1627 void  SdrPage::SetLwrBorder(sal_Int32 nBorder)
1628 {
1629 	if(nBordLwr != nBorder)
1630     {
1631     	nBordLwr=nBorder;
1632 	    SetChanged();
1633     }
1634 }
1635 
GetLftBorder() const1636 sal_Int32 SdrPage::GetLftBorder() const
1637 {
1638 	return nBordLft;
1639 }
1640 
GetUppBorder() const1641 sal_Int32 SdrPage::GetUppBorder() const
1642 {
1643 	return nBordUpp;
1644 }
1645 
GetRgtBorder() const1646 sal_Int32 SdrPage::GetRgtBorder() const
1647 {
1648 	return nBordRgt;
1649 }
1650 
GetLwrBorder() const1651 sal_Int32 SdrPage::GetLwrBorder() const
1652 {
1653 	return nBordLwr;
1654 }
1655 
SetModel(SdrModel * pNewModel)1656 void SdrPage::SetModel(SdrModel* pNewModel)
1657 {
1658 	SdrModel* pOldModel=pModel;
1659 	SdrObjList::SetModel(pNewModel);
1660 	if (pNewModel!=pOldModel)
1661 	{
1662 		if (pNewModel!=NULL) {
1663 			pLayerAdmin->SetParent(&pNewModel->GetLayerAdmin());
1664 		} else {
1665 			pLayerAdmin->SetParent(NULL);
1666 		}
1667 		pLayerAdmin->SetModel(pNewModel);
1668 
1669         // create new SdrPageProperties with new model (due to SfxItemSet there)
1670         // and copy ItemSet and StyleSheet
1671         SdrPageProperties *pNew = new SdrPageProperties(*this);
1672 
1673         if(!IsMasterPage())
1674         {
1675             pNew->PutItemSet(getSdrPageProperties().GetItemSet());
1676         }
1677 
1678         pNew->SetStyleSheet(getSdrPageProperties().GetStyleSheet());
1679 
1680         delete mpSdrPageProperties;
1681         mpSdrPageProperties = pNew;
1682 	}
1683 
1684 	// update listeners at possible api wrapper object
1685 	if( pOldModel != pNewModel )
1686 	{
1687 		if( mxUnoPage.is() )
1688 		{
1689 			SvxDrawPage* pPage2 = SvxDrawPage::getImplementation( mxUnoPage );
1690 			if( pPage2 )
1691 				pPage2->ChangeModel( pNewModel );
1692 		}
1693 	}
1694 }
1695 
1696 ////////////////////////////////////////////////////////////////////////////////////////////////////
1697 
1698 // #i68775# React on PageNum changes (from Model in most cases)
SetPageNum(sal_uInt16 nNew)1699 void SdrPage::SetPageNum(sal_uInt16 nNew)
1700 {
1701 	if(nNew != nPageNum)
1702 	{
1703 		// change
1704 		nPageNum = nNew;
1705 
1706 		// notify visualisations, also notifies e.g. buffered MasterPages
1707 		ActionChanged();
1708 	}
1709 }
1710 
GetPageNum() const1711 sal_uInt16 SdrPage::GetPageNum() const
1712 {
1713 	if (!mbInserted)
1714         return 0;
1715 
1716 	if (mbMaster) {
1717 		if (pModel && pModel->IsMPgNumsDirty())
1718 			((SdrModel*)pModel)->RecalcPageNums(sal_True);
1719 	} else {
1720 		if (pModel && pModel->IsPagNumsDirty())
1721 			((SdrModel*)pModel)->RecalcPageNums(sal_False);
1722 	}
1723 	return nPageNum;
1724 }
1725 
SetChanged()1726 void SdrPage::SetChanged()
1727 {
1728 	// #110094#-11
1729 	// For test purposes, use the new ViewContact for change
1730 	// notification now.
1731 	ActionChanged();
1732 
1733 	if( pModel )
1734 	{
1735 		pModel->SetChanged();
1736 	}
1737 }
1738 
1739 ////////////////////////////////////////////////////////////////////////////////////////////////////
1740 // MasterPage interface
1741 
TRG_SetMasterPage(SdrPage & rNew)1742 void SdrPage::TRG_SetMasterPage(SdrPage& rNew)
1743 {
1744 	if(mpMasterPageDescriptor && &(mpMasterPageDescriptor->GetUsedPage()) == &rNew)
1745 		return;
1746 
1747 	if(mpMasterPageDescriptor)
1748 		TRG_ClearMasterPage();
1749 
1750 	mpMasterPageDescriptor = new ::sdr::MasterPageDescriptor(*this, rNew);
1751 	GetViewContact().ActionChanged();
1752 }
1753 
TRG_ClearMasterPage()1754 void SdrPage::TRG_ClearMasterPage()
1755 {
1756 	if(mpMasterPageDescriptor)
1757 	{
1758 		SetChanged();
1759 
1760 		// the flushViewObjectContacts() will do needed invalidates by deleting the involved VOCs
1761         mpMasterPageDescriptor->GetUsedPage().GetViewContact().flushViewObjectContacts(true);
1762 
1763 		delete mpMasterPageDescriptor;
1764 		mpMasterPageDescriptor = 0L;
1765 	}
1766 }
1767 
TRG_GetMasterPage() const1768 SdrPage& SdrPage::TRG_GetMasterPage() const
1769 {
1770 	DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPage(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1771         if (mpMasterPageDescriptor == NULL) {
1772             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No master page descriptor")), NULL);
1773         }
1774 	return mpMasterPageDescriptor->GetUsedPage();
1775 }
1776 
TRG_GetMasterPageVisibleLayers() const1777 const SetOfByte& SdrPage::TRG_GetMasterPageVisibleLayers() const
1778 {
1779 	DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1780         if (mpMasterPageDescriptor == NULL) {
1781             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No master page descriptor")), NULL);
1782         }
1783 	return mpMasterPageDescriptor->GetVisibleLayers();
1784 }
1785 
TRG_SetMasterPageVisibleLayers(const SetOfByte & rNew)1786 void SdrPage::TRG_SetMasterPageVisibleLayers(const SetOfByte& rNew)
1787 {
1788 	DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_SetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1789         if (mpMasterPageDescriptor == NULL) {
1790             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No master page descriptor")), NULL);
1791         }
1792 	mpMasterPageDescriptor->SetVisibleLayers(rNew);
1793 }
1794 
TRG_GetMasterPageDescriptorViewContact() const1795 sdr::contact::ViewContact& SdrPage::TRG_GetMasterPageDescriptorViewContact() const
1796 {
1797 	DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPageDescriptorViewContact(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1798         if (mpMasterPageDescriptor == NULL) {
1799             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No master page descriptor")), NULL);
1800         }
1801 	return mpMasterPageDescriptor->GetViewContact();
1802 }
1803 
1804 // #115423# used from SdrModel::RemoveMasterPage
TRG_ImpMasterPageRemoved(const SdrPage & rRemovedPage)1805 void SdrPage::TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage)
1806 {
1807 	if(TRG_HasMasterPage())
1808 	{
1809 		if(&TRG_GetMasterPage() == &rRemovedPage)
1810 		{
1811 			TRG_ClearMasterPage();
1812 		}
1813 	}
1814 }
1815 
GetGridFrameList(const SdrPageView *,const Rectangle *) const1816 const SdrPageGridFrameList* SdrPage::GetGridFrameList(const SdrPageView* /*pPV*/, const Rectangle* /*pRect*/) const
1817 {
1818 	return NULL;
1819 }
1820 
GetLayoutName() const1821 XubString SdrPage::GetLayoutName() const
1822 {
1823 	// Die wollte Dieter haben.
1824 	return String();
1825 }
1826 
SetInserted(bool bIns)1827 void SdrPage::SetInserted( bool bIns )
1828 {
1829 	if( mbInserted != bIns )
1830 	{
1831 		mbInserted = bIns;
1832 
1833         // #120437# go over whole hierarchy, not only over object level null (seen from grouping)
1834 		SdrObjListIter aIter(*this, IM_DEEPNOGROUPS);
1835 
1836  		while ( aIter.IsMore() )
1837 		{
1838 			SdrObject* pObj = aIter.Next();
1839 			if ( pObj->ISA(SdrOle2Obj) )
1840 			{
1841 				if( mbInserted )
1842 					( (SdrOle2Obj*) pObj)->Connect();
1843 				else
1844 					( (SdrOle2Obj*) pObj)->Disconnect();
1845 			}
1846 		}
1847 	}
1848 }
1849 
1850 
getUnoPage()1851 uno::Reference< uno::XInterface > SdrPage::getUnoPage()
1852 {
1853 	// try weak reference first
1854 	if( !mxUnoPage.is() )
1855 	{
1856 		// create one
1857 		mxUnoPage = createUnoPage();
1858 	}
1859 
1860 	return mxUnoPage;
1861 }
1862 
createUnoPage()1863 uno::Reference< uno::XInterface > SdrPage::createUnoPage()
1864 {
1865 	::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xInt =
1866 		static_cast<cppu::OWeakObject*>( new SvxFmDrawPage( this ) );
1867 	return xInt;
1868 }
1869 
GetTextStyleSheetForObject(SdrObject * pObj) const1870 SfxStyleSheet* SdrPage::GetTextStyleSheetForObject( SdrObject* pObj ) const
1871 {
1872 	return pObj->GetStyleSheet();
1873 }
1874 
HasTransparentObjects(sal_Bool bCheckForAlphaChannel) const1875 FASTBOOL SdrPage::HasTransparentObjects( sal_Bool bCheckForAlphaChannel ) const
1876 {
1877 	FASTBOOL bRet = sal_False;
1878 
1879 	for( sal_uIntPtr n = 0, nCount = GetObjCount(); ( n < nCount ) && !bRet; n++ )
1880 		if( GetObj( n )->IsTransparent( bCheckForAlphaChannel ) )
1881 			bRet = sal_True;
1882 
1883 	return bRet;
1884 }
1885 
1886 /** returns an averaged background color of this page */
1887 // #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value
GetPageBackgroundColor(SdrPageView * pView,bool bScreenDisplay) const1888 Color SdrPage::GetPageBackgroundColor( SdrPageView* pView, bool bScreenDisplay ) const
1889 {
1890 	Color aColor;
1891 
1892 	if(bScreenDisplay && (!pView || pView->GetApplicationDocumentColor() == COL_AUTO))
1893 	{
1894         svtools::ColorConfig aColorConfig;
1895         aColor = aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor;
1896 	}
1897 	else
1898 	{
1899 		aColor = pView->GetApplicationDocumentColor();
1900 	}
1901 
1902     const SfxItemSet* pBackgroundFill = &getSdrPageProperties().GetItemSet();
1903 
1904     if(!IsMasterPage() && TRG_HasMasterPage())
1905     {
1906     	if(XFILL_NONE == ((const XFillStyleItem&)pBackgroundFill->Get(XATTR_FILLSTYLE)).GetValue())
1907         {
1908 		    pBackgroundFill = &TRG_GetMasterPage().getSdrPageProperties().GetItemSet();
1909         }
1910     }
1911 
1912 	GetDraftFillColor(*pBackgroundFill, aColor);
1913 
1914 	return aColor;
1915 }
1916 
1917 /** *deprecated, use GetBackgroundColor with SdrPageView */
GetPageBackgroundColor() const1918 Color SdrPage::GetPageBackgroundColor() const
1919 // #i75566# GetBackgroundColor -> GetPageBackgroundColor
1920 {
1921 	return GetPageBackgroundColor( NULL, true );
1922 }
1923 
1924 /** this method returns true if the object from the ViewObjectContact should
1925 	be visible on this page while rendering.
1926 	bEdit selects if visibility test is for an editing view or a final render,
1927 	like printing.
1928 */
checkVisibility(const sdr::contact::ViewObjectContact &,const sdr::contact::DisplayInfo &,bool)1929 bool SdrPage::checkVisibility(
1930 	const sdr::contact::ViewObjectContact& /*rOriginal*/,
1931 	const sdr::contact::DisplayInfo& /*rDisplayInfo*/,
1932 	bool /*bEdit*/)
1933 {
1934 	// this will be handled in the application if needed
1935 	return true;
1936 }
1937 
1938 // #110094# DrawContact support: Methods for handling Page changes
ActionChanged() const1939 void SdrPage::ActionChanged() const
1940 {
1941 	// Do necessary ViewContact actions
1942 	GetViewContact().ActionChanged();
1943 
1944 	// #i48535# also handle MasterPage change
1945 	if(TRG_HasMasterPage())
1946 	{
1947 		TRG_GetMasterPageDescriptorViewContact().ActionChanged();
1948 	}
1949 }
1950 
1951 // NYI: Dummy implementations for declarations in svdpage.hxx
GetBitmap(const SetOfByte &,FASTBOOL) const1952 Bitmap      SdrPage::GetBitmap(const SetOfByte& /*rVisibleLayers*/, FASTBOOL /*bTrimBorders*/) const
1953 {
1954 	DBG_ASSERT(0, "SdrPage::GetBitmap(): not yet implemented.");
1955 	return Bitmap();
1956 }
GetMetaFile(const SetOfByte &,FASTBOOL)1957 GDIMetaFile SdrPage::GetMetaFile(const SetOfByte& /*rVisibleLayers*/, FASTBOOL /*bTrimBorders*/)
1958 {
1959 	DBG_ASSERT(0, "SdrPage::GetMetaFile(): not yet implemented.");
1960 	return GDIMetaFile();
1961 }
1962 
isHandoutMasterPage() const1963 bool SdrPage::isHandoutMasterPage() const
1964 {
1965     return mbMaster && GetModel() && GetModel()->GetMasterPageCount()
1966         && GetModel()->GetMasterPage(0) == this;
1967 }
1968 
1969 //////////////////////////////////////////////////////////////////////////////
1970 // sdr::Comment interface
1971 
GetCommentByIndex(sal_uInt32 nIndex)1972 const sdr::Comment& SdrPage::GetCommentByIndex(sal_uInt32 nIndex)
1973 {
1974 	DBG_ASSERT(nIndex < maComments.size(), "SdrPage::GetCommentByIndex: Access out of range (!)");
1975 	return maComments[nIndex];
1976 }
1977 
AddComment(const sdr::Comment & rNew)1978 void SdrPage::AddComment(const sdr::Comment& rNew)
1979 {
1980 	maComments.push_back(rNew);
1981     ::std::sort(maComments.begin(), maComments.end());
1982 }
1983 
ReplaceCommentByIndex(sal_uInt32 nIndex,const sdr::Comment & rNew)1984 void SdrPage::ReplaceCommentByIndex(sal_uInt32 nIndex, const sdr::Comment& rNew)
1985 {
1986 	DBG_ASSERT(nIndex < maComments.size(), "SdrPage::GetCommentByIndex: Access out of range (!)");
1987 
1988 	if(maComments[nIndex] != rNew)
1989 	{
1990 		maComments[nIndex] = rNew;
1991 		::std::sort(maComments.begin(), maComments.end());
1992 	}
1993 }
1994 
getCorrectSdrPageProperties() const1995 const SdrPageProperties* SdrPage::getCorrectSdrPageProperties() const
1996 {
1997     if(mpMasterPageDescriptor)
1998     {
1999         return mpMasterPageDescriptor->getCorrectSdrPageProperties();
2000     }
2001     else
2002     {
2003         return &getSdrPageProperties();
2004     }
2005 }
2006 
2007 //////////////////////////////////////////////////////////////////////////////
2008 // use new redirector instead of pPaintProc
2009 
StandardCheckVisisbilityRedirector()2010 StandardCheckVisisbilityRedirector::StandardCheckVisisbilityRedirector()
2011 :	ViewObjectContactRedirector()
2012 {
2013 }
2014 
~StandardCheckVisisbilityRedirector()2015 StandardCheckVisisbilityRedirector::~StandardCheckVisisbilityRedirector()
2016 {
2017 }
2018 
createRedirectedPrimitive2DSequence(const sdr::contact::ViewObjectContact & rOriginal,const sdr::contact::DisplayInfo & rDisplayInfo)2019 drawinglayer::primitive2d::Primitive2DSequence StandardCheckVisisbilityRedirector::createRedirectedPrimitive2DSequence(
2020 	const sdr::contact::ViewObjectContact& rOriginal,
2021 	const sdr::contact::DisplayInfo& rDisplayInfo)
2022 {
2023 	SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
2024 
2025 	if(pObject)
2026 	{
2027 		if(pObject->GetPage())
2028 		{
2029 			if(pObject->GetPage()->checkVisibility(rOriginal, rDisplayInfo, false))
2030 			{
2031 				return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
2032 			}
2033 		}
2034 
2035 		return drawinglayer::primitive2d::Primitive2DSequence();
2036 	}
2037 	else
2038 	{
2039 		// not an object, maybe a page
2040 		return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
2041 	}
2042 }
2043 
2044 //////////////////////////////////////////////////////////////////////////////
2045 // eof
2046