Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <vcl/metaact.hxx>
21 : #include <svx/svdedtv.hxx>
22 : #include <svx/svdundo.hxx>
23 : #include <svx/svdograf.hxx>
24 : #include <svx/svdopath.hxx>
25 : #include <svx/svdoole2.hxx>
26 : #include <svx/svdopage.hxx>
27 : #include <svx/svdoedge.hxx>
28 : #include <svx/svdlayer.hxx>
29 : #include <svx/svdpagv.hxx>
30 : #include <svx/svdpage.hxx>
31 : #include <svx/svdpoev.hxx>
32 : #include "svx/svdstr.hrc"
33 : #include "svdglob.hxx"
34 : #include <svx/e3dsceneupdater.hxx>
35 : #include <rtl/strbuf.hxx>
36 : #include <svx/svdview.hxx>
37 : #include <clonelist.hxx>
38 :
39 : using namespace com::sun::star;
40 :
41 19881 : void SdrEditView::ImpResetPossibilityFlags()
42 : {
43 19881 : bReadOnly =false;
44 :
45 19881 : bGroupPossible =false;
46 19881 : bUnGroupPossible =false;
47 19881 : bGrpEnterPossible =false;
48 19881 : bDeletePossible =false;
49 19881 : bToTopPossible =false;
50 19881 : bToBtmPossible =false;
51 19881 : bReverseOrderPossible =false;
52 :
53 19881 : bImportMtfPossible =false;
54 19881 : bCombinePossible =false;
55 19881 : bDismantlePossible =false;
56 19881 : bCombineNoPolyPolyPossible =false;
57 19881 : bDismantleMakeLinesPossible=false;
58 19881 : bOrthoDesiredOnMarked =false;
59 :
60 19881 : bMoreThanOneNotMovable =false;
61 19881 : bOneOrMoreMovable =false;
62 19881 : bMoreThanOneNoMovRot =false;
63 19881 : bContortionPossible =false;
64 19881 : bAllPolys =false;
65 19881 : bOneOrMorePolys =false;
66 19881 : bMoveAllowed =false;
67 19881 : bResizeFreeAllowed =false;
68 19881 : bResizePropAllowed =false;
69 19881 : bRotateFreeAllowed =false;
70 19881 : bRotate90Allowed =false;
71 19881 : bMirrorFreeAllowed =false;
72 19881 : bMirror45Allowed =false;
73 19881 : bMirror90Allowed =false;
74 19881 : bTransparenceAllowed =false;
75 19881 : bGradientAllowed =false;
76 19881 : bShearAllowed =false;
77 19881 : bEdgeRadiusAllowed =false;
78 19881 : bCanConvToPath =false;
79 19881 : bCanConvToPoly =false;
80 19881 : bCanConvToContour =false;
81 19881 : bCanConvToPathLineToArea=false;
82 19881 : bCanConvToPolyLineToArea=false;
83 19881 : bMoveProtect =false;
84 19881 : bResizeProtect =false;
85 19881 : }
86 :
87 15989 : void SdrEditView::ImpClearVars()
88 : {
89 15989 : ImpResetPossibilityFlags();
90 15989 : bPossibilitiesDirty=true; // << Purify didn't like this
91 15989 : bBundleVirtObj=false;
92 15989 : }
93 :
94 15989 : SdrEditView::SdrEditView(SdrModel* pModel1, OutputDevice* pOut):
95 15989 : SdrMarkView(pModel1,pOut)
96 : {
97 15989 : ImpClearVars();
98 15989 : }
99 :
100 15919 : SdrEditView::~SdrEditView()
101 : {
102 15919 : }
103 :
104 :
105 :
106 0 : SdrLayer* SdrEditView::InsertNewLayer(const OUString& rName, sal_uInt16 nPos)
107 : {
108 0 : SdrLayerAdmin& rLA=pMod->GetLayerAdmin();
109 0 : sal_uInt16 nMax=rLA.GetLayerCount();
110 0 : if (nPos>nMax) nPos=nMax;
111 0 : SdrLayer* pNewLayer=rLA.NewLayer(rName,nPos);
112 :
113 0 : if( GetModel()->IsUndoEnabled() )
114 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewLayer(nPos,rLA,*pMod));
115 :
116 0 : pMod->SetChanged();
117 0 : return pNewLayer;
118 : }
119 :
120 : #include <svx/svdogrp.hxx>
121 : #include <svx/scene3d.hxx>
122 :
123 0 : bool SdrEditView::ImpDelLayerCheck(SdrObjList* pOL, SdrLayerID nDelID) const
124 : {
125 0 : bool bDelAll(true);
126 :
127 0 : for(size_t nObjNum = pOL->GetObjCount(); nObjNum > 0 && bDelAll;)
128 : {
129 0 : nObjNum--;
130 0 : SdrObject* pObj = pOL->GetObj(nObjNum);
131 0 : SdrObjList* pSubOL = pObj->GetSubList();
132 :
133 : // explicitly test for group objects and 3d scenes
134 0 : if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
135 : {
136 0 : if(!ImpDelLayerCheck(pSubOL, nDelID))
137 : {
138 0 : bDelAll = false;
139 : }
140 : }
141 : else
142 : {
143 0 : if(pObj->GetLayer() != nDelID)
144 : {
145 0 : bDelAll = false;
146 : }
147 : }
148 : }
149 :
150 0 : return bDelAll;
151 : }
152 :
153 0 : void SdrEditView::ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID)
154 : {
155 0 : const size_t nObjAnz(pOL->GetObjCount());
156 : // make sure OrdNums are correct
157 0 : pOL->GetObj(0)->GetOrdNum();
158 :
159 0 : const bool bUndo = GetModel()->IsUndoEnabled();
160 :
161 0 : for(size_t nObjNum = nObjAnz; nObjNum > 0;)
162 : {
163 0 : nObjNum--;
164 0 : SdrObject* pObj = pOL->GetObj(nObjNum);
165 0 : SdrObjList* pSubOL = pObj->GetSubList();
166 :
167 :
168 : // explicitly test for group objects and 3d scenes
169 0 : if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
170 : {
171 0 : if(ImpDelLayerCheck(pSubOL, nDelID))
172 : {
173 0 : if( bUndo )
174 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
175 0 : pOL->RemoveObject(nObjNum);
176 :
177 0 : if( !bUndo )
178 0 : SdrObject::Free( pObj );
179 : }
180 : else
181 : {
182 0 : ImpDelLayerDelObjs(pSubOL, nDelID);
183 : }
184 : }
185 : else
186 : {
187 0 : if(pObj->GetLayer() == nDelID)
188 : {
189 0 : if( bUndo )
190 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
191 0 : pOL->RemoveObject(nObjNum);
192 0 : if( !bUndo )
193 0 : SdrObject::Free( pObj );
194 : }
195 : }
196 : }
197 0 : }
198 :
199 2 : void SdrEditView::DeleteLayer(const OUString& rName)
200 : {
201 2 : SdrLayerAdmin& rLA = pMod->GetLayerAdmin();
202 2 : SdrLayer* pLayer = rLA.GetLayer(rName, true);
203 2 : sal_uInt16 nLayerNum(rLA.GetLayerPos(pLayer));
204 :
205 2 : if(SDRLAYER_NOTFOUND != nLayerNum)
206 : {
207 :
208 2 : SdrLayerID nDelID = pLayer->GetID();
209 :
210 2 : const bool bUndo = IsUndoEnabled();
211 2 : if( bUndo )
212 2 : BegUndo(ImpGetResStr(STR_UndoDelLayer));
213 :
214 2 : bool bMaPg(true);
215 :
216 6 : for(sal_uInt16 nPageKind(0); nPageKind < 2; nPageKind++)
217 : {
218 : // MasterPages and DrawPages
219 4 : sal_uInt16 nPgAnz(bMaPg ? pMod->GetMasterPageCount() : pMod->GetPageCount());
220 :
221 16 : for(sal_uInt16 nPgNum(0); nPgNum < nPgAnz; nPgNum++)
222 : {
223 : // over all pages
224 12 : SdrPage* pPage = (bMaPg) ? pMod->GetMasterPage(nPgNum) : pMod->GetPage(nPgNum);
225 12 : const size_t nObjAnz(pPage->GetObjCount());
226 :
227 : // make sure OrdNums are correct
228 12 : if(nObjAnz)
229 4 : pPage->GetObj(0)->GetOrdNum();
230 :
231 30 : for(size_t nObjNum(nObjAnz); nObjNum > 0;)
232 : {
233 6 : nObjNum--;
234 6 : SdrObject* pObj = pPage->GetObj(nObjNum);
235 6 : SdrObjList* pSubOL = pObj->GetSubList();
236 :
237 : // explicitly test for group objects and 3d scenes
238 6 : if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
239 : {
240 0 : if(ImpDelLayerCheck(pSubOL, nDelID))
241 : {
242 0 : if( bUndo )
243 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
244 0 : pPage->RemoveObject(nObjNum);
245 0 : if( !bUndo )
246 0 : SdrObject::Free(pObj);
247 : }
248 : else
249 : {
250 0 : ImpDelLayerDelObjs(pSubOL, nDelID);
251 : }
252 : }
253 : else
254 : {
255 6 : if(pObj->GetLayer() == nDelID)
256 : {
257 2 : if( bUndo )
258 2 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
259 2 : pPage->RemoveObject(nObjNum);
260 2 : if( !bUndo )
261 0 : SdrObject::Free(pObj);
262 : }
263 : }
264 : }
265 : }
266 4 : bMaPg = false;
267 : }
268 :
269 2 : if( bUndo )
270 : {
271 2 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteLayer(nLayerNum, rLA, *pMod));
272 2 : rLA.RemoveLayer(nLayerNum);
273 2 : EndUndo();
274 : }
275 : else
276 : {
277 0 : delete rLA.RemoveLayer(nLayerNum);
278 : }
279 :
280 2 : pMod->SetChanged();
281 : }
282 2 : }
283 :
284 :
285 :
286 130 : void SdrEditView::EndUndo()
287 : {
288 : // #i13033#
289 : // Comparison changed to 1L since EndUndo() is called later now
290 : // and EndUndo WILL change count to count-1
291 130 : if(1L == pMod->GetUndoBracketLevel())
292 : {
293 104 : ImpBroadcastEdgesOfMarkedNodes();
294 : }
295 :
296 : // #i13033#
297 : // moved to bottom to still have access to UNDOs inside of
298 : // ImpBroadcastEdgesOfMarkedNodes()
299 130 : pMod->EndUndo();
300 130 : }
301 :
302 104 : void SdrEditView::ImpBroadcastEdgesOfMarkedNodes()
303 : {
304 104 : std::vector<SdrObject*>::const_iterator iterPos;
305 104 : const std::vector<SdrObject*>& rAllMarkedObjects = GetTransitiveHullOfMarkedObjects();
306 :
307 : // #i13033#
308 : // New mechanism to search for necessary disconnections for
309 : // changed connectors inside the transitive hull of all at
310 : // the beginning of UNDO selected objects
311 682 : for(sal_uInt32 a(0L); a < rAllMarkedObjects.size(); a++)
312 : {
313 578 : SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, rAllMarkedObjects[a]);
314 :
315 578 : if(pEdge)
316 : {
317 0 : SdrObject* pObj1 = pEdge->GetConnectedNode(false);
318 0 : SdrObject* pObj2 = pEdge->GetConnectedNode(true);
319 :
320 0 : if(pObj1 && !pEdge->CheckNodeConnection(false))
321 : {
322 0 : iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj1);
323 :
324 0 : if (iterPos == rAllMarkedObjects.end())
325 : {
326 0 : if( IsUndoEnabled() )
327 0 : AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pEdge));
328 0 : pEdge->DisconnectFromNode(false);
329 : }
330 : }
331 :
332 0 : if(pObj2 && !pEdge->CheckNodeConnection(true))
333 : {
334 0 : iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj2);
335 :
336 0 : if (iterPos == rAllMarkedObjects.end())
337 : {
338 0 : if( IsUndoEnabled() )
339 0 : AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pEdge));
340 0 : pEdge->DisconnectFromNode(true);
341 : }
342 : }
343 : }
344 : }
345 :
346 104 : const size_t nMarkedEdgeAnz = GetMarkedEdgesOfMarkedNodes().GetMarkCount();
347 :
348 104 : for (size_t i=0; i<nMarkedEdgeAnz; ++i) {
349 0 : SdrMark* pEM = GetMarkedEdgesOfMarkedNodes().GetMark(i);
350 0 : SdrObject* pEdgeTmp=pEM->GetMarkedSdrObj();
351 0 : SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pEdgeTmp);
352 0 : if (pEdge!=NULL) {
353 0 : pEdge->SetEdgeTrackDirty();
354 : }
355 : }
356 104 : }
357 :
358 :
359 : // Possibilities
360 :
361 :
362 8078 : void SdrEditView::MarkListHasChanged()
363 : {
364 8078 : SdrMarkView::MarkListHasChanged();
365 8078 : bPossibilitiesDirty=true;
366 8078 : }
367 :
368 8129 : void SdrEditView::ModelHasChanged()
369 : {
370 8129 : SdrMarkView::ModelHasChanged();
371 8129 : bPossibilitiesDirty=true;
372 8129 : }
373 :
374 0 : bool SdrEditView::IsResizeAllowed(bool bProp) const
375 : {
376 0 : ForcePossibilities();
377 0 : if (bResizeProtect) return false;
378 0 : if (bProp) return bResizePropAllowed;
379 0 : return bResizeFreeAllowed;
380 : }
381 :
382 0 : bool SdrEditView::IsRotateAllowed(bool b90Deg) const
383 : {
384 0 : ForcePossibilities();
385 0 : if (bMoveProtect) return false;
386 0 : if (b90Deg) return bRotate90Allowed;
387 0 : return bRotateFreeAllowed;
388 : }
389 :
390 8442 : bool SdrEditView::IsMirrorAllowed(bool b45Deg, bool b90Deg) const
391 : {
392 8442 : ForcePossibilities();
393 8442 : if (bMoveProtect) return false;
394 8442 : if (b90Deg) return bMirror90Allowed;
395 4221 : if (b45Deg) return bMirror45Allowed;
396 4221 : return bMirrorFreeAllowed && !bMoveProtect;
397 : }
398 :
399 4221 : bool SdrEditView::IsTransparenceAllowed() const
400 : {
401 4221 : ForcePossibilities();
402 4221 : return bTransparenceAllowed;
403 : }
404 :
405 4221 : bool SdrEditView::IsGradientAllowed() const
406 : {
407 4221 : ForcePossibilities();
408 4221 : return bGradientAllowed;
409 : }
410 :
411 0 : bool SdrEditView::IsShearAllowed() const
412 : {
413 0 : ForcePossibilities();
414 0 : if (bResizeProtect) return false;
415 0 : return bShearAllowed;
416 : }
417 :
418 0 : bool SdrEditView::IsEdgeRadiusAllowed() const
419 : {
420 0 : ForcePossibilities();
421 0 : return bEdgeRadiusAllowed;
422 : }
423 :
424 4219 : bool SdrEditView::IsCrookAllowed(bool bNoContortion) const
425 : {
426 : // CrookMode missing here (no rotations allowed when shearing ...)
427 4219 : ForcePossibilities();
428 4219 : if (bNoContortion) {
429 0 : if (!bRotateFreeAllowed) return false;
430 0 : return !bMoveProtect && bMoveAllowed;
431 : } else {
432 4219 : return !bResizeProtect && bContortionPossible;
433 : }
434 : }
435 :
436 0 : bool SdrEditView::IsDistortAllowed(bool bNoContortion) const
437 : {
438 0 : ForcePossibilities();
439 0 : if (bNoContortion) {
440 0 : return false;
441 : } else {
442 0 : return !bResizeProtect && bContortionPossible;
443 : }
444 : }
445 :
446 0 : bool SdrEditView::IsCombinePossible(bool bNoPolyPoly) const
447 : {
448 0 : ForcePossibilities();
449 0 : if (bNoPolyPoly) return bCombineNoPolyPolyPossible;
450 0 : else return bCombinePossible;
451 : }
452 :
453 0 : bool SdrEditView::IsDismantlePossible(bool bMakeLines) const
454 : {
455 0 : ForcePossibilities();
456 0 : if (bMakeLines) return bDismantleMakeLinesPossible;
457 0 : else return bDismantlePossible;
458 : }
459 :
460 3892 : void SdrEditView::CheckPossibilities()
461 : {
462 3892 : if (bSomeObjChgdFlag) bPossibilitiesDirty=true;
463 :
464 3892 : if(bSomeObjChgdFlag)
465 : {
466 : // This call IS necessary to correct the MarkList, in which
467 : // no longer to the model belonging objects still can reside.
468 : // These ones need to be removed.
469 3562 : CheckMarked();
470 : }
471 :
472 3892 : if (bPossibilitiesDirty) {
473 3892 : ImpResetPossibilityFlags();
474 3892 : SortMarkedObjects();
475 3892 : const size_t nMarkAnz=GetMarkedObjectCount();
476 3892 : if (nMarkAnz!=0) {
477 2 : bReverseOrderPossible=nMarkAnz>=2;
478 :
479 2 : size_t nMovableCount=0;
480 2 : bGroupPossible=nMarkAnz>=2;
481 2 : bCombinePossible=nMarkAnz>=2;
482 2 : if (nMarkAnz==1) {
483 : // check bCombinePossible more thoroughly
484 : // still missing ...
485 2 : const SdrObject* pObj=GetMarkedObjectByIndex(0);
486 : //const SdrPathObj* pPath=PTR_CAST(SdrPathObj,pObj);
487 2 : bool bGroup=pObj->GetSubList()!=NULL;
488 2 : bool bHasText=pObj->GetOutlinerParaObject()!=NULL;
489 2 : if (bGroup || bHasText) {
490 0 : bCombinePossible=true;
491 : }
492 : }
493 2 : bCombineNoPolyPolyPossible=bCombinePossible;
494 2 : bDeletePossible=true;
495 : // accept transformations for now
496 2 : bMoveAllowed =true;
497 2 : bResizeFreeAllowed=true;
498 2 : bResizePropAllowed=true;
499 2 : bRotateFreeAllowed=true;
500 2 : bRotate90Allowed =true;
501 2 : bMirrorFreeAllowed=true;
502 2 : bMirror45Allowed =true;
503 2 : bMirror90Allowed =true;
504 2 : bShearAllowed =true;
505 2 : bEdgeRadiusAllowed=false;
506 2 : bContortionPossible=true;
507 2 : bCanConvToContour = true;
508 :
509 : // these ones are only allowed when single object is selected
510 2 : bTransparenceAllowed = (nMarkAnz == 1);
511 2 : bGradientAllowed = (nMarkAnz == 1);
512 2 : if(bGradientAllowed)
513 : {
514 : // gradient depends on fill style
515 2 : const SdrMark* pM = GetSdrMarkByIndex(0);
516 2 : const SdrObject* pObj = pM->GetMarkedSdrObj();
517 :
518 : // may be group object, so get merged ItemSet
519 2 : const SfxItemSet& rSet = pObj->GetMergedItemSet();
520 2 : SfxItemState eState = rSet.GetItemState(XATTR_FILLSTYLE, false);
521 :
522 2 : if(SfxItemState::DONTCARE != eState)
523 : {
524 : // If state is not DONTCARE, test the item
525 2 : drawing::FillStyle eFillStyle = static_cast<const XFillStyleItem&>(rSet.Get(XATTR_FILLSTYLE)).GetValue();
526 :
527 2 : if(eFillStyle != drawing::FillStyle_GRADIENT)
528 : {
529 2 : bGradientAllowed = false;
530 : }
531 : }
532 : }
533 :
534 2 : bool bNoMovRotFound=false;
535 2 : const SdrPageView* pPV0=NULL;
536 :
537 4 : for (size_t nm=0; nm<nMarkAnz; ++nm) {
538 2 : const SdrMark* pM=GetSdrMarkByIndex(nm);
539 2 : const SdrObject* pObj=pM->GetMarkedSdrObj();
540 2 : const SdrPageView* pPV=pM->GetPageView();
541 2 : if (pPV!=pPV0) {
542 2 : if (pPV->IsReadOnly()) bReadOnly=true;
543 2 : pPV0=pPV;
544 : }
545 :
546 2 : SdrObjTransformInfoRec aInfo;
547 2 : pObj->TakeObjInfo(aInfo);
548 2 : bool bMovPrt=pObj->IsMoveProtect();
549 2 : bool bSizPrt=pObj->IsResizeProtect();
550 2 : if (!bMovPrt && aInfo.bMoveAllowed) nMovableCount++; // count MovableObjs
551 2 : if (bMovPrt) bMoveProtect=true;
552 2 : if (bSizPrt) bResizeProtect=true;
553 :
554 : // not allowed when not allowed at one object
555 2 : if(!aInfo.bTransparenceAllowed)
556 0 : bTransparenceAllowed = false;
557 :
558 : // If one of these can't do something, none can
559 2 : if (!aInfo.bMoveAllowed ) bMoveAllowed =false;
560 2 : if (!aInfo.bResizeFreeAllowed) bResizeFreeAllowed=false;
561 2 : if (!aInfo.bResizePropAllowed) bResizePropAllowed=false;
562 2 : if (!aInfo.bRotateFreeAllowed) bRotateFreeAllowed=false;
563 2 : if (!aInfo.bRotate90Allowed ) bRotate90Allowed =false;
564 2 : if (!aInfo.bMirrorFreeAllowed) bMirrorFreeAllowed=false;
565 2 : if (!aInfo.bMirror45Allowed ) bMirror45Allowed =false;
566 2 : if (!aInfo.bMirror90Allowed ) bMirror90Allowed =false;
567 2 : if (!aInfo.bShearAllowed ) bShearAllowed =false;
568 2 : if (aInfo.bEdgeRadiusAllowed) bEdgeRadiusAllowed=true;
569 2 : if (aInfo.bNoContortion ) bContortionPossible=false;
570 : // For Crook with Contortion: all objects have to be
571 : // Movable and Rotatable, except for a maximum of 1 of them
572 2 : if (!bMoreThanOneNoMovRot) {
573 2 : if (!aInfo.bMoveAllowed || !aInfo.bResizeFreeAllowed) {
574 0 : bMoreThanOneNoMovRot=bNoMovRotFound;
575 0 : bNoMovRotFound=true;
576 : }
577 : }
578 :
579 : // if one member cannot be converted, no conversion is possible
580 2 : if(!aInfo.bCanConvToContour)
581 0 : bCanConvToContour = false;
582 :
583 : // Ungroup
584 2 : if (!bUnGroupPossible) bUnGroupPossible=pObj->GetSubList()!=NULL;
585 : // ConvertToCurve: If at least one can be converted, that is fine.
586 2 : if (aInfo.bCanConvToPath ) bCanConvToPath =true;
587 2 : if (aInfo.bCanConvToPoly ) bCanConvToPoly =true;
588 2 : if (aInfo.bCanConvToPathLineToArea) bCanConvToPathLineToArea=true;
589 2 : if (aInfo.bCanConvToPolyLineToArea) bCanConvToPolyLineToArea=true;
590 :
591 : // Combine/Dismantle
592 2 : if(bCombinePossible)
593 : {
594 0 : bCombinePossible = ImpCanConvertForCombine(pObj);
595 0 : bCombineNoPolyPolyPossible = bCombinePossible;
596 : }
597 :
598 2 : if (!bDismantlePossible) bDismantlePossible = ImpCanDismantle(pObj, false);
599 2 : if (!bDismantleMakeLinesPossible) bDismantleMakeLinesPossible = ImpCanDismantle(pObj, true);
600 : // check OrthoDesiredOnMarked
601 2 : if (!bOrthoDesiredOnMarked && !aInfo.bNoOrthoDesired) bOrthoDesiredOnMarked=true;
602 : // check ImportMtf
603 :
604 2 : if (!bImportMtfPossible)
605 : {
606 2 : const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pObj);
607 2 : const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(pObj);
608 :
609 2 : if(pSdrGrafObj && ((pSdrGrafObj->HasGDIMetaFile() && !pSdrGrafObj->IsEPS()) || pSdrGrafObj->isEmbeddedSvg()))
610 : {
611 0 : bImportMtfPossible = true;
612 : }
613 :
614 2 : if(pSdrOle2Obj)
615 : {
616 0 : bImportMtfPossible = pSdrOle2Obj->GetObjRef().is();
617 : }
618 : }
619 : }
620 :
621 2 : bMoreThanOneNotMovable=nMovableCount<nMarkAnz-1;
622 2 : bOneOrMoreMovable=nMovableCount!=0;
623 2 : bGrpEnterPossible=bUnGroupPossible;
624 : }
625 3892 : ImpCheckToTopBtmPossible();
626 3892 : static_cast<SdrPolyEditView*>(this)->ImpCheckPolyPossibilities();
627 3892 : bPossibilitiesDirty=false;
628 :
629 3892 : if (bReadOnly) {
630 0 : bool bMerker1=bGrpEnterPossible;
631 0 : ImpResetPossibilityFlags();
632 0 : bReadOnly=true;
633 0 : bGrpEnterPossible=bMerker1;
634 : }
635 3892 : if (bMoveAllowed) {
636 : // Don't allow moving glued connectors.
637 : // Currently only implemented for single selection.
638 2 : if (nMarkAnz==1) {
639 2 : SdrObject* pObj=GetMarkedObjectByIndex(0);
640 2 : SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pObj);
641 2 : if (pEdge!=NULL) {
642 0 : SdrObject* pNode1=pEdge->GetConnectedNode(true);
643 0 : SdrObject* pNode2=pEdge->GetConnectedNode(false);
644 0 : if (pNode1!=NULL || pNode2!=NULL) bMoveAllowed=false;
645 : }
646 : }
647 : }
648 : }
649 3892 : }
650 :
651 :
652 :
653 0 : void SdrEditView::ForceMarkedObjToAnotherPage()
654 : {
655 0 : bool bFlg=false;
656 0 : for (size_t nm=0; nm<GetMarkedObjectCount(); ++nm) {
657 0 : SdrMark* pM=GetSdrMarkByIndex(nm);
658 0 : SdrObject* pObj=pM->GetMarkedSdrObj();
659 0 : Rectangle aObjRect(pObj->GetCurrentBoundRect());
660 0 : Rectangle aPgRect(pM->GetPageView()->GetPageRect());
661 0 : if (!aObjRect.IsOver(aPgRect)) {
662 0 : bool bFnd=false;
663 0 : SdrPageView* pPV = GetSdrPageView();
664 :
665 0 : if(pPV)
666 : {
667 0 : bFnd = aObjRect.IsOver(pPV->GetPageRect());
668 : }
669 :
670 0 : if(bFnd)
671 : {
672 0 : pM->GetPageView()->GetObjList()->RemoveObject(pObj->GetOrdNum());
673 0 : SdrInsertReason aReason(SDRREASON_VIEWCALL);
674 0 : pPV->GetObjList()->InsertObject(pObj, SAL_MAX_SIZE, &aReason);
675 0 : pM->SetPageView(pPV);
676 0 : InvalidateAllWin(aObjRect);
677 0 : bFlg=true;
678 : }
679 : }
680 : }
681 0 : if (bFlg) {
682 0 : MarkListHasChanged();
683 : }
684 0 : }
685 :
686 14 : void SdrEditView::DeleteMarkedList(const SdrMarkList& rMark)
687 : {
688 14 : if (rMark.GetMarkCount()!=0)
689 : {
690 14 : rMark.ForceSort();
691 :
692 14 : const bool bUndo = IsUndoEnabled();
693 14 : if( bUndo )
694 14 : BegUndo();
695 14 : const size_t nMarkAnz(rMark.GetMarkCount());
696 :
697 14 : if(nMarkAnz)
698 : {
699 14 : std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
700 :
701 14 : if( bUndo )
702 : {
703 70 : for(size_t nm = nMarkAnz; nm > 0;)
704 : {
705 42 : --nm;
706 42 : SdrMark* pM = rMark.GetMark(nm);
707 42 : SdrObject* pObj = pM->GetMarkedSdrObj();
708 :
709 : // extra undo actions for changed connector which now may hold its layed out path (SJ)
710 42 : std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pObj ) );
711 42 : AddUndoActions( vConnectorUndoActions );
712 :
713 42 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
714 42 : }
715 : }
716 :
717 : // make sure, OrderNums are correct:
718 14 : rMark.GetMark(0)->GetMarkedSdrObj()->GetOrdNum();
719 :
720 28 : std::vector< SdrObject* > aRemoved3DObjects;
721 :
722 70 : for(size_t nm = nMarkAnz; nm > 0;)
723 : {
724 42 : --nm;
725 42 : SdrMark* pM = rMark.GetMark(nm);
726 42 : SdrObject* pObj = pM->GetMarkedSdrObj();
727 42 : SdrObjList* pOL = pObj->GetObjList();
728 42 : const size_t nOrdNum(pObj->GetOrdNumDirect());
729 :
730 42 : bool bIs3D = dynamic_cast< E3dObject* >(pObj);
731 : // set up a scene updater if object is a 3d object
732 42 : if(bIs3D)
733 : {
734 0 : aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj));
735 : }
736 :
737 42 : pOL->RemoveObject(nOrdNum);
738 :
739 42 : if( !bUndo )
740 : {
741 0 : if( bIs3D )
742 0 : aRemoved3DObjects.push_back( pObj ); // may be needed later
743 : else
744 0 : SdrObject::Free(pObj);
745 : }
746 : }
747 :
748 : // fire scene updaters
749 28 : while(!aUpdaters.empty())
750 : {
751 0 : delete aUpdaters.back();
752 0 : aUpdaters.pop_back();
753 : }
754 :
755 14 : if( !bUndo )
756 : {
757 : // now delete removed scene objects
758 0 : while(!aRemoved3DObjects.empty())
759 : {
760 0 : SdrObject::Free( aRemoved3DObjects.back() );
761 0 : aRemoved3DObjects.pop_back();
762 : }
763 14 : }
764 : }
765 :
766 14 : if( bUndo )
767 14 : EndUndo();
768 : }
769 14 : }
770 :
771 2 : void SdrEditView::DeleteMarkedObj()
772 : {
773 : // #i110981# return when nothing is to be done at all
774 2 : if(!GetMarkedObjectCount())
775 : {
776 2 : return;
777 : }
778 :
779 : // moved breaking action and undo start outside loop
780 2 : BrkAction();
781 2 : BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_DELETE);
782 :
783 : // remove as long as something is selected. This allows to schedule objects for
784 : // removal for a next run as needed
785 6 : while(GetMarkedObjectCount())
786 : {
787 : // vector to remember the parents which may be empty after object removal
788 2 : std::vector< SdrObject* > aParents;
789 :
790 : {
791 2 : const SdrMarkList& rMarkList = GetMarkedObjectList();
792 2 : const size_t nCount(rMarkList.GetMarkCount());
793 :
794 4 : for(size_t a = 0; a < nCount; ++a)
795 : {
796 : // in the first run, add all found parents, but only once
797 2 : SdrMark* pMark = rMarkList.GetMark(a);
798 2 : SdrObject* pObject = pMark->GetMarkedSdrObj();
799 2 : SdrObject* pParent = pObject->GetObjList()->GetOwnerObj();
800 :
801 2 : if(pParent)
802 : {
803 0 : if(!aParents.empty())
804 : {
805 : std::vector< SdrObject* >::iterator aFindResult =
806 0 : std::find(aParents.begin(), aParents.end(), pParent);
807 :
808 0 : if(aFindResult == aParents.end())
809 : {
810 0 : aParents.push_back(pParent);
811 : }
812 : }
813 : else
814 : {
815 0 : aParents.push_back(pParent);
816 : }
817 : }
818 : }
819 :
820 2 : if(!aParents.empty())
821 : {
822 : // in a 2nd run, remove all objects which may already be scheduled for
823 : // removal. I am not sure if this can happen, but theoretically
824 : // a to-be-removed object may already be the group/3DScene itself
825 0 : for(size_t a = 0; a < nCount; ++a)
826 : {
827 0 : SdrMark* pMark = rMarkList.GetMark(a);
828 0 : SdrObject* pObject = pMark->GetMarkedSdrObj();
829 :
830 : std::vector< SdrObject* >::iterator aFindResult =
831 0 : std::find(aParents.begin(), aParents.end(), pObject);
832 :
833 0 : if(aFindResult != aParents.end())
834 : {
835 0 : aParents.erase(aFindResult);
836 : }
837 : }
838 : }
839 : }
840 :
841 : // original stuff: remove selected objects. Handle clear will
842 : // do something only once
843 2 : DeleteMarkedList(GetMarkedObjectList());
844 2 : GetMarkedObjectListWriteAccess().Clear();
845 2 : aHdl.Clear();
846 :
847 4 : while(aParents.size() && !GetMarkedObjectCount())
848 : {
849 : // iterate over remembered parents
850 0 : SdrObject* pParent = aParents.back();
851 0 : aParents.pop_back();
852 :
853 0 : if(pParent->GetSubList() && 0 == pParent->GetSubList()->GetObjCount())
854 : {
855 : // we detected an empty parent, a candidate to leave group/3DScene
856 : // if entered
857 0 : if(GetSdrPageView()->GetAktGroup()
858 0 : && GetSdrPageView()->GetAktGroup() == pParent)
859 : {
860 0 : GetSdrPageView()->LeaveOneGroup();
861 : }
862 :
863 : // schedule empty parent for removal
864 0 : GetMarkedObjectListWriteAccess().InsertEntry(
865 0 : SdrMark(pParent, GetSdrPageView()));
866 : }
867 : }
868 2 : }
869 :
870 : // end undo and change messaging moved at the end
871 2 : EndUndo();
872 2 : MarkListHasChanged();
873 : }
874 :
875 0 : void SdrEditView::CopyMarkedObj()
876 : {
877 0 : SortMarkedObjects();
878 :
879 0 : SdrMarkList aSourceObjectsForCopy(GetMarkedObjectList());
880 : // The following loop is used instead of MarkList::Merge(), to be
881 : // able to flag the MarkEntries.
882 0 : const size_t nEdgeAnz = GetEdgesOfMarkedNodes().GetMarkCount();
883 0 : for (size_t nEdgeNum=0; nEdgeNum<nEdgeAnz; ++nEdgeNum) {
884 0 : SdrMark aM(*GetEdgesOfMarkedNodes().GetMark(nEdgeNum));
885 0 : aM.SetUser(1);
886 0 : aSourceObjectsForCopy.InsertEntry(aM);
887 0 : }
888 0 : aSourceObjectsForCopy.ForceSort();
889 :
890 : // #i13033#
891 : // New mechanism to re-create the connections of cloned connectors
892 0 : CloneList aCloneList;
893 :
894 0 : const bool bUndo = IsUndoEnabled();
895 :
896 0 : GetMarkedObjectListWriteAccess().Clear();
897 0 : size_t nCloneErrCnt=0;
898 0 : const size_t nMarkAnz=aSourceObjectsForCopy.GetMarkCount();
899 0 : for (size_t nm=0; nm<nMarkAnz; ++nm) {
900 0 : SdrMark* pM=aSourceObjectsForCopy.GetMark(nm);
901 0 : SdrObject* pO=pM->GetMarkedSdrObj()->Clone();
902 0 : if (pO!=NULL) {
903 0 : SdrInsertReason aReason(SDRREASON_VIEWCALL);
904 0 : pM->GetPageView()->GetObjList()->InsertObject(pO, SAL_MAX_SIZE, &aReason);
905 :
906 0 : if( bUndo )
907 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoCopyObject(*pO));
908 :
909 0 : SdrMark aME(*pM);
910 0 : aME.SetMarkedSdrObj(pO);
911 0 : aCloneList.AddPair(pM->GetMarkedSdrObj(), pO);
912 :
913 0 : if (pM->GetUser()==0)
914 : {
915 : // otherwise it is only an Edge we have to copy as well
916 0 : GetMarkedObjectListWriteAccess().InsertEntry(aME);
917 0 : }
918 : } else {
919 0 : nCloneErrCnt++;
920 : }
921 : }
922 :
923 : // #i13033#
924 : // New mechanism to re-create the connections of cloned connectors
925 0 : aCloneList.CopyConnections();
926 :
927 : if(nCloneErrCnt)
928 : {
929 : #ifdef DBG_UTIL
930 : OStringBuffer aStr("SdrEditView::CopyMarkedObj(): Error when cloning ");
931 :
932 : if(nCloneErrCnt == 1)
933 : {
934 : aStr.append("a drawing object.");
935 : }
936 : else
937 : {
938 : aStr.append(static_cast<sal_Int32>(nCloneErrCnt));
939 : aStr.append(" drawing objects.");
940 : }
941 :
942 : aStr.append(" This object's/These objects's connections will not be copied.");
943 : OSL_FAIL(aStr.getStr());
944 : #endif
945 : }
946 0 : MarkListHasChanged();
947 0 : }
948 :
949 :
950 :
951 0 : bool SdrEditView::InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, sal_uIntPtr nOptions)
952 : {
953 0 : if ((nOptions & SDRINSERT_SETDEFLAYER)!=0) {
954 0 : SdrLayerID nLayer=rPV.GetPage()->GetLayerAdmin().GetLayerID(aAktLayer,true);
955 0 : if (nLayer==SDRLAYER_NOTFOUND) nLayer=0;
956 0 : if (rPV.GetLockedLayers().IsSet(nLayer) || !rPV.GetVisibleLayers().IsSet(nLayer)) {
957 0 : SdrObject::Free( pObj ); // Layer locked or invisible
958 0 : return false;
959 : }
960 0 : pObj->NbcSetLayer(nLayer);
961 : }
962 0 : if ((nOptions & SDRINSERT_SETDEFATTR)!=0) {
963 0 : if (pDefaultStyleSheet!=NULL) pObj->NbcSetStyleSheet(pDefaultStyleSheet, false);
964 0 : pObj->SetMergedItemSet(aDefaultAttr);
965 : }
966 0 : if (!pObj->IsInserted()) {
967 0 : SdrInsertReason aReason(SDRREASON_VIEWCALL);
968 0 : if ((nOptions & SDRINSERT_NOBROADCAST)!=0) {
969 0 : rPV.GetObjList()->NbcInsertObject(pObj, SAL_MAX_SIZE, &aReason);
970 : } else {
971 0 : rPV.GetObjList()->InsertObject(pObj, SAL_MAX_SIZE, &aReason);
972 : }
973 : }
974 0 : if( IsUndoEnabled() )
975 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pObj));
976 :
977 0 : if ((nOptions & SDRINSERT_DONTMARK)==0) {
978 0 : if ((nOptions & SDRINSERT_ADDMARK)==0) UnmarkAllObj();
979 0 : MarkObj(pObj,&rPV);
980 : }
981 0 : return true;
982 : }
983 :
984 0 : void SdrEditView::ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, bool bMark)
985 : {
986 0 : if(IsTextEdit())
987 : {
988 : #ifdef DBG_UTIL
989 : if(dynamic_cast< SdrTextObj* >(pOldObj) && static_cast< SdrTextObj* >(pOldObj)->IsTextEditActive())
990 : {
991 : OSL_ENSURE(false, "OldObject is in TextEdit mode, this has to be ended before replacing it usnig SdrEndTextEdit (!)");
992 : }
993 :
994 : if(dynamic_cast< SdrTextObj* >(pNewObj) && static_cast< SdrTextObj* >(pNewObj)->IsTextEditActive())
995 : {
996 : OSL_ENSURE(false, "NewObject is in TextEdit mode, this has to be ended before replacing it usnig SdrEndTextEdit (!)");
997 : }
998 : #endif
999 :
1000 : // #i123468# emergency repair situation, needs to cast up to a class derived from
1001 : // this one; (aw080 has a mechanism for that and the view hierarchy is secured to
1002 : // always be a SdrView)
1003 0 : SdrView *pSdrView = dynamic_cast<SdrView*>(this);
1004 0 : if (pSdrView)
1005 0 : pSdrView->SdrEndTextEdit();
1006 : }
1007 :
1008 0 : SdrObjList* pOL=pOldObj->GetObjList();
1009 0 : const bool bUndo = IsUndoEnabled();
1010 0 : if( bUndo )
1011 0 : AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoReplaceObject(*pOldObj,*pNewObj));
1012 :
1013 0 : if( IsObjMarked( pOldObj ) )
1014 0 : MarkObj( pOldObj, &rPV, true /*unmark!*/ );
1015 :
1016 0 : pOL->ReplaceObject(pNewObj,pOldObj->GetOrdNum());
1017 :
1018 0 : if( !bUndo )
1019 0 : SdrObject::Free( pOldObj );
1020 :
1021 0 : if (bMark) MarkObj(pNewObj,&rPV);
1022 0 : }
1023 :
1024 :
1025 :
1026 3066 : bool SdrEditView::IsUndoEnabled() const
1027 : {
1028 3066 : return pMod->IsUndoEnabled();
1029 651 : }
1030 :
1031 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
