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