svx/source/svdraw/svdedtv1.cxx

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