LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdedtv1.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 12 1053 1.1 %
Date: 2014-11-03 Functions: 5 35 14.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10