LibreOffice Module svx (master)  1
svdedtv1.cxx
Go to the documentation of this file.
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 
22 #include <editeng/eeitem.hxx>
23 #include <math.h>
24 #include <svl/itemiter.hxx>
25 #include <svl/whiter.hxx>
26 #include <tools/bigint.hxx>
27 #include <vcl/svapp.hxx>
28 #include <vcl/weld.hxx>
29 
30 #include <getallcharpropids.hxx>
31 #include <svx/dialmgr.hxx>
32 #include <svx/svditer.hxx>
33 #include <svx/strings.hrc>
34 
35 #include <AffineMatrixItem.hxx>
36 #include <svx/e3dsceneupdater.hxx>
37 #include <svx/obj3d.hxx>
38 #include <svx/rectenum.hxx>
40 #include <svx/sdooitm.hxx>
41 #include <svx/sderitm.hxx>
42 #include <svx/sdtagitm.hxx>
43 #include <svx/svdedtv.hxx>
44 #include <svx/svdetc.hxx>
45 #include <svx/svdopath.hxx>
46 #include <svx/svdpage.hxx>
47 #include <svx/svdpagv.hxx>
48 #include <svx/svdtrans.hxx>
49 #include <svx/svdundo.hxx>
50 #include <svx/svxids.hrc>
51 #include <sxallitm.hxx>
52 #include <sxmovitm.hxx>
53 #include <sxreaitm.hxx>
54 #include <sxreoitm.hxx>
55 #include <sxroaitm.hxx>
56 #include <sxrooitm.hxx>
57 #include <sxsalitm.hxx>
58 #include <sxsoitm.hxx>
59 #include <sxtraitm.hxx>
60 #include <svx/xlnedwit.hxx>
61 #include <svx/xlnstwit.hxx>
62 #include <svx/xlnwtit.hxx>
63 #include <svx/xlnclit.hxx>
64 #include <svx/xflclit.hxx>
65 #include <svx/xlntrit.hxx>
66 #include <svx/xfltrit.hxx>
67 #include <svx/sdprcitm.hxx>
68 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
69 #include <rtl/ustring.hxx>
70 #include <sfx2/viewsh.hxx>
71 #include <comphelper/lok.hxx>
72 
73 // EditView
74 
75 
77 {
78  DBG_ASSERT(!rRect.IsEmpty(),"SetMarkedObjRect() with an empty Rect does not make sense.");
79  if (rRect.IsEmpty()) return;
80  const size_t nCount=GetMarkedObjectCount();
81  if (nCount==0) return;
83  DBG_ASSERT(!aR0.IsEmpty(),"SetMarkedObjRect(): GetMarkedObjRect() is empty.");
84  if (aR0.IsEmpty()) return;
85  long x0=aR0.Left();
86  long y0=aR0.Top();
87  long w0=aR0.Right()-x0;
88  long h0=aR0.Bottom()-y0;
89  long x1=rRect.Left();
90  long y1=rRect.Top();
91  long w1=rRect.Right()-x1;
92  long h1=rRect.Bottom()-y1;
93 
94  const bool bUndo = IsUndoEnabled();
95  if( bUndo )
96  {
98  BegUndo(ImpGetDescriptionString(STR_EditPosSize));
99  }
100 
101  for (size_t nm=0; nm<nCount; ++nm)
102  {
103  SdrMark* pM=GetSdrMarkByIndex(nm);
104  SdrObject* pO=pM->GetMarkedSdrObj();
105  if( bUndo )
106  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
107 
108  tools::Rectangle aR1(pO->GetSnapRect());
109  if (!aR1.IsEmpty())
110  {
111  if (aR1==aR0)
112  {
113  aR1=rRect;
114  }
115  else
116  { // transform aR1 to aR0 after rRect
117  aR1.Move(-x0,-y0);
118  BigInt l(aR1.Left());
119  BigInt r(aR1.Right());
120  BigInt t(aR1.Top());
121  BigInt b(aR1.Bottom());
122  if (w0!=0) {
123  l*=w1; l/=w0;
124  r*=w1; r/=w0;
125  } else {
126  l=0; r=w1;
127  }
128  if (h0!=0) {
129  t*=h1; t/=h0;
130  b*=h1; b/=h0;
131  } else {
132  t=0; b=h1;
133  }
134  aR1.SetLeft(long(l) );
135  aR1.SetRight(long(r) );
136  aR1.SetTop(long(t) );
137  aR1.SetBottom(long(b) );
138  aR1.Move(x1,y1);
139  }
140  pO->SetSnapRect(aR1);
141  } else {
142  OSL_FAIL("SetMarkedObjRect(): pObj->GetSnapRect() returns empty Rect");
143  }
144  }
145  if( bUndo )
146  EndUndo();
147 }
148 
149 std::vector< std::unique_ptr<SdrUndoAction> > SdrEditView::CreateConnectorUndo( SdrObject& rO )
150 {
151  std::vector< std::unique_ptr<SdrUndoAction> > vUndoActions;
152 
153  if ( rO.GetBroadcaster() )
154  {
155  const SdrPage* pPage = rO.getSdrPageFromSdrObject();
156  if ( pPage )
157  {
159  while( aIter.IsMore() )
160  {
161  SdrObject* pPartObj = aIter.Next();
162  if ( dynamic_cast<const SdrEdgeObj*>( pPartObj) != nullptr )
163  {
164  if ( ( pPartObj->GetConnectedNode( false ) == &rO ) ||
165  ( pPartObj->GetConnectedNode( true ) == &rO ) )
166  {
167  vUndoActions.push_back( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject( *pPartObj ) );
168  }
169  }
170  }
171  }
172  }
173  return vUndoActions;
174 }
175 
176 void SdrEditView::AddUndoActions( std::vector< std::unique_ptr<SdrUndoAction> > aUndoActions )
177 {
178  for (auto & rAction : aUndoActions)
179  AddUndo( std::move(rAction) );
180 }
181 
182 void SdrEditView::MoveMarkedObj(const Size& rSiz, bool bCopy)
183 {
184  const bool bUndo = IsUndoEnabled();
185 
186  if( bUndo )
187  {
189  OUString aStr(SvxResId(STR_EditMove));
190  if (bCopy)
191  aStr += SvxResId(STR_EditWithCopy);
192  // needs its own UndoGroup because of its parameters
194  }
195 
196  if (bCopy)
197  CopyMarkedObj();
198 
199  const size_t nMarkCount=GetMarkedObjectCount();
200  for (size_t nm=0; nm<nMarkCount; ++nm)
201  {
202  SdrMark* pM=GetSdrMarkByIndex(nm);
203  SdrObject* pO=pM->GetMarkedSdrObj();
204  if( bUndo )
205  {
207  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pO,rSiz));
208  }
209  pO->Move(rSiz);
210  }
211 
212  if( bUndo )
213  EndUndo();
214 }
215 
216 void SdrEditView::ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy)
217 {
218  const bool bUndo = IsUndoEnabled();
219  if( bUndo )
220  {
222  OUString aStr {ImpGetDescriptionString(STR_EditResize)};
223  if (bCopy)
224  aStr+=SvxResId(STR_EditWithCopy);
225  BegUndo(aStr);
226  }
227 
228  if (bCopy)
229  CopyMarkedObj();
230 
231  const size_t nMarkCount=GetMarkedObjectCount();
232  for (size_t nm=0; nm<nMarkCount; ++nm)
233  {
234  SdrMark* pM=GetSdrMarkByIndex(nm);
235  SdrObject* pO=pM->GetMarkedSdrObj();
236  if( bUndo )
237  {
239  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
240  }
241  pO->Resize(rRef,xFact,yFact);
242  }
243 
244  if( bUndo )
245  EndUndo();
246 }
247 void SdrEditView::ResizeMultMarkedObj(const Point& rRef,
248  const Fraction& xFact,
249  const Fraction& yFact,
250  const bool bWdh,
251  const bool bHgt)
252 {
253  const bool bUndo = IsUndoEnabled();
254  if( bUndo )
255  {
257  BegUndo(ImpGetDescriptionString(STR_EditResize));
258  }
259 
260  const size_t nMarkCount=GetMarkedObjectCount();
261  for (size_t nm=0; nm<nMarkCount; ++nm)
262  {
263  SdrMark* pM=GetSdrMarkByIndex(nm);
264  SdrObject* pO=pM->GetMarkedSdrObj();
265  if( bUndo )
266  {
268  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
269  }
270 
271  Fraction aFrac(1,1);
272  if (bWdh && bHgt)
273  pO->Resize(rRef, xFact, yFact);
274  else if (bWdh)
275  pO->Resize(rRef, xFact, aFrac);
276  else if (bHgt)
277  pO->Resize(rRef, aFrac, yFact);
278  }
279  if( bUndo )
280  EndUndo();
281 }
282 
284 {
285  long nRetval(0);
286 
288  {
289  SdrMark* pM = GetSdrMarkByIndex(0);
290  SdrObject* pO = pM->GetMarkedSdrObj();
291 
292  nRetval = pO->GetRotateAngle();
293  }
294 
295  return nRetval;
296  //sal_Bool b1st=true;
297  //sal_Bool bOk=true;
298  //long nAngle=0;
299  //sal_uIntPtr nMarkCount=GetMarkedObjectCount();
300  //for (sal_uIntPtr nm=0; nm<nMarkCount && bOk; nm++) {
301  // SdrMark* pM=GetSdrMarkByIndex(nm);
302  // SdrObject* pO=pM->GetMarkedSdrObj();
303  // long nAngle2=pO->GetRotateAngle();
304  // if (b1st) nAngle=nAngle2;
305  // else if (nAngle2!=nAngle) bOk=false;
306  // b1st=false;
307  //}
308  //if (!bOk) nAngle=0;
309  //return nAngle;
310 }
311 
312 void SdrEditView::RotateMarkedObj(const Point& rRef, long nAngle, bool bCopy)
313 {
314  const bool bUndo = IsUndoEnabled();
315  if( bUndo )
316  {
318  OUString aStr {ImpGetDescriptionString(STR_EditRotate)};
319  if (bCopy) aStr+=SvxResId(STR_EditWithCopy);
320  BegUndo(aStr);
321  }
322 
323  if (bCopy)
324  CopyMarkedObj();
325 
326  double nSin = sin(nAngle * F_PI18000);
327  double nCos = cos(nAngle * F_PI18000);
328  const size_t nMarkCount(GetMarkedObjectCount());
329 
330  if(nMarkCount)
331  {
332  std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
333 
334  for(size_t nm = 0; nm < nMarkCount; ++nm)
335  {
336  SdrMark* pM = GetSdrMarkByIndex(nm);
337  SdrObject* pO = pM->GetMarkedSdrObj();
338 
339  if( bUndo )
340  {
341  // extra undo actions for changed connector which now may hold its laid out path (SJ)
343 
344  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
345  }
346 
347  // set up a scene updater if object is a 3d object
348  if(dynamic_cast< E3dObject* >(pO))
349  {
350  aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
351  }
352 
353  pO->Rotate(rRef,nAngle,nSin,nCos);
354  }
355 
356  // fire scene updaters
357  while(!aUpdaters.empty())
358  {
359  delete aUpdaters.back();
360  aUpdaters.pop_back();
361  }
362  }
363 
364  if( bUndo )
365  EndUndo();
366 }
367 
368 void SdrEditView::MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy)
369 {
370  const bool bUndo = IsUndoEnabled();
371 
372  if( bUndo )
373  {
375  OUString aStr;
376  Point aDif(rRef2-rRef1);
377  if (aDif.X()==0)
378  aStr = ImpGetDescriptionString(STR_EditMirrorHori);
379  else if (aDif.Y()==0)
380  aStr = ImpGetDescriptionString(STR_EditMirrorVert);
381  else if (std::abs(aDif.X()) == std::abs(aDif.Y()))
382  aStr = ImpGetDescriptionString(STR_EditMirrorDiag);
383  else
384  aStr = ImpGetDescriptionString(STR_EditMirrorFree);
385  if (bCopy) aStr+=SvxResId(STR_EditWithCopy);
386  BegUndo(aStr);
387  }
388 
389  if (bCopy)
390  CopyMarkedObj();
391 
392  const size_t nMarkCount(GetMarkedObjectCount());
393 
394  if(nMarkCount)
395  {
396  std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
397 
398  for(size_t nm = 0; nm < nMarkCount; ++nm)
399  {
400  SdrMark* pM = GetSdrMarkByIndex(nm);
401  SdrObject* pO = pM->GetMarkedSdrObj();
402 
403  if( bUndo )
404  {
405  // extra undo actions for changed connector which now may hold its laid out path (SJ)
407 
408  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
409  }
410 
411  // set up a scene updater if object is a 3d object
412  if(dynamic_cast< E3dObject* >(pO))
413  {
414  aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
415  }
416 
417  pO->Mirror(rRef1,rRef2);
418  }
419 
420  // fire scene updaters
421  while(!aUpdaters.empty())
422  {
423  delete aUpdaters.back();
424  aUpdaters.pop_back();
425  }
426  }
427 
428  if( bUndo )
429  EndUndo();
430 }
431 
433 {
435  Point aPt2(aCenter);
436  aPt2.AdjustY( 1 );
437  MirrorMarkedObj(aCenter,aPt2);
438 }
439 
441 {
443  Point aPt2(aCenter);
444  aPt2.AdjustX( 1 );
445  MirrorMarkedObj(aCenter,aPt2);
446 }
447 
449 {
450  bool b1st=true;
451  bool bOk=true;
452  long nAngle=0;
453  const size_t nMarkCount=GetMarkedObjectCount();
454  for (size_t nm=0; nm<nMarkCount && bOk; ++nm) {
455  SdrMark* pM=GetSdrMarkByIndex(nm);
456  SdrObject* pO=pM->GetMarkedSdrObj();
457  long nAngle2=pO->GetShearAngle();
458  if (b1st) nAngle=nAngle2;
459  else if (nAngle2!=nAngle) bOk=false;
460  b1st=false;
461  }
462  if (nAngle>SDRMAXSHEAR) nAngle=SDRMAXSHEAR;
463  if (nAngle<-SDRMAXSHEAR) nAngle=-SDRMAXSHEAR;
464  if (!bOk) nAngle=0;
465  return nAngle;
466 }
467 
468 void SdrEditView::ShearMarkedObj(const Point& rRef, long nAngle, bool bVShear, bool bCopy)
469 {
470  const bool bUndo = IsUndoEnabled();
471 
472  if( bUndo )
473  {
475  OUString aStr {ImpGetDescriptionString(STR_EditShear)};
476  if (bCopy)
477  aStr+=SvxResId(STR_EditWithCopy);
478  BegUndo(aStr);
479  }
480 
481  if (bCopy)
482  CopyMarkedObj();
483 
484  double nTan = tan(nAngle * F_PI18000);
485  const size_t nMarkCount=GetMarkedObjectCount();
486  for (size_t nm=0; nm<nMarkCount; ++nm)
487  {
488  SdrMark* pM=GetSdrMarkByIndex(nm);
489  SdrObject* pO=pM->GetMarkedSdrObj();
490  if( bUndo )
491  {
493  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
494  }
495  pO->Shear(rRef,nAngle,nTan,bVShear);
496  }
497 
498  if( bUndo )
499  EndUndo();
500 }
501 
502 void SdrEditView::ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad,
503  SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bRotate, const tools::Rectangle& rMarkRect)
504 {
505  SdrPathObj* pPath=dynamic_cast<SdrPathObj*>( pO );
506  bool bDone = false;
507 
508  if(pPath!=nullptr && !bNoContortion)
509  {
510  XPolyPolygon aXPP(pPath->GetPathPoly());
511  switch (eMode) {
512  case SdrCrookMode::Rotate : CrookRotatePoly (aXPP,rRef,rRad,bVertical); break;
513  case SdrCrookMode::Slant : CrookSlantPoly (aXPP,rRef,rRad,bVertical); break;
514  case SdrCrookMode::Stretch: CrookStretchPoly(aXPP,rRef,rRad,bVertical,rMarkRect); break;
515  } // switch
516  pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
517  bDone = true;
518  }
519 
520  if(!bDone && !pPath && pO->IsPolyObj() && 0 != pO->GetPointCount())
521  {
522  // for PolyObj's, but NOT for SdrPathObj's, e.g. the measurement object
523  sal_uInt32 nPointCount(pO->GetPointCount());
524  XPolygon aXP(static_cast<sal_uInt16>(nPointCount));
525  sal_uInt32 nPtNum;
526 
527  for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
528  {
529  Point aPt(pO->GetPoint(nPtNum));
530  aXP[static_cast<sal_uInt16>(nPtNum)]=aPt;
531  }
532 
533  switch (eMode)
534  {
535  case SdrCrookMode::Rotate : CrookRotatePoly (aXP,rRef,rRad,bVertical); break;
536  case SdrCrookMode::Slant : CrookSlantPoly (aXP,rRef,rRad,bVertical); break;
537  case SdrCrookMode::Stretch: CrookStretchPoly(aXP,rRef,rRad,bVertical,rMarkRect); break;
538  }
539 
540  for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
541  {
542  // broadcasting could be optimized here, but for the
543  // current two points of the measurement object, it's fine
544  pO->SetPoint(aXP[static_cast<sal_uInt16>(nPtNum)],nPtNum);
545  }
546 
547  bDone = true;
548  }
549 
550  if(!bDone)
551  {
552  // for all others or if bNoContortion
553  Point aCtr0(pO->GetSnapRect().Center());
554  Point aCtr1(aCtr0);
555  bool bRotOk(false);
556  double nSin(0.0), nCos(1.0);
557  double nAngle(0.0);
558 
559  if(0 != rRad.X() && 0 != rRad.Y())
560  {
561  bRotOk = bRotate;
562 
563  switch (eMode)
564  {
565  case SdrCrookMode::Rotate : nAngle=CrookRotateXPoint (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical); bRotOk=bRotate; break;
566  case SdrCrookMode::Slant : nAngle=CrookSlantXPoint (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical); break;
567  case SdrCrookMode::Stretch: nAngle=CrookStretchXPoint(aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical,rMarkRect); break;
568  }
569  }
570 
571  aCtr1 -= aCtr0;
572 
573  if(bRotOk)
574  pO->Rotate(aCtr0, FRound(nAngle / F_PI18000), nSin, nCos);
575 
576  pO->Move(Size(aCtr1.X(),aCtr1.Y()));
577  }
578 }
579 
580 void SdrEditView::CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode,
581  bool bVertical, bool bNoContortion, bool bCopy)
582 {
584  const bool bUndo = IsUndoEnabled();
585 
586  bool bRotate=bNoContortion && eMode==SdrCrookMode::Rotate && IsRotateAllowed();
587 
588  if( bUndo )
589  {
591  OUString aStr {ImpGetDescriptionString(bNoContortion ? STR_EditCrook : STR_EditCrookContortion)};
592  if (bCopy)
593  aStr+=SvxResId(STR_EditWithCopy);
594  BegUndo(aStr);
595  }
596 
597  if (bCopy)
598  CopyMarkedObj();
599 
600  const size_t nMarkCount=GetMarkedObjectCount();
601  for (size_t nm=0; nm<nMarkCount; ++nm)
602  {
603  SdrMark* pM=GetSdrMarkByIndex(nm);
604  SdrObject* pO=pM->GetMarkedSdrObj();
605  if( bUndo )
606  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
607 
608  const SdrObjList* pOL=pO->GetSubList();
609  if (bNoContortion || pOL==nullptr) {
610  ImpCrookObj(pO,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
611  } else {
613  while (aIter.IsMore()) {
614  SdrObject* pO1=aIter.Next();
615  ImpCrookObj(pO1,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
616  }
617  }
618  }
619 
620  if( bUndo )
621  EndUndo();
622 }
623 
624 void SdrEditView::ImpDistortObj(SdrObject* pO, const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion)
625 {
626  SdrPathObj* pPath = dynamic_cast<SdrPathObj*>( pO );
627 
628  if(!bNoContortion && pPath)
629  {
630  XPolyPolygon aXPP(pPath->GetPathPoly());
631  aXPP.Distort(rRef, rDistortedRect);
632  pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
633  }
634  else if(pO->IsPolyObj())
635  {
636  // e. g. for the measurement object
637  sal_uInt32 nPointCount(pO->GetPointCount());
638  XPolygon aXP(static_cast<sal_uInt16>(nPointCount));
639  sal_uInt32 nPtNum;
640 
641  for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
642  {
643  Point aPt(pO->GetPoint(nPtNum));
644  aXP[static_cast<sal_uInt16>(nPtNum)]=aPt;
645  }
646 
647  aXP.Distort(rRef, rDistortedRect);
648 
649  for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
650  {
651  // broadcasting could be optimized here, but for the
652  // current two points of the measurement object it's fine
653  pO->SetPoint(aXP[static_cast<sal_uInt16>(nPtNum)],nPtNum);
654  }
655  }
656 }
657 
658 void SdrEditView::DistortMarkedObj(const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion, bool bCopy)
659 {
660  const bool bUndo = IsUndoEnabled();
661 
662  if( bUndo )
663  {
665  OUString aStr {ImpGetDescriptionString(STR_EditDistort)};
666  if (bCopy)
667  aStr+=SvxResId(STR_EditWithCopy);
668  BegUndo(aStr);
669  }
670 
671  if (bCopy)
672  CopyMarkedObj();
673 
674  const size_t nMarkCount=GetMarkedObjectCount();
675  for (size_t nm=0; nm<nMarkCount; ++nm)
676  {
677  SdrMark* pM=GetSdrMarkByIndex(nm);
678  SdrObject* pO=pM->GetMarkedSdrObj();
679  if( bUndo )
680  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
681 
682  tools::Rectangle aRefRect(rRef);
683  const SdrObjList* pOL=pO->GetSubList();
684  if (bNoContortion || pOL==nullptr) {
685  ImpDistortObj(pO,aRefRect,rDistortedRect,bNoContortion);
686  } else {
688  while (aIter.IsMore()) {
689  SdrObject* pO1=aIter.Next();
690  ImpDistortObj(pO1,aRefRect,rDistortedRect,bNoContortion);
691  }
692  }
693  }
694  if( bUndo )
695  EndUndo();
696 }
697 
698 
700 {
701  // bReplaceAll has no effect here
702  tools::Rectangle aAllSnapRect(GetMarkedObjRect());
703  const SfxPoolItem *pPoolItem=nullptr;
704  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1X,true,&pPoolItem)==SfxItemState::SET) {
705  long n=static_cast<const SdrTransformRef1XItem*>(pPoolItem)->GetValue();
706  SetRef1(Point(n,GetRef1().Y()));
707  }
708  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1Y,true,&pPoolItem)==SfxItemState::SET) {
709  long n=static_cast<const SdrTransformRef1YItem*>(pPoolItem)->GetValue();
710  SetRef1(Point(GetRef1().X(),n));
711  }
712  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2X,true,&pPoolItem)==SfxItemState::SET) {
713  long n=static_cast<const SdrTransformRef2XItem*>(pPoolItem)->GetValue();
714  SetRef2(Point(n,GetRef2().Y()));
715  }
716  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2Y,true,&pPoolItem)==SfxItemState::SET) {
717  long n=static_cast<const SdrTransformRef2YItem*>(pPoolItem)->GetValue();
718  SetRef2(Point(GetRef2().X(),n));
719  }
720  long nAllPosX=0; bool bAllPosX=false;
721  long nAllPosY=0; bool bAllPosY=false;
722  long nAllWdt=0; bool bAllWdt=false;
723  long nAllHgt=0; bool bAllHgt=false;
724  bool bDoIt=false;
725  if (rAttr.GetItemState(SDRATTR_ALLPOSITIONX,true,&pPoolItem)==SfxItemState::SET) {
726  nAllPosX=static_cast<const SdrAllPositionXItem*>(pPoolItem)->GetValue();
727  bAllPosX=true; bDoIt=true;
728  }
729  if (rAttr.GetItemState(SDRATTR_ALLPOSITIONY,true,&pPoolItem)==SfxItemState::SET) {
730  nAllPosY=static_cast<const SdrAllPositionYItem*>(pPoolItem)->GetValue();
731  bAllPosY=true; bDoIt=true;
732  }
733  if (rAttr.GetItemState(SDRATTR_ALLSIZEWIDTH,true,&pPoolItem)==SfxItemState::SET) {
734  nAllWdt=static_cast<const SdrAllSizeWidthItem*>(pPoolItem)->GetValue();
735  bAllWdt=true; bDoIt=true;
736  }
737  if (rAttr.GetItemState(SDRATTR_ALLSIZEHEIGHT,true,&pPoolItem)==SfxItemState::SET) {
738  nAllHgt=static_cast<const SdrAllSizeHeightItem*>(pPoolItem)->GetValue();
739  bAllHgt=true; bDoIt=true;
740  }
741  if (bDoIt) {
742  tools::Rectangle aRect(aAllSnapRect); // TODO: change this for PolyPt's and GluePt's!!!
743  if (bAllPosX) aRect.Move(nAllPosX-aRect.Left(),0);
744  if (bAllPosY) aRect.Move(0,nAllPosY-aRect.Top());
745  if (bAllWdt) aRect.SetRight(aAllSnapRect.Left()+nAllWdt );
746  if (bAllHgt) aRect.SetBottom(aAllSnapRect.Top()+nAllHgt );
747  SetMarkedObjRect(aRect);
748  }
749  if (rAttr.GetItemState(SDRATTR_RESIZEXALL,true,&pPoolItem)==SfxItemState::SET) {
750  Fraction aXFact=static_cast<const SdrResizeXAllItem*>(pPoolItem)->GetValue();
751  ResizeMarkedObj(aAllSnapRect.TopLeft(),aXFact,Fraction(1,1));
752  }
753  if (rAttr.GetItemState(SDRATTR_RESIZEYALL,true,&pPoolItem)==SfxItemState::SET) {
754  Fraction aYFact=static_cast<const SdrResizeYAllItem*>(pPoolItem)->GetValue();
755  ResizeMarkedObj(aAllSnapRect.TopLeft(),Fraction(1,1),aYFact);
756  }
757  if (rAttr.GetItemState(SDRATTR_ROTATEALL,true,&pPoolItem)==SfxItemState::SET) {
758  long nAngle=static_cast<const SdrRotateAllItem*>(pPoolItem)->GetValue();
759  RotateMarkedObj(aAllSnapRect.Center(),nAngle);
760  }
761  if (rAttr.GetItemState(SDRATTR_HORZSHEARALL,true,&pPoolItem)==SfxItemState::SET) {
762  long nAngle=static_cast<const SdrHorzShearAllItem*>(pPoolItem)->GetValue();
763  ShearMarkedObj(aAllSnapRect.Center(),nAngle);
764  }
765  if (rAttr.GetItemState(SDRATTR_VERTSHEARALL,true,&pPoolItem)==SfxItemState::SET) {
766  long nAngle=static_cast<const SdrVertShearAllItem*>(pPoolItem)->GetValue();
767  ShearMarkedObj(aAllSnapRect.Center(),nAngle,true);
768  }
769 
770  const bool bUndo = IsUndoEnabled();
771 
772  // TODO: check if WhichRange is necessary.
773  const size_t nMarkCount=GetMarkedObjectCount();
774  for (size_t nm=0; nm<nMarkCount; ++nm)
775  {
776  const SdrMark* pM=GetSdrMarkByIndex(nm);
777  SdrObject* pObj=pM->GetMarkedSdrObj();
778  if( bUndo )
779  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
780 
781  pObj->ApplyNotPersistAttr(rAttr);
782  }
783 }
784 
786 {
787  // TODO: Take into account the origin and PvPos.
788  tools::Rectangle aAllSnapRect(GetMarkedObjRect()); // TODO: change this for PolyPt's and GluePt's!!!
789  long nAllSnapPosX=aAllSnapRect.Left();
790  long nAllSnapPosY=aAllSnapRect.Top();
791  long nAllSnapWdt=aAllSnapRect.GetWidth()-1;
792  long nAllSnapHgt=aAllSnapRect.GetHeight()-1;
793  // TODO: could go into CheckPossibilities
794  bool bMovProtect = false, bMovProtectDC = false;
795  bool bSizProtect = false, bSizProtectDC = false;
796  bool bPrintable = true, bPrintableDC = false;
797  bool bVisible = true, bVisibleDC = false;
798  SdrLayerID nLayerId(0);
799  bool bLayerDC=false;
800  long nSnapPosX=0; bool bSnapPosXDC=false;
801  long nSnapPosY=0; bool bSnapPosYDC=false;
802  long nSnapWdt=0; bool bSnapWdtDC=false;
803  long nSnapHgt=0; bool bSnapHgtDC=false;
804  long nLogicWdt=0; bool bLogicWdtDC=false,bLogicWdtDiff=false;
805  long nLogicHgt=0; bool bLogicHgtDC=false,bLogicHgtDiff=false;
806  long nRotAngle=0; bool bRotAngleDC=false;
807  long nShrAngle=0; bool bShrAngleDC=false;
808  tools::Rectangle aSnapRect;
809  tools::Rectangle aLogicRect;
810  const size_t nMarkCount=GetMarkedObjectCount();
811  for (size_t nm=0; nm<nMarkCount; ++nm) {
812  const SdrMark* pM=GetSdrMarkByIndex(nm);
813  const SdrObject* pObj=pM->GetMarkedSdrObj();
814  if (nm==0) {
815  nLayerId=pObj->GetLayer();
816  bMovProtect=pObj->IsMoveProtect();
817  bSizProtect=pObj->IsResizeProtect();
818  bPrintable =pObj->IsPrintable();
819  bVisible = pObj->IsVisible();
820  tools::Rectangle aSnapRect2(pObj->GetSnapRect());
821  tools::Rectangle aLogicRect2(pObj->GetLogicRect());
822  nSnapPosX=aSnapRect2.Left();
823  nSnapPosY=aSnapRect2.Top();
824  nSnapWdt=aSnapRect2.GetWidth()-1;
825  nSnapHgt=aSnapRect2.GetHeight()-1;
826  nLogicWdt=aLogicRect2.GetWidth()-1;
827  nLogicHgt=aLogicRect2.GetHeight()-1;
828  bLogicWdtDiff=nLogicWdt!=nSnapWdt;
829  bLogicHgtDiff=nLogicHgt!=nSnapHgt;
830  nRotAngle=pObj->GetRotateAngle();
831  nShrAngle=pObj->GetShearAngle();
832  } else {
833  if (!bLayerDC && nLayerId !=pObj->GetLayer()) bLayerDC = true;
834  if (!bMovProtectDC && bMovProtect!=pObj->IsMoveProtect()) bMovProtectDC = true;
835  if (!bSizProtectDC && bSizProtect!=pObj->IsResizeProtect()) bSizProtectDC = true;
836  if (!bPrintableDC && bPrintable !=pObj->IsPrintable()) bPrintableDC = true;
837  if (!bVisibleDC && bVisible !=pObj->IsVisible()) bVisibleDC=true;
838  if (!bRotAngleDC && nRotAngle !=pObj->GetRotateAngle()) bRotAngleDC=true;
839  if (!bShrAngleDC && nShrAngle !=pObj->GetShearAngle()) bShrAngleDC=true;
840  if (!bSnapWdtDC || !bSnapHgtDC || !bSnapPosXDC || !bSnapPosYDC || !bLogicWdtDiff || !bLogicHgtDiff) {
841  aSnapRect=pObj->GetSnapRect();
842  if (nSnapPosX!=aSnapRect.Left()) bSnapPosXDC=true;
843  if (nSnapPosY!=aSnapRect.Top()) bSnapPosYDC=true;
844  if (nSnapWdt!=aSnapRect.GetWidth()-1) bSnapWdtDC=true;
845  if (nSnapHgt!=aSnapRect.GetHeight()-1) bSnapHgtDC=true;
846  }
847  if (!bLogicWdtDC || !bLogicHgtDC || !bLogicWdtDiff || !bLogicHgtDiff) {
848  aLogicRect=pObj->GetLogicRect();
849  if (nLogicWdt!=aLogicRect.GetWidth()-1) bLogicWdtDC=true;
850  if (nLogicHgt!=aLogicRect.GetHeight()-1) bLogicHgtDC=true;
851  if (!bLogicWdtDiff && aSnapRect.GetWidth()!=aLogicRect.GetWidth()) bLogicWdtDiff=true;
852  if (!bLogicHgtDiff && aSnapRect.GetHeight()!=aLogicRect.GetHeight()) bLogicHgtDiff=true;
853  }
854  }
855  }
856 
857  if (bSnapPosXDC || nAllSnapPosX!=nSnapPosX) rAttr.Put(SdrAllPositionXItem(nAllSnapPosX));
858  if (bSnapPosYDC || nAllSnapPosY!=nSnapPosY) rAttr.Put(SdrAllPositionYItem(nAllSnapPosY));
859  if (bSnapWdtDC || nAllSnapWdt !=nSnapWdt ) rAttr.Put(SdrAllSizeWidthItem(nAllSnapWdt));
860  if (bSnapHgtDC || nAllSnapHgt !=nSnapHgt ) rAttr.Put(SdrAllSizeHeightItem(nAllSnapHgt));
861 
862  // items for pure transformations
863  rAttr.Put(SdrMoveXItem());
864  rAttr.Put(SdrMoveYItem());
865  rAttr.Put(SdrResizeXOneItem());
866  rAttr.Put(SdrResizeYOneItem());
867  rAttr.Put(SdrRotateOneItem());
868  rAttr.Put(SdrHorzShearOneItem());
869  rAttr.Put(SdrVertShearOneItem());
870 
871  if (nMarkCount>1) {
872  rAttr.Put(SdrResizeXAllItem());
873  rAttr.Put(SdrResizeYAllItem());
874  rAttr.Put(SdrRotateAllItem());
875  rAttr.Put(SdrHorzShearAllItem());
876  rAttr.Put(SdrVertShearAllItem());
877  }
878 
880  {
881  rAttr.Put(SdrTransformRef1XItem(GetRef1().X()));
882  rAttr.Put(SdrTransformRef1YItem(GetRef1().Y()));
883  }
884 
886  {
887  rAttr.Put(SdrTransformRef2XItem(GetRef2().X()));
888  rAttr.Put(SdrTransformRef2YItem(GetRef2().Y()));
889  }
890 }
891 
893 {
894  SfxItemSet aSet(mpModel->GetItemPool());
895  MergeAttrFromMarked(aSet,bOnlyHardAttr);
896  //the EE_FEATURE items should not be set with SetAttrToMarked (see error message there)
897  //so we do not set them here
898  // #i32448#
899  // Do not disable, but clear the items.
900  aSet.ClearItem(EE_FEATURE_TAB);
901  aSet.ClearItem(EE_FEATURE_LINEBR);
902  aSet.ClearItem(EE_FEATURE_NOTCONV);
903  aSet.ClearItem(EE_FEATURE_FIELD);
904 
905  return aSet;
906 }
907 
908 void SdrEditView::MergeAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const
909 {
910  const size_t nMarkCount(GetMarkedObjectCount());
911 
912  for(size_t a = 0; a < nMarkCount; ++a)
913  {
914  // #80277# merging was done wrong in the prev version
916  SfxWhichIter aIter(rSet);
917  sal_uInt16 nWhich(aIter.FirstWhich());
918 
919  while(nWhich)
920  {
921  if(!bOnlyHardAttr)
922  {
923  if(SfxItemState::DONTCARE == rSet.GetItemState(nWhich, false))
924  rAttr.InvalidateItem(nWhich);
925  else
926  rAttr.MergeValue(rSet.Get(nWhich), true);
927  }
928  else if(SfxItemState::SET == rSet.GetItemState(nWhich, false))
929  {
930  const SfxPoolItem& rItem = rSet.Get(nWhich);
931  rAttr.MergeValue(rItem, true);
932  }
933 
935  {
936  OUString sPayload;
937  switch(nWhich)
938  {
939  case XATTR_LINECOLOR:
940  {
941  const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINECOLOR);
942  if (pItem)
943  {
944  Color aColor = static_cast<const XLineColorItem*>(pItem)->GetColorValue();
945  sPayload = OUString::number(static_cast<sal_uInt32>(aColor));
946 
947  sPayload = ".uno:XLineColor=" + sPayload;
948  }
949  break;
950  }
951 
952  case XATTR_FILLCOLOR:
953  {
954  const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLCOLOR);
955  if (pItem)
956  {
957  Color aColor = static_cast<const XFillColorItem*>(pItem)->GetColorValue();
958  sPayload = OUString::number(static_cast<sal_uInt32>(aColor));
959 
960  sPayload = ".uno:FillColor=" + sPayload;
961  }
962  break;
963  }
964 
966  {
967  const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLTRANSPARENCE);
968  if (pItem)
969  {
970  sal_uInt16 nTransparency = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
971  sPayload = OUString::number(nTransparency);
972 
973  sPayload = ".uno:FillTransparence=" + sPayload;
974  }
975  break;
976  }
977 
979  {
980  const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINETRANSPARENCE);
981  if (pItem)
982  {
983  sal_uInt16 nTransparency = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
984  sPayload = OUString::number(nTransparency);
985 
986  sPayload = ".uno:LineTransparence=" + sPayload;
987  }
988  break;
989  }
990 
991  case XATTR_LINEWIDTH:
992  {
993  const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINEWIDTH);
994  if (pItem)
995  {
996  sal_uInt32 nWidth = static_cast<const XLineWidthItem*>(pItem)->GetValue();
997  sPayload = OUString::number(nWidth);
998 
999  sPayload = ".uno:LineWidth=" + sPayload;
1000  }
1001  break;
1002  }
1003 
1005  {
1006  const SfxPoolItem* pItem = rSet.GetItem(SDRATTR_SHADOWTRANSPARENCE);
1007  if (pItem)
1008  {
1009  sal_uInt16 nWidth = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1010  sPayload = OUString::number(nWidth);
1011 
1012  sPayload = ".uno:FillShadowTransparency=" + sPayload;
1013  }
1014  break;
1015  }
1016  }
1017 
1018  if (!sPayload.isEmpty())
1019  GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
1020  OUStringToOString(sPayload, RTL_TEXTENCODING_ASCII_US).getStr());
1021  }
1022 
1023  nWhich = aIter.NextWhich();
1024  }
1025  }
1026 }
1027 
1028 std::vector<sal_uInt16> GetAllCharPropIds(const SfxItemSet& rSet)
1029 {
1030  std::vector<sal_uInt16> aCharWhichIds;
1031  {
1032  SfxItemIter aIter(rSet);
1033  for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
1034  {
1035  if (!IsInvalidItem(pItem))
1036  {
1037  sal_uInt16 nWhich = pItem->Which();
1038  if (nWhich>=EE_CHAR_START && nWhich<=EE_CHAR_END)
1039  aCharWhichIds.push_back( nWhich );
1040  }
1041  }
1042  }
1043  return aCharWhichIds;
1044 }
1045 
1046 void SdrEditView::SetAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll)
1047 {
1048  if (!AreObjectsMarked())
1049  return;
1050 
1051 #ifdef DBG_UTIL
1052  {
1053  bool bHasEEFeatureItems=false;
1054  SfxItemIter aIter(rAttr);
1055  for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem;
1056  pItem = aIter.NextItem())
1057  {
1058  if (!IsInvalidItem(pItem)) {
1059  sal_uInt16 nW=pItem->Which();
1060  if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true;
1061  }
1062  }
1063  if(bHasEEFeatureItems)
1064  {
1065  const OUString aMessage("SdrEditView::SetAttrToMarked(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents.");
1066  std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
1067  VclMessageType::Info, VclButtonsType::Ok,
1068  aMessage));
1069  xInfoBox->run();
1070  }
1071  }
1072 #endif
1073 
1074  // #103836# if the user sets character attributes to the complete shape,
1075  // we want to remove all hard set character attributes with same
1076  // which ids from the text. We do that later but here we remember
1077  // all character attribute which id's that are set.
1078  std::vector<sal_uInt16> aCharWhichIds(GetAllCharPropIds(rAttr));
1079 
1080  // To make Undo reconstruct text attributes correctly after Format.Standard
1081  bool bHasEEItems=SearchOutlinerItems(rAttr,bReplaceAll);
1082 
1083  // save additional geometry information when paragraph or character attributes
1084  // are changed and the geometrical shape of the text object might be changed
1085  bool bPossibleGeomChange(false);
1086  SfxWhichIter aIter(rAttr);
1087  sal_uInt16 nWhich = aIter.FirstWhich();
1088  while(!bPossibleGeomChange && nWhich)
1089  {
1090  SfxItemState eState = rAttr.GetItemState(nWhich);
1091  if(eState == SfxItemState::SET)
1092  {
1093  if((nWhich >= SDRATTR_TEXT_MINFRAMEHEIGHT && nWhich <= SDRATTR_TEXT_CONTOURFRAME)
1094  || nWhich == SDRATTR_3DOBJ_PERCENT_DIAGONAL
1095  || nWhich == SDRATTR_3DOBJ_BACKSCALE
1096  || nWhich == SDRATTR_3DOBJ_DEPTH
1097  || nWhich == SDRATTR_3DOBJ_END_ANGLE
1098  || nWhich == SDRATTR_3DSCENE_DISTANCE)
1099  {
1100  bPossibleGeomChange = true;
1101  }
1102  }
1103  nWhich = aIter.NextWhich();
1104  }
1105 
1106  const bool bUndo = IsUndoEnabled();
1107  if( bUndo )
1108  {
1110  BegUndo(ImpGetDescriptionString(STR_EditSetAttributes));
1111  }
1112 
1113  const size_t nMarkCount(GetMarkedObjectCount());
1114  std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
1115 
1116  // create ItemSet without SfxItemState::DONTCARE. Put()
1117  // uses its second parameter (bInvalidAsDefault) to
1118  // remove all such items to set them to default.
1119  SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges());
1120  aAttr.Put(rAttr);
1121 
1122  // #i38135#
1123  bool bResetAnimationTimer(false);
1124 
1125  const bool bLineStartWidthExplicitChange(SfxItemState::SET
1126  == aAttr.GetItemState(XATTR_LINESTARTWIDTH));
1127  const bool bLineEndWidthExplicitChange(SfxItemState::SET
1128  == aAttr.GetItemState(XATTR_LINEENDWIDTH));
1129  // check if LineWidth is part of the change
1130  const bool bAdaptStartEndWidths(!(bLineStartWidthExplicitChange && bLineEndWidthExplicitChange)
1131  && SfxItemState::SET == aAttr.GetItemState(XATTR_LINEWIDTH));
1132  sal_Int32 nNewLineWidth(0);
1133 
1134  if(bAdaptStartEndWidths)
1135  {
1136  nNewLineWidth = aAttr.Get(XATTR_LINEWIDTH).GetValue();
1137  }
1138 
1139  for (size_t nm=0; nm<nMarkCount; ++nm)
1140  {
1141  SdrMark* pM=GetSdrMarkByIndex(nm);
1142  SdrObject* pObj = pM->GetMarkedSdrObj();
1143 
1144  if( bUndo )
1145  {
1146  SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >( pObj );
1147  if ( pEdgeObj )
1148  bPossibleGeomChange = true;
1149  else
1150  AddUndoActions( CreateConnectorUndo( *pObj ) );
1151  }
1152 
1153  // new geometry undo
1154  if(bPossibleGeomChange && bUndo)
1155  {
1156  // save position and size of object, too
1157  AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
1158  }
1159 
1160  if( bUndo )
1161  {
1162  // #i8508#
1163  // If this is a text object also rescue the OutlinerParaObject since
1164  // applying attributes to the object may change text layout when
1165  // multiple portions exist with multiple formats. If an OutlinerParaObject
1166  // really exists and needs to be rescued is evaluated in the undo
1167  // implementation itself.
1168  const bool bRescueText = dynamic_cast< SdrTextObj* >(pObj) != nullptr;
1169 
1170  // add attribute undo
1171  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj,false,bHasEEItems || bPossibleGeomChange || bRescueText));
1172  }
1173 
1174  // set up a scene updater if object is a 3d object
1175  if(dynamic_cast< E3dObject* >(pObj))
1176  {
1177  aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj));
1178  }
1179 
1180  sal_Int32 nOldLineWidth(0);
1181  if (bAdaptStartEndWidths)
1182  {
1183  nOldLineWidth = pObj->GetMergedItem(XATTR_LINEWIDTH).GetValue();
1184  }
1185 
1186  // set attributes at object
1187  pObj->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll);
1188 
1189  if(bAdaptStartEndWidths)
1190  {
1191  const SfxItemSet& rSet = pObj->GetMergedItemSet();
1192 
1193  if(nOldLineWidth != nNewLineWidth)
1194  {
1195  if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINESTARTWIDTH))
1196  {
1197  const sal_Int32 nValAct(rSet.Get(XATTR_LINESTARTWIDTH).GetValue());
1198  const sal_Int32 nValNewStart(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10)));
1199 
1200  pObj->SetMergedItem(XLineStartWidthItem(nValNewStart));
1201  }
1202 
1203  if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINEENDWIDTH))
1204  {
1205  const sal_Int32 nValAct(rSet.Get(XATTR_LINEENDWIDTH).GetValue());
1206  const sal_Int32 nValNewEnd(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10)));
1207 
1208  pObj->SetMergedItem(XLineEndWidthItem(nValNewEnd));
1209  }
1210  }
1211  }
1212 
1213  if(dynamic_cast<const SdrTextObj*>( pObj) != nullptr)
1214  {
1215  SdrTextObj* pTextObj = static_cast<SdrTextObj*>(pObj);
1216 
1217  if(!aCharWhichIds.empty())
1218  {
1219  tools::Rectangle aOldBoundRect = pTextObj->GetLastBoundRect();
1220 
1221  // #110094#-14 pTextObj->SendRepaintBroadcast(pTextObj->GetBoundRect());
1222  pTextObj->RemoveOutlinerCharacterAttribs( aCharWhichIds );
1223 
1224  // object has changed, should be called from
1225  // RemoveOutlinerCharacterAttribs. This will change when the text
1226  // object implementation changes.
1227  pTextObj->SetChanged();
1228 
1229  pTextObj->BroadcastObjectChange();
1230  pTextObj->SendUserCall(SdrUserCallType::ChangeAttr, aOldBoundRect);
1231  }
1232  }
1233 
1234  // #i38495#
1235  if(!bResetAnimationTimer)
1236  {
1238  {
1239  bResetAnimationTimer = true;
1240  }
1241  }
1242  }
1243 
1244  // fire scene updaters
1245  while(!aUpdaters.empty())
1246  {
1247  delete aUpdaters.back();
1248  aUpdaters.pop_back();
1249  }
1250 
1251  // #i38135#
1252  if(bResetAnimationTimer)
1253  {
1254  SetAnimationTimer(0);
1255  }
1256 
1257  // better check before what to do:
1258  // pObj->SetAttr() or SetNotPersistAttr()
1259  // TODO: missing implementation!
1261 
1262  if( bUndo )
1263  EndUndo();
1264 }
1265 
1267 {
1268  SfxStyleSheet* pRet=nullptr;
1269  bool b1st=true;
1270  const size_t nMarkCount=GetMarkedObjectCount();
1271  for (size_t nm=0; nm<nMarkCount; ++nm) {
1272  SdrMark* pM=GetSdrMarkByIndex(nm);
1274  if (b1st) pRet=pSS;
1275  else if (pRet!=pSS) return nullptr; // different stylesheets
1276  b1st=false;
1277  }
1278  return pRet;
1279 }
1280 
1281 void SdrEditView::SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
1282 {
1283  if (AreObjectsMarked())
1284  {
1285  const bool bUndo = IsUndoEnabled();
1286 
1287  if( bUndo )
1288  {
1290  OUString aStr;
1291  if (pStyleSheet!=nullptr)
1292  aStr = ImpGetDescriptionString(STR_EditSetStylesheet);
1293  else
1294  aStr = ImpGetDescriptionString(STR_EditDelStylesheet);
1295  BegUndo(aStr);
1296  }
1297 
1298  const size_t nMarkCount=GetMarkedObjectCount();
1299  for (size_t nm=0; nm<nMarkCount; ++nm)
1300  {
1301  SdrMark* pM=GetSdrMarkByIndex(nm);
1302  if( bUndo )
1303  {
1304  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pM->GetMarkedSdrObj()));
1305  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pM->GetMarkedSdrObj(),true,true));
1306  }
1307  pM->GetMarkedSdrObj()->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1308  }
1309 
1310  if( bUndo )
1311  EndUndo();
1312  }
1313 }
1314 
1315 
1316 void SdrEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
1317 {
1318  if(GetMarkedObjectCount())
1319  {
1320  rTargetSet.Put(GetAttrFromMarked(bOnlyHardAttr), false);
1321  }
1322  else
1323  {
1324  SdrMarkView::GetAttributes(rTargetSet, bOnlyHardAttr);
1325  }
1326 }
1327 
1328 void SdrEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
1329 {
1330  if (GetMarkedObjectCount()!=0) {
1331  SetAttrToMarked(rSet,bReplaceAll);
1332  } else {
1333  SdrMarkView::SetAttributes(rSet,bReplaceAll);
1334  }
1335 }
1336 
1338 {
1339  if (GetMarkedObjectCount()!=0) {
1340  return GetStyleSheetFromMarked();
1341  } else {
1342  return SdrMarkView::GetStyleSheet();
1343  }
1344 }
1345 
1346 void SdrEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
1347 {
1348  if (GetMarkedObjectCount()!=0) {
1349  SetStyleSheetToMarked(pStyleSheet,bDontRemoveHardAttr);
1350  } else {
1351  SdrMarkView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1352  }
1353 }
1354 
1355 
1357 {
1358  SfxItemSet aRetSet(
1359  mpModel->GetItemPool(),
1360  svl::Items< // SID_ATTR_TRANSFORM_... from s:svxids.hrc
1362  SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_ANGLE,
1363  SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_AUTOHEIGHT>{});
1364 
1365  if (AreObjectsMarked())
1366  {
1367  SfxItemSet aMarkAttr(GetAttrFromMarked(false)); // because of AutoGrowHeight and corner radius
1369 
1370  if(GetSdrPageView())
1371  {
1372  GetSdrPageView()->LogicToPagePos(aRect);
1373  }
1374 
1375  // position
1376  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_X,aRect.Left()));
1377  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_Y,aRect.Top()));
1378 
1379  // size
1380  long nResizeRefX=aRect.Left();
1381  long nResizeRefY=aRect.Top();
1382  if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for resizing, too
1383  nResizeRefX=maRef1.X();
1384  nResizeRefY=maRef1.Y();
1385  }
1386  aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_WIDTH,aRect.Right()-aRect.Left()));
1387  aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_HEIGHT,aRect.Bottom()-aRect.Top()));
1388  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_X,nResizeRefX));
1389  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_Y,nResizeRefY));
1390 
1391  Point aRotateAxe(maRef1);
1392 
1393  if(GetSdrPageView())
1394  {
1395  GetSdrPageView()->LogicToPagePos(aRotateAxe);
1396  }
1397 
1398  // rotation
1399  long nRotateRefX=aRect.Center().X();
1400  long nRotateRefY=aRect.Center().Y();
1402  nRotateRefX=aRotateAxe.X();
1403  nRotateRefY=aRotateAxe.Y();
1404  }
1405  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ANGLE,GetMarkedObjRotate()));
1406  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_X,nRotateRefX));
1407  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_Y,nRotateRefY));
1408 
1409  // shearing
1410  long nShearRefX=aRect.Left();
1411  long nShearRefY=aRect.Bottom();
1412  if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for shearing, too
1413  nShearRefX=aRotateAxe.X();
1414  nShearRefY=aRotateAxe.Y();
1415  }
1416  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR,GetMarkedObjShear()));
1417  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X,nShearRefX));
1418  aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y,nShearRefY));
1419 
1420  // check every object whether it is protected
1421  const SdrMarkList& rMarkList=GetMarkedObjectList();
1422  const size_t nMarkCount=rMarkList.GetMarkCount();
1423  SdrObject* pObj=rMarkList.GetMark(0)->GetMarkedSdrObj();
1424  bool bPosProt=pObj->IsMoveProtect();
1425  bool bSizProt=pObj->IsResizeProtect();
1426  bool bPosProtDontCare=false;
1427  bool bSizProtDontCare=false;
1428  for (size_t i=1; i<nMarkCount && (!bPosProtDontCare || !bSizProtDontCare); ++i)
1429  {
1430  pObj=rMarkList.GetMark(i)->GetMarkedSdrObj();
1431  if (bPosProt!=pObj->IsMoveProtect()) bPosProtDontCare=true;
1432  if (bSizProt!=pObj->IsResizeProtect()) bSizProtDontCare=true;
1433  }
1434 
1435  // InvalidateItem sets item to DONT_CARE
1436  if (bPosProtDontCare) {
1437  aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_POS);
1438  } else {
1439  aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_POS,bPosProt));
1440  }
1441  if (bSizProtDontCare) {
1442  aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_SIZE);
1443  } else {
1444  aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_SIZE,bSizProt));
1445  }
1446 
1448  bool bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue();
1449  if (eState==SfxItemState::DONTCARE) {
1450  aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOWIDTH);
1451  } else if (eState==SfxItemState::SET) {
1452  aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOWIDTH,bAutoGrow));
1453  }
1454 
1455  eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWHEIGHT);
1456  bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
1457  if (eState==SfxItemState::DONTCARE) {
1458  aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOHEIGHT);
1459  } else if (eState==SfxItemState::SET) {
1460  aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOHEIGHT,bAutoGrow));
1461  }
1462 
1463  eState=aMarkAttr.GetItemState(SDRATTR_ECKENRADIUS);
1464  long nRadius=aMarkAttr.Get(SDRATTR_ECKENRADIUS).GetValue();
1465  if (eState==SfxItemState::DONTCARE) {
1466  aRetSet.InvalidateItem(SDRATTR_ECKENRADIUS);
1467  } else if (eState==SfxItemState::SET) {
1468  aRetSet.Put(makeSdrEckenradiusItem(nRadius));
1469  }
1470 
1471  basegfx::B2DHomMatrix aTransformation;
1472 
1473  if(nMarkCount > 1)
1474  {
1475  // multiple objects, range is collected in aRect
1477  aRect.Left(), aRect.Top(),
1478  aRect.getWidth(), aRect.getHeight());
1479  }
1480  else
1481  {
1482  // single object, get homogen transformation
1483  basegfx::B2DPolyPolygon aPolyPolygon;
1484 
1485  pObj->TRGetBaseGeometry(aTransformation, aPolyPolygon);
1486  }
1487 
1488  if(aTransformation.isIdentity())
1489  {
1490  aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_MATRIX);
1491  }
1492  else
1493  {
1494  css::geometry::AffineMatrix2D aAffineMatrix2D;
1495  Point aPageOffset(0, 0);
1496 
1497  if(GetSdrPageView())
1498  {
1499  aPageOffset = GetSdrPageView()->GetPageOrigin();
1500  }
1501 
1502  aAffineMatrix2D.m00 = aTransformation.get(0, 0);
1503  aAffineMatrix2D.m01 = aTransformation.get(0, 1);
1504  aAffineMatrix2D.m02 = aTransformation.get(0, 2) - aPageOffset.X();
1505  aAffineMatrix2D.m10 = aTransformation.get(1, 0);
1506  aAffineMatrix2D.m11 = aTransformation.get(1, 1);
1507  aAffineMatrix2D.m12 = aTransformation.get(1, 2) - aPageOffset.Y();
1508 
1509  aRetSet.Put(AffineMatrixItem(&aAffineMatrix2D));
1510  }
1511  }
1512 
1513  return aRetSet;
1514 }
1515 
1516 static Point ImpGetPoint(const tools::Rectangle& rRect, RectPoint eRP)
1517 {
1518  switch(eRP) {
1519  case RectPoint::LT: return rRect.TopLeft();
1520  case RectPoint::MT: return rRect.TopCenter();
1521  case RectPoint::RT: return rRect.TopRight();
1522  case RectPoint::LM: return rRect.LeftCenter();
1523  case RectPoint::MM: return rRect.Center();
1524  case RectPoint::RM: return rRect.RightCenter();
1525  case RectPoint::LB: return rRect.BottomLeft();
1526  case RectPoint::MB: return rRect.BottomCenter();
1527  case RectPoint::RB: return rRect.BottomRight();
1528  }
1529  return Point(); // Should not happen!
1530 }
1531 
1533 {
1534  const bool bTiledRendering = comphelper::LibreOfficeKit::isActive();
1535 
1537 
1538  if(GetSdrPageView())
1539  {
1540  GetSdrPageView()->LogicToPagePos(aRect);
1541  }
1542 
1543  long nOldRotateAngle=GetMarkedObjRotate();
1544  long nOldShearAngle=GetMarkedObjShear();
1545  const SdrMarkList& rMarkList=GetMarkedObjectList();
1546  const size_t nMarkCount=rMarkList.GetMarkCount();
1547  SdrObject* pObj=nullptr;
1548 
1549  RectPoint eSizePoint=RectPoint::MM;
1550  long nPosDX=0;
1551  long nPosDY=0;
1552  long nSizX=0;
1553  long nSizY=0;
1554  long nRotateAngle=0;
1555 
1556  bool bModeIsRotate(meDragMode == SdrDragMode::Rotate);
1557  long nRotateX(0);
1558  long nRotateY(0);
1559  long nOldRotateX(0);
1560  long nOldRotateY(0);
1561  if(bModeIsRotate)
1562  {
1563  Point aRotateAxe(maRef1);
1564 
1565  if(GetSdrPageView())
1566  {
1567  GetSdrPageView()->LogicToPagePos(aRotateAxe);
1568  }
1569 
1570  nRotateX = nOldRotateX = aRotateAxe.X();
1571  nRotateY = nOldRotateY = aRotateAxe.Y();
1572  }
1573 
1574  long nShearAngle=0;
1575  long nShearX=0;
1576  long nShearY=0;
1577  bool bShearVert=false;
1578 
1579  bool bChgPos=false;
1580  bool bChgSiz=false;
1581  bool bChgWdh=false;
1582  bool bChgHgt=false;
1583  bool bRotate=false;
1584  bool bShear =false;
1585 
1586  bool bSetAttr=false;
1587  SfxItemSet aSetAttr(mpModel->GetItemPool());
1588 
1589  const SfxPoolItem* pPoolItem=nullptr;
1590 
1591  // position
1592  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_X,true,&pPoolItem)) {
1593  nPosDX=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - aRect.Left();
1594  bChgPos=true;
1595  }
1596  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_Y,true,&pPoolItem)){
1597  nPosDY=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - aRect.Top();
1598  bChgPos=true;
1599  }
1600  // size
1601  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_WIDTH,true,&pPoolItem)) {
1602  nSizX=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
1603  bChgSiz=true;
1604  bChgWdh=true;
1605  }
1606  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_HEIGHT,true,&pPoolItem)) {
1607  nSizY=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
1608  bChgSiz=true;
1609  bChgHgt=true;
1610  }
1611  if (bChgSiz) {
1612  if (bTiledRendering && SfxItemState::SET != rAttr.GetItemState(SID_ATTR_TRANSFORM_SIZE_POINT, true, &pPoolItem))
1613  eSizePoint = RectPoint::LT;
1614  else
1615  eSizePoint = static_cast<RectPoint>(rAttr.Get(SID_ATTR_TRANSFORM_SIZE_POINT).GetValue());
1616  }
1617 
1618  // rotation
1619  if (SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_DELTA_ANGLE, true, &pPoolItem)) {
1620  nRotateAngle = static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
1621  bRotate = (nRotateAngle != 0);
1622  }
1623 
1624  // rotation
1625  if (SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_ANGLE, true, &pPoolItem)) {
1626  nRotateAngle = static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - nOldRotateAngle;
1627  bRotate = (nRotateAngle != 0);
1628  }
1629 
1630  // position rotation point x
1631  if(bRotate || SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_X, true ,&pPoolItem))
1632  nRotateX = rAttr.Get(SID_ATTR_TRANSFORM_ROT_X).GetValue();
1633 
1634  // position rotation point y
1635  if(bRotate || SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_Y, true ,&pPoolItem))
1636  nRotateY = rAttr.Get(SID_ATTR_TRANSFORM_ROT_Y).GetValue();
1637 
1638  // shearing
1639  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_SHEAR,true,&pPoolItem)) {
1640  long nNewShearAngle=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
1641  if (nNewShearAngle>SDRMAXSHEAR) nNewShearAngle=SDRMAXSHEAR;
1642  if (nNewShearAngle<-SDRMAXSHEAR) nNewShearAngle=-SDRMAXSHEAR;
1643  if (nNewShearAngle!=nOldShearAngle) {
1644  bShearVert=static_cast<const SfxBoolItem&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_VERTICAL)).GetValue();
1645  if (bShearVert) {
1646  nShearAngle=nNewShearAngle;
1647  } else {
1648  if (nNewShearAngle!=0 && nOldShearAngle!=0) {
1649  // bug fix
1650  double nOld = tan(static_cast<double>(nOldShearAngle) * F_PI18000);
1651  double nNew = tan(static_cast<double>(nNewShearAngle) * F_PI18000);
1652  nNew-=nOld;
1653  nNew = atan(nNew) / F_PI18000;
1654  nShearAngle=FRound(nNew);
1655  } else {
1656  nShearAngle=nNewShearAngle-nOldShearAngle;
1657  }
1658  }
1659  bShear=nShearAngle!=0;
1660  if (bShear) {
1661  nShearX=static_cast<const SfxInt32Item&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_X)).GetValue();
1662  nShearY=static_cast<const SfxInt32Item&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_Y)).GetValue();
1663  }
1664  }
1665  }
1666 
1667  // AutoGrow
1668  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOWIDTH,true,&pPoolItem)) {
1669  bool bAutoGrow=static_cast<const SfxBoolItem*>(pPoolItem)->GetValue();
1670  aSetAttr.Put(makeSdrTextAutoGrowWidthItem(bAutoGrow));
1671  bSetAttr=true;
1672  }
1673 
1674  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOHEIGHT,true,&pPoolItem)) {
1675  bool bAutoGrow=static_cast<const SfxBoolItem*>(pPoolItem)->GetValue();
1676  aSetAttr.Put(makeSdrTextAutoGrowHeightItem(bAutoGrow));
1677  bSetAttr=true;
1678  }
1679 
1680  // corner radius
1681  if (m_bEdgeRadiusAllowed && SfxItemState::SET==rAttr.GetItemState(SDRATTR_ECKENRADIUS,true,&pPoolItem)) {
1682  long nRadius=static_cast<const SdrMetricItem*>(pPoolItem)->GetValue();
1683  aSetAttr.Put(makeSdrEckenradiusItem(nRadius));
1684  bSetAttr=true;
1685  }
1686 
1688 
1689  BegUndo(SvxResId(STR_EditTransform),GetDescriptionOfMarkedObjects());
1690 
1691  if (bSetAttr) {
1692  SetAttrToMarked(aSetAttr,false);
1693  }
1694 
1695  // change size and height
1696  if (bChgSiz && (m_bResizeFreeAllowed || m_bResizePropAllowed)) {
1697  Fraction aWdt(nSizX,aRect.Right()-aRect.Left());
1698  Fraction aHgt(nSizY,aRect.Bottom()-aRect.Top());
1699  Point aRef(ImpGetPoint(aRect,eSizePoint));
1700 
1701  if(GetSdrPageView())
1702  {
1703  GetSdrPageView()->PagePosToLogic(aRef);
1704  }
1705 
1706  ResizeMultMarkedObj(aRef, aWdt, aHgt, bChgWdh, bChgHgt);
1707  }
1708 
1709  // rotate
1710  if (bRotate && (m_bRotateFreeAllowed || m_bRotate90Allowed)) {
1711  Point aRef(nRotateX,nRotateY);
1712 
1713  if(GetSdrPageView())
1714  {
1715  GetSdrPageView()->PagePosToLogic(aRef);
1716  }
1717 
1718  RotateMarkedObj(aRef,nRotateAngle);
1719  }
1720 
1721  // set rotation point position
1722  if(bModeIsRotate && (nRotateX != nOldRotateX || nRotateY != nOldRotateY))
1723  {
1724  Point aNewRef1(nRotateX, nRotateY);
1725 
1726  if(GetSdrPageView())
1727  {
1728  GetSdrPageView()->PagePosToLogic(aNewRef1);
1729  }
1730 
1731  SetRef1(aNewRef1);
1732  }
1733 
1734  // shear
1735  if (bShear && m_bShearAllowed) {
1736  Point aRef(nShearX,nShearY);
1737 
1738  if(GetSdrPageView())
1739  {
1740  GetSdrPageView()->PagePosToLogic(aRef);
1741  }
1742 
1743  ShearMarkedObj(aRef,nShearAngle,bShearVert);
1744 
1745  // #i74358#
1746  // ShearMarkedObj creates a linear combination of the existing transformation and
1747  // the new shear to apply. If the object is already transformed (e.g. rotated) the
1748  // linear combination will not decompose to the same start values again, but to a
1749  // new combination. Thus it makes no sense to check if the wanted shear is reached
1750  // or not. Taking out.
1751  }
1752 
1753  // change position
1754  if (bChgPos && m_bMoveAllowed) {
1755  MoveMarkedObj(Size(nPosDX,nPosDY));
1756  }
1757 
1758  // protect position
1759  if(SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_POS, true, &pPoolItem))
1760  {
1761  const bool bProtPos(static_cast<const SfxBoolItem*>(pPoolItem)->GetValue());
1762  bool bChanged(false);
1763 
1764  for(size_t i = 0; i < nMarkCount; ++i)
1765  {
1766  pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1767 
1768  if(pObj->IsMoveProtect() != bProtPos)
1769  {
1770  bChanged = true;
1771  pObj->SetMoveProtect(bProtPos);
1772 
1773  if(bProtPos)
1774  {
1775  pObj->SetResizeProtect(true);
1776  }
1777  }
1778  }
1779 
1780  if(bChanged)
1781  {
1782  m_bMoveProtect = bProtPos;
1783 
1784  if(bProtPos)
1785  {
1786  m_bResizeProtect = true;
1787  }
1788 
1789  // #i77187# there is no simple method to get the toolbars updated
1790  // in the application. The App is listening to selection change and i
1791  // will use it here (even if not true). It's acceptable since changing
1792  // this model data is pretty rare and only possible using the F4 dialog
1794  }
1795  }
1796 
1797  if(!m_bMoveProtect)
1798  {
1799  // protect size
1800  if(SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_SIZE, true, &pPoolItem))
1801  {
1802  const bool bProtSize(static_cast<const SfxBoolItem*>(pPoolItem)->GetValue());
1803  bool bChanged(false);
1804 
1805  for(size_t i = 0; i < nMarkCount; ++i)
1806  {
1807  pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1808 
1809  if(pObj->IsResizeProtect() != bProtSize)
1810  {
1811  bChanged = true;
1812  pObj->SetResizeProtect(bProtSize);
1813  }
1814  }
1815 
1816  if(bChanged)
1817  {
1818  m_bResizeProtect = bProtSize;
1819 
1820  // #i77187# see above
1822  }
1823  }
1824  }
1825 
1826  EndUndo();
1827 }
1828 
1829 
1831 { // at least two selected objects, at least one of them movable
1833  const size_t nCount=GetMarkedObjectCount();
1834  if (nCount==0) return false; // nothing selected!
1835  if (nCount==1) return m_bMoveAllowed; // align single object to page
1836  return m_bOneOrMoreMovable; // otherwise: MarkCount>=2
1837 }
1838 
1840 {
1841  if (eHor==SdrHorAlign::NONE && eVert==SdrVertAlign::NONE)
1842  return;
1843 
1845  if (!GetMarkedObjectCount())
1846  return;
1847 
1848  const bool bUndo = IsUndoEnabled();
1849  if( bUndo )
1850  {
1852  OUString aStr(GetDescriptionOfMarkedObjects());
1853  if (eHor==SdrHorAlign::NONE)
1854  {
1855  switch (eVert)
1856  {
1857  case SdrVertAlign::Top:
1858  aStr = ImpGetDescriptionString(STR_EditAlignVTop);
1859  break;
1860  case SdrVertAlign::Bottom:
1861  aStr = ImpGetDescriptionString(STR_EditAlignVBottom);
1862  break;
1863  case SdrVertAlign::Center:
1864  aStr = ImpGetDescriptionString(STR_EditAlignVCenter);
1865  break;
1866  default: break;
1867  }
1868  }
1869  else if (eVert==SdrVertAlign::NONE)
1870  {
1871  switch (eHor)
1872  {
1873  case SdrHorAlign::Left:
1874  aStr = ImpGetDescriptionString(STR_EditAlignHLeft);
1875  break;
1876  case SdrHorAlign::Right:
1877  aStr = ImpGetDescriptionString(STR_EditAlignHRight);
1878  break;
1879  case SdrHorAlign::Center:
1880  aStr = ImpGetDescriptionString(STR_EditAlignHCenter);
1881  break;
1882  default: break;
1883  }
1884  }
1885  else if (eHor==SdrHorAlign::Center && eVert==SdrVertAlign::Center)
1886  {
1887  aStr = ImpGetDescriptionString(STR_EditAlignCenter);
1888  }
1889  else
1890  {
1891  aStr = ImpGetDescriptionString(STR_EditAlign);
1892  }
1893  BegUndo(aStr);
1894  }
1895 
1896  tools::Rectangle aBound;
1897  const size_t nMarkCount=GetMarkedObjectCount();
1898  bool bHasFixed=false;
1899  for (size_t nm=0; nm<nMarkCount; ++nm)
1900  {
1901  SdrMark* pM=GetSdrMarkByIndex(nm);
1902  SdrObject* pObj=pM->GetMarkedSdrObj();
1903  SdrObjTransformInfoRec aInfo;
1904  pObj->TakeObjInfo(aInfo);
1905  if (!aInfo.bMoveAllowed || pObj->IsMoveProtect())
1906  {
1907  tools::Rectangle aObjRect(pObj->GetSnapRect());
1908  aBound.Union(aObjRect);
1909  bHasFixed=true;
1910  }
1911  }
1912  if (!bHasFixed)
1913  {
1914  if (nMarkCount==1)
1915  { // align single object to page
1916  const SdrObject* pObj=GetMarkedObjectByIndex(0);
1917  const SdrPage* pPage=pObj->getSdrPageFromSdrObject();
1919  const SdrPageGridFrame* pFrame=nullptr;
1920  if (pGFL!=nullptr && pGFL->GetCount()!=0)
1921  { // Writer
1922  pFrame=&((*pGFL)[0]);
1923  }
1924 
1925  if (pFrame!=nullptr)
1926  { // Writer
1927  aBound=pFrame->GetUserArea();
1928  }
1929  else
1930  {
1931  aBound=tools::Rectangle(pPage->GetLeftBorder(),pPage->GetUpperBorder(),
1932  pPage->GetWidth()-pPage->GetRightBorder(),
1933  pPage->GetHeight()-pPage->GetLowerBorder());
1934  }
1935  }
1936  else
1937  {
1938  aBound=GetMarkedObjRect();
1939  }
1940  }
1941  Point aCenter(aBound.Center());
1942  for (size_t nm=0; nm<nMarkCount; ++nm)
1943  {
1944  SdrMark* pM=GetSdrMarkByIndex(nm);
1945  SdrObject* pObj=pM->GetMarkedSdrObj();
1946  SdrObjTransformInfoRec aInfo;
1947  pObj->TakeObjInfo(aInfo);
1948  if (aInfo.bMoveAllowed && !pObj->IsMoveProtect())
1949  {
1950  long nXMov=0;
1951  long nYMov=0;
1952  tools::Rectangle aObjRect(pObj->GetSnapRect());
1953  switch (eVert)
1954  {
1955  case SdrVertAlign::Top : nYMov=aBound.Top() -aObjRect.Top() ; break;
1956  case SdrVertAlign::Bottom: nYMov=aBound.Bottom()-aObjRect.Bottom() ; break;
1957  case SdrVertAlign::Center: nYMov=aCenter.Y() -aObjRect.Center().Y(); break;
1958  default: break;
1959  }
1960  switch (eHor)
1961  {
1962  case SdrHorAlign::Left : nXMov=aBound.Left() -aObjRect.Left() ; break;
1963  case SdrHorAlign::Right : nXMov=aBound.Right() -aObjRect.Right() ; break;
1964  case SdrHorAlign::Center: nXMov=aCenter.X() -aObjRect.Center().X(); break;
1965  default: break;
1966  }
1967  if (nXMov!=0 || nYMov!=0)
1968  {
1969  // SdrEdgeObj needs an extra SdrUndoGeoObj since the
1970  // connections may need to be saved
1971  if( bUndo )
1972  {
1973  if( dynamic_cast<SdrEdgeObj*>(pObj) )
1974  {
1975  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
1976  }
1977 
1978  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pObj,Size(nXMov,nYMov)));
1979  }
1980 
1981  pObj->Move(Size(nXMov,nYMov));
1982  }
1983  }
1984  }
1985 
1986  if( bUndo )
1987  EndUndo();
1988 }
1989 
1990 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Point TopLeft() const
long getHeight() const
XPropertyListType t
Definition: xtable.cxx:370
#define EE_FEATURE_END
long GetMarkedObjRotate() const
Definition: svdedtv1.cxx:283
long GetWidth() const
virtual void TakeObjInfo(SdrObjTransformInfoRec &rInfo) const
Definition: svdobj.cxx:562
bool SearchOutlinerItems(const SfxItemSet &rSet, bool bInklDefaults, bool *pbOnlyEE)
Search an ItemSet for Outliner/EditEngine Items.
Definition: svdetc.cxx:348
#define EE_FEATURE_NOTCONV
void MirrorMarkedObj(const Point &rRef1, const Point &rRef2, bool bCopy=false)
Definition: svdedtv1.cxx:368
void RemoveOutlinerCharacterAttribs(const std::vector< sal_uInt16 > &rCharWhichIds)
iterates over the paragraphs of a given SdrObject and removes all hard set character attributes with ...
Definition: svdotxat.cxx:373
bool bVisible
size_t GetMarkCount() const
Definition: svdmark.hxx:180
long GetHeight() const
virtual void Resize(const Point &rRef, const Fraction &xFact, const Fraction &yFact, bool bUnsetRelative=true)
Definition: svdobj.cxx:1483
void SetStyleSheet(SfxStyleSheet *pStyleSheet, bool bDontRemoveHardAttr)
Definition: svdpntv.cxx:1008
#define SDRMAXSHEAR
Definition: svdtrans.hxx:46
void SortMarkedObjects() const
Definition: svdmrkv.hxx:250
#define SDRATTR_3DOBJ_PERCENT_DIAGONAL
Definition: svddef.hxx:328
void AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert)
Definition: svdedtv1.cxx:1839
void GetAttributes(SfxItemSet &rTargetSet, bool bOnlyHardAttr) const
Definition: svdedtv1.cxx:1316
void SetResizeProtect(bool bProt)
Definition: svdobj.cxx:2562
void SetPoint(const Point &rPnt, sal_uInt32 i)
Definition: svdobj.cxx:1674
long FRound(double fVal)
#define SDRATTR_ALLSIZEWIDTH
Definition: svddef.hxx:281
sal_Int32 GetHeight() const
Definition: svdpage.cxx:1410
for the snap-to-grid in Writer
Definition: svdpage.hxx:281
std::string GetValue
#define XATTR_LINEENDWIDTH
Definition: xdef.hxx:97
void SetNotPersistAttrToMarked(const SfxItemSet &rAttr)
Definition: svdedtv1.cxx:699
virtual bool IsPolyObj() const
Definition: svdobj.cxx:1659
Point BottomLeft() const
bool m_bShearAllowed
Definition: svdedtv.hxx:105
long getWidth() const
bool isAnimatedInAnyViewObjectContact() const
bool AreObjectsMarked() const
Definition: svdmrkv.hxx:251
bool IsUndoEnabled() const
Definition: svdedtv.cxx:1027
void MirrorMarkedObjHorizontal()
Definition: svdedtv1.cxx:432
void SetGeoAttrToMarked(const SfxItemSet &rAttr)
Definition: svdedtv1.cxx:1532
void MergeValue(const SfxPoolItem &rItem, bool bOverwriteDefaults=false)
void ForcePossibilities() const
Definition: svdedtv.hxx:162
void ResizeMultMarkedObj(const Point &rRef, const Fraction &xFact, const Fraction &yFact, const bool bWdh, const bool bHgt)
Definition: svdedtv1.cxx:247
void SetStyleSheet(SfxStyleSheet *pNewStyleSheet, bool bDontRemoveHardAttr)
Definition: svdobj.cxx:2139
bool m_bResizeProtect
Definition: svdedtv.hxx:114
static void ImpDistortObj(SdrObject *pO, const tools::Rectangle &rRef, const XPolygon &rDistortedRect, bool bNoContortion)
Definition: svdedtv1.cxx:624
sal_Int64 n
sal_Int32 GetRightBorder() const
Definition: svdpage.cxx:1495
#define SDRATTR_SHADOWTRANSPARENCE
Definition: svddef.hxx:180
void MirrorMarkedObjVertical()
Definition: svdedtv1.cxx:440
void InvalidateItem(sal_uInt16 nWhich)
void BegUndo()
Definition: svdedtv.hxx:179
sal_uInt16 FirstWhich()
const tools::Rectangle & GetUserArea() const
Definition: svdpage.hxx:288
SdrPageView * GetSdrPageViewOfMarkedByIndex(size_t nNum) const
Definition: svdmrkv.hxx:246
const SfxBroadcaster * GetBroadcaster() const
Definition: svdobj.cxx:626
SdrMark * GetMark(size_t nNum) const
Definition: svdmark.cxx:229
std::vector< std::unique_ptr< SdrUndoAction > > CreateConnectorUndo(SdrObject &rO)
Definition: svdedtv1.cxx:149
void MergeAttrFromMarked(SfxItemSet &rAttr, bool bOnlyHardAttr) const
Definition: svdedtv1.cxx:908
void EndTextEditAllViews() const
Checks if this or other views have an active text edit, if true, end them.
Definition: svdedtv.cxx:1032
virtual sal_uInt32 GetPointCount() const
Definition: svdobj.cxx:1664
sal_Int32 GetLowerBorder() const
Definition: svdpage.cxx:1500
void PagePosToLogic(Point &rPnt) const
Definition: svdpagv.hxx:212
Center
virtual SdrObjList * GetSubList() const
Definition: svdobj.cxx:646
#define SDRATTR_RESIZEYALL
Definition: svddef.hxx:299
sal_Int32 GetLeftBorder() const
Definition: svdpage.cxx:1485
#define EE_FEATURE_START
double CrookRotateXPoint(Point &rPnt, Point *pC1, Point *pC2, const Point &rCenter, const Point &rRad, double &rSin, double &rCos, bool bVert)
The following methods accept a point of an XPolygon, whereas the neighbouring control points of the a...
Definition: svdtrans.cxx:161
#define SDRATTR_HORZSHEARALL
Definition: svddef.hxx:301
virtual void Rotate(const Point &rRef, long nAngle, double sn, double cs)
Definition: svdobj.cxx:1510
static Point ImpGetPoint(const tools::Rectangle &rRect, RectPoint eRP)
Definition: svdedtv1.cxx:1516
sdr::contact::ViewContact & GetViewContact() const
Definition: svdobj.cxx:244
#define XATTR_FILLCOLOR
Definition: xdef.hxx:108
sal_uInt16 NextWhich()
SdrOnOffItem makeSdrTextAutoGrowHeightItem(bool bAuto)
Definition: sdtagitm.hxx:25
#define EE_FEATURE_TAB
double get(sal_uInt16 nRow, sal_uInt16 nColumn) const
const tools::Rectangle & GetMarkedObjRect() const
Definition: svdmrkv.cxx:2363
void Move(long nHorzMoveDelta, long nVertMoveDelta)
Point RightCenter() const
virtual const tools::Rectangle & GetSnapRect() const
Definition: svdobj.cxx:1596
SfxItemSet GetGeoAttrFromMarked() const
Definition: svdedtv1.cxx:1356
bool IsVisible() const
Definition: svdobj.hxx:804
bool IsEmpty() const
SdrModel * mpModel
Definition: svdpntv.hxx:132
bool m_bMoveProtect
Definition: svdedtv.hxx:113
Provides information about various ZObject properties.
Definition: svdobj.hxx:248
#define SDRATTR_ALLPOSITIONX
Definition: svddef.hxx:279
void SetAttrToMarked(const SfxItemSet &rAttr, bool bReplaceAll)
Definition: svdedtv1.cxx:1046
const SfxPoolItem * NextItem()
SdrCrookMode
Definition: svdsnpv.hxx:83
long Right() const
void LogicToPagePos(Point &rPnt) const
Definition: svdpagv.hxx:210
void CrookRotatePoly(XPolygon &rPoly, const Point &rCenter, const Point &rRad, bool bVert)
Definition: svdtrans.cxx:290
void RotateMarkedObj(const Point &rRef, long nAngle, bool bCopy=false)
Definition: svdedtv1.cxx:312
bool IsMore() const
Definition: svditer.hxx:62
SdrPage * getSdrPageFromSdrObject() const
Definition: svdobj.cxx:262
OUString SvxResId(const char *pId)
Definition: dialmgr.cxx:28
double CrookStretchXPoint(Point &rPnt, Point *pC1, Point *pC2, const Point &rCenter, const Point &rRad, double &rSin, double &rCos, bool bVert, const tools::Rectangle &rRefRect)
Definition: svdtrans.cxx:270
#define X
Point BottomCenter() const
int nCount
tools::Rectangle aMarkRect
Definition: svddrgm1.hxx:142
void libreOfficeKitViewCallback(int nType, const char *pPayload) const override
SfxStyleSheet * GetStyleSheet() const
Definition: svdobj.cxx:2134
void DistortMarkedObj(const tools::Rectangle &rRef, const XPolygon &rDistortedRect, bool bNoContortion, bool bCopy=false)
Definition: svdedtv1.cxx:658
B2DHomMatrix createScaleTranslateB2DHomMatrix(double fScaleX, double fScaleY, double fTranslateX, double fTranslateY)
long Top() const
bool IsRotateAllowed(bool b90Deg=false) const
Definition: svdedtv.cxx:371
SdrOnOffItem makeSdrTextAutoGrowWidthItem(bool bAuto)
Definition: sdtagitm.hxx:29
const Point & GetPageOrigin() const
The Origin always refers to the upper left corner of the Page.
Definition: svdpagv.hxx:207
Point LeftCenter() const
void SetMoveProtect(bool bProt)
Definition: svdobj.cxx:2551
Point maRef1
Definition: svdmrkv.hxx:101
#define SDRATTR_TRANSFORMREF2Y
Definition: svddef.hxx:306
SfxStyleSheet * GetStyleSheet() const
Definition: svdedtv1.cxx:1337
#define SDRATTR_3DOBJ_END_ANGLE
Definition: svddef.hxx:333
void SetAttributes(const SfxItemSet &rSet, bool bReplaceAll)
Definition: svdedtv1.cxx:1328
virtual SdrObject * GetConnectedNode(bool bTail1) const
Definition: svdobj.cxx:2261
void EndUndo()
Definition: svdedtv.cxx:275
SdrVertAlign
Definition: svdedtv.hxx:44
SdrObject * GetMarkedSdrObj() const
Definition: svdmark.hxx:68
Point BottomRight() const
Everything a View needs to know about a selected object.
Definition: svdmark.hxx:44
SfxStyleSheet * GetStyleSheet() const
Definition: svdpntv.cxx:1003
void GetAttributes(SfxItemSet &rTargetSet, bool bOnlyHardAttr) const
Definition: svdpntv.cxx:983
SdrDragMode meDragMode
Definition: svdmrkv.hxx:112
RectPoint
Definition: rectenum.hxx:22
void AddUndo(std::unique_ptr< SdrUndoAction > pUndo)
Definition: svdedtv.hxx:183
std::vector< sal_uInt16 > GetAllCharPropIds(const SfxItemSet &rSet)
Definition: svdedtv1.cxx:1028
void CopyMarkedObj()
Definition: svdedtv.cxx:879
void CrookStretchPoly(XPolygon &rPoly, const Point &rCenter, const Point &rRad, bool bVert, const tools::Rectangle &rRefRect)
Definition: svdtrans.cxx:336
virtual const SdrPageGridFrameList * GetGridFrameList(const SdrPageView *pPV, const tools::Rectangle *pRect) const
for snap-to-grid in Writer, also for AlignObjects if 1 object is marked if pRect != null...
Definition: svdpage.cxx:1636
long GetMarkedObjShear() const
Definition: svdedtv1.cxx:448
virtual void MarkListHasChanged() override
Definition: svdedtv.cxx:351
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
#define DBG_ASSERT(sCon, aError)
int i
void ResizeMarkedObj(const Point &rRef, const Fraction &xFact, const Fraction &yFact, bool bCopy=false)
Definition: svdedtv1.cxx:216
void SetPathPoly(const basegfx::B2DPolyPolygon &rPathPoly)
Definition: svdopath.cxx:2738
uno_Any a
SdrMetricItem makeSdrEckenradiusItem(long nRadius)
Definition: sderitm.hxx:25
size_t GetMarkedObjectCount() const
Definition: svdmrkv.hxx:249
void MergeNotPersistAttrFromMarked(SfxItemSet &rAttr) const
Definition: svdedtv1.cxx:785
OUString const & GetDescriptionOfMarkedObjects() const
Definition: svdmrkv.hxx:252
#define EE_FEATURE_FIELD
bool m_bRotate90Allowed
Definition: svdedtv.hxx:101
sal_Int32 GetUpperBorder() const
Definition: svdpage.cxx:1490
#define SDRATTR_ROTATEALL
Definition: svddef.hxx:300
void BroadcastObjectChange() const
Definition: svdobj.cxx:904
bool m_bRotateFreeAllowed
Definition: svdedtv.hxx:100
const SdrMarkList & GetMarkedObjectList() const
Definition: svdmrkv.hxx:243
void SetRight(long v)
#define SDRATTR_3DOBJ_BACKSCALE
Definition: svddef.hxx:329
bool IsPrintable() const
Definition: svdobj.hxx:802
#define SDRATTR_VERTSHEARALL
Definition: svddef.hxx:302
void SetAttributes(const SfxItemSet &rSet, bool bReplaceAll)
Definition: svdpntv.cxx:998
void SetMergedItemSetAndBroadcast(const SfxItemSet &rSet, bool bClearAllItems=false)
Definition: svdobj.cxx:1923
bool bVertical
Definition: svddrgm1.hxx:155
static void ImpCrookObj(SdrObject *pO, const Point &rRef, const Point &rRad, SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bRotate, const tools::Rectangle &rMarkRect)
Definition: svdedtv1.cxx:502
long Bottom() const
virtual long GetShearAngle(bool bVertical=false) const
Definition: svdobj.cxx:1644
#define SDRATTR_3DOBJ_DEPTH
Definition: svddef.hxx:330
virtual void Move(const Size &rSiz)
Definition: svdobj.cxx:1466
void SetMergedItem(const SfxPoolItem &rItem)
Definition: svdobj.cxx:1893
bool isIdentity() const
bool IsResizeProtect() const
Definition: svdobj.hxx:800
#define SDRATTR_TRANSFORMREF2X
Definition: svddef.hxx:305
#define SDRATTR_TEXT_CONTOURFRAME
Definition: svddef.hxx:220
const SfxPoolItem & GetMergedItem(const sal_uInt16 nWhich) const
Definition: svdobj.cxx:1918
#define SDRATTR_TRANSFORMREF1X
Definition: svddef.hxx:303
Abstract DrawObject.
Definition: svdobj.hxx:312
virtual SfxViewShell * GetSfxViewShell() const
Get access to the view shell owning this draw view, if any.
Definition: svdmrkv.cxx:1564
#define SDRATTR_TEXT_MINFRAMEHEIGHT
Definition: svddef.hxx:200
SfxItemPool * GetPool() const
virtual void Mirror(const Point &rRef1, const Point &rRef2)
Definition: svdobj.cxx:1521
#define Y
void CrookMarkedObj(const Point &rRef, const Point &rRad, SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bCopy=false)
Definition: svdedtv1.cxx:580
#define SDRATTR_3DSCENE_DISTANCE
Definition: svddef.hxx:364
void SetAnimationTimer(sal_uInt32 nTime)
Definition: svdpntv.cxx:1193
bool m_bResizeFreeAllowed
Definition: svdedtv.hxx:98
sal_uInt16 GetCount() const
Definition: svdpage.hxx:303
virtual SdrLayerID GetLayer() const
Definition: svdobj.cxx:576
#define XATTR_LINEWIDTH
Definition: xdef.hxx:92
OString OUStringToOString(const OUString &str, ConnectionSettings const *settings)
void SetRef1(const Point &rPt)
Definition: svdmrkv.cxx:1542
Point aCenter
Definition: svddrgm1.hxx:144
void SetStyleSheetToMarked(SfxStyleSheet *pStyleSheet, bool bDontRemoveHardAttr)
Definition: svdedtv1.cxx:1281
#define SDRATTR_ALLSIZEHEIGHT
Definition: svddef.hxx:282
virtual const tools::Rectangle & GetLastBoundRect() const
Definition: svdobj.cxx:867
SdrObject * Next()
Definition: svditer.hxx:63
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
bool IsAlignPossible() const
Definition: svdedtv1.cxx:1830
bool m_bMoveAllowed
Definition: svdedtv.hxx:97
void SetStyleSheet(SfxStyleSheet *pStyleSheet, bool bDontRemoveHardAttr)
Definition: svdedtv1.cxx:1346
#define EE_CHAR_START
SfxItemState
const Point & GetRef2() const
Definition: svdmrkv.hxx:431
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
tools::Rectangle & Union(const tools::Rectangle &rRect)
#define SDRATTR_ALLPOSITIONY
Definition: svddef.hxx:280
OUString ImpGetDescriptionString(const char *pStrCacheID, ImpGetDescriptionOptions nOpt=ImpGetDescriptionOptions::NONE) const
Definition: svdmrkv.cxx:2383
bool m_bEdgeRadiusAllowed
Definition: svdedtv.hxx:106
void ShearMarkedObj(const Point &rRef, long nAngle, bool bVShear=false, bool bCopy=false)
Definition: svdedtv1.cxx:468
#define SDRATTR_RESIZEXALL
Definition: svddef.hxx:298
double CrookSlantXPoint(Point &rPnt, Point *pC1, Point *pC2, const Point &rCenter, const Point &rRad, double &rSin, double &rCos, bool bVert)
Definition: svdtrans.cxx:215
const SfxItemSet & GetMergedItemSet() const
Definition: svdobj.cxx:1883
bool m_bResizePropAllowed
Definition: svdedtv.hxx:99
#define SDRATTR_TEXT_AUTOGROWWIDTH
Definition: svddef.hxx:211
SfxStyleSheet * GetStyleSheetFromMarked() const
Definition: svdedtv1.cxx:1266
void SetBottom(long v)
#define F_PI18000
SfxItemSet GetAttrFromMarked(bool bOnlyHardAttr) const
Definition: svdedtv1.cxx:892
virtual long GetRotateAngle() const
Definition: svdobj.cxx:1639
void AddUndoActions(std::vector< std::unique_ptr< SdrUndoAction > >)
Definition: svdedtv1.cxx:176
SdrObject * GetMarkedObjectByIndex(size_t nNum) const
Definition: svdmrkv.hxx:248
long Left() const
const basegfx::B2DPolyPolygon & GetPathPoly() const
Definition: svdopath.hxx:139
static weld::MessageDialog * CreateMessageDialog(weld::Widget *pParent, VclMessageType eMessageType, VclButtonsType eButtonType, const OUString &rPrimaryMessage)
SdrPageView * GetSdrPageView() const
Definition: svdpntv.hxx:310
Helper for 3d object changes affecting 2d geometry.
virtual void Shear(const Point &rRef, long nAngle, double tn, bool bVShear)
Definition: svdobj.cxx:1530
virtual void SetSnapRect(const tools::Rectangle &rRect)
Definition: svdobj.cxx:1621
const sal_uInt16 * GetRanges() const
#define SDRATTR_TEXT_AUTOGROWHEIGHT
Definition: svddef.hxx:201
#define XATTR_LINESTARTWIDTH
Definition: xdef.hxx:96
SdrHorAlign
Definition: svdedtv.hxx:37
const SfxItemPool & GetItemPool() const
Definition: svdmodel.hxx:314
#define XATTR_LINECOLOR
Definition: xdef.hxx:93
virtual const tools::Rectangle & GetLogicRect() const
Definition: svdobj.cxx:1606
SdrMark * GetSdrMarkByIndex(size_t nNum) const
Definition: svdmrkv.hxx:247
#define EE_FEATURE_LINEBR
A SdrPage contains exactly one SdrObjList and a description of the physical page dimensions (size / m...
Definition: svdpage.hxx:366
#define SDRATTR_TRANSFORMREF1Y
Definition: svddef.hxx:304
sal_Int32 GetWidth() const
Definition: svdpage.cxx:1384
void CrookSlantPoly(XPolygon &rPoly, const Point &rCenter, const Point &rRad, bool bVert)
Definition: svdtrans.cxx:313
SdrCrookMode eMode
Definition: svddrgm1.hxx:164
void SetMarkedObjRect(const tools::Rectangle &rRect)
Definition: svdedtv1.cxx:76
virtual bool TRGetBaseGeometry(basegfx::B2DHomMatrix &rMatrix, basegfx::B2DPolyPolygon &rPolyPolygon) const
Definition: svdobj.cxx:2881
bool IsInvalidItem(const SfxPoolItem *pItem)
virtual void SetChanged()
Definition: svdobj.cxx:928
const SfxPoolItem * GetItem(sal_uInt16 nWhich, bool bSearchInParent=true) const
virtual Point GetPoint(sal_uInt32 i) const
Definition: svdobj.cxx:1669
SdrModel * GetModel() const
Definition: svdpntv.hxx:271
void SetRef2(const Point &rPt)
Definition: svdmrkv.cxx:1553
#define XATTR_LINETRANSPARENCE
Definition: xdef.hxx:100
aStr
Point TopRight() const
void SendUserCall(SdrUserCallType eUserCall, const tools::Rectangle &rBoundRect) const
Definition: svdobj.cxx:2648
void ApplyNotPersistAttr(const SfxItemSet &rAttr)
Definition: svdobj.cxx:1928
#define EE_CHAR_END
Point Center() const
bool IsMoveProtect() const
Definition: svdobj.hxx:798
Point TopCenter() const
const SfxPoolItem * GetCurItem() const
void Distort(const tools::Rectangle &rRefRect, const XPolygon &rDistortedRect)
Distort a polygon by scaling its coordinates relative to a reference rectangle into an arbitrary rect...
Definition: _xpoly.cxx:928
Utility class SdrEdgeObj.
Definition: svdoedge.hxx:128
const Point & GetRef1() const
Definition: svdmrkv.hxx:427
#define XATTR_FILLTRANSPARENCE
Definition: xdef.hxx:112
bool m_bOneOrMoreMovable
Definition: svdedtv.hxx:94
void MoveMarkedObj(const Size &rSiz, bool bCopy=false)
Definition: svdedtv1.cxx:182
#define SDRATTR_ECKENRADIUS
Definition: svddef.hxx:199