sd/source/ui/func/fumorph.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 <fumorph.hxx>
  21 #include <svx/xlnclit.hxx>
  22 #include <svx/xlnwtit.hxx>
  23 #include <svx/xflclit.hxx>
  24 #include <svx/svdopath.hxx>
  25 #include <svx/svdogrp.hxx>
  26 #include <editeng/eeitem.hxx>
  27 #include <editeng/outlobj.hxx>
  28
  29 #include <View.hxx>
  30 #include <Window.hxx>
  31 #include <basegfx/polygon/b2dpolygontools.hxx>
  32 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  33 #include <basegfx/matrix/b2dhommatrix.hxx>
  34 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  35
  36 #include <strings.hrc>
  37 #include <sdresid.hxx>
  38
  39 #include <sdabstdlg.hxx>
  40
  41 #include <svx/svditer.hxx>
  42
  43 #include <basegfx/color/bcolor.hxx>
  44 #include <com/sun/star/drawing/LineStyle.hpp>
  45
  46 using namespace com::sun::star;
  47
  48 namespace sd {
  49
  50 FuMorph::FuMorph (
  51     ViewShell* pViewSh,
  52     ::sd::Window* pWin,
  53     ::sd::View* pView,
  54     SdDrawDocument* pDoc,
  55     SfxRequest& rReq )
  56     :   FuPoor(pViewSh, pWin, pView, pDoc, rReq)
  57 {
  58 }
  59
  60 rtl::Reference<FuPoor> FuMorph::Create(
  61     ViewShell* pViewSh,
  62     ::sd::Window* pWin,
  63     ::sd::View* pView,
  64     SdDrawDocument* pDoc,
  65     SfxRequest& rReq
  66 )
  67 {
  68     rtl::Reference<FuPoor> xFunc( new FuMorph( pViewSh, pWin, pView, pDoc, rReq ) );
  69     xFunc->DoExecute(rReq);
  70     return xFunc;
  71 }
  72
  73 void FuMorph::DoExecute( SfxRequest& )
  74 {
  75     const SdrMarkList&  rMarkList = mpView->GetMarkedObjectList();
  76
  77     if(rMarkList.GetMarkCount() != 2)
  78         return;
  79
  80     // create clones
  81     SdrObject*  pObj1 = rMarkList.GetMark(0)->GetMarkedSdrObj();
  82     SdrObject*  pObj2 = rMarkList.GetMark(1)->GetMarkedSdrObj();
  83     SdrObject*  pCloneObj1(pObj1->CloneSdrObject(pObj1->getSdrModelFromSdrObject()));
  84     SdrObject*  pCloneObj2(pObj2->CloneSdrObject(pObj2->getSdrModelFromSdrObject()));
  85
  86     // delete text at clone, otherwise we do net get a correct PathObj
  87     pCloneObj1->SetOutlinerParaObject(nullptr);
  88     pCloneObj2->SetOutlinerParaObject(nullptr);
  89
  90     // create path objects
  91     SdrObject*  pPolyObj1 = pCloneObj1->ConvertToPolyObj(false, false);
  92     SdrObject*  pPolyObj2 = pCloneObj2->ConvertToPolyObj(false, false);
  93     SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
  94     ScopedVclPtr<AbstractMorphDlg> pDlg( pFact->CreateMorphDlg(mpWindow ? mpWindow->GetFrameWeld() : nullptr, pObj1, pObj2) );
  95     if(pPolyObj1 && pPolyObj2 && (pDlg->Execute() == RET_OK))
  96     {
  97         B2DPolyPolygonList_impl aPolyPolyList;
  98         ::basegfx::B2DPolyPolygon aPolyPoly1;
  99         ::basegfx::B2DPolyPolygon aPolyPoly2;
 100
 101         pDlg->SaveSettings();
 102
 103         // #i48168# Not always is the pPolyObj1/pPolyObj2 a SdrPathObj, it may also be a group object
 104         // containing SdrPathObjs. To get the polygons, I add two iters here
 105         SdrObjListIter aIter1(*pPolyObj1);
 106         SdrObjListIter aIter2(*pPolyObj2);
 107
 108         while(aIter1.IsMore())
 109         {
 110             SdrObject* pObj = aIter1.Next();
 111             if(auto pPathObj = dynamic_cast< SdrPathObj *>( pObj ))
 112                 aPolyPoly1.append(pPathObj->GetPathPoly());
 113         }
 114
 115         while(aIter2.IsMore())
 116         {
 117             SdrObject* pObj = aIter2.Next();
 118             if(auto pPathObj = dynamic_cast< SdrPathObj *>( pObj ))
 119                 aPolyPoly2.append(pPathObj->GetPathPoly());
 120         }
 121
 122         // perform morphing
 123         if(aPolyPoly1.count() && aPolyPoly2.count())
 124         {
 125             aPolyPoly1 = ::basegfx::utils::correctOrientations(aPolyPoly1);
 126             aPolyPoly1.removeDoublePoints();
 127             ::basegfx::B2VectorOrientation eIsClockwise1(::basegfx::utils::getOrientation(aPolyPoly1.getB2DPolygon(0)));
 128
 129             aPolyPoly2 = ::basegfx::utils::correctOrientations(aPolyPoly2);
 130             aPolyPoly2.removeDoublePoints();
 131             ::basegfx::B2VectorOrientation eIsClockwise2(::basegfx::utils::getOrientation(aPolyPoly2.getB2DPolygon(0)));
 132
 133             // set same orientation
 134             if(eIsClockwise1 != eIsClockwise2)
 135                 aPolyPoly2.flip();
 136
 137             // force same poly count
 138             if(aPolyPoly1.count() < aPolyPoly2.count())
 139                 ImpAddPolys(aPolyPoly1, aPolyPoly2);
 140             else if(aPolyPoly2.count() < aPolyPoly1.count())
 141                 ImpAddPolys(aPolyPoly2, aPolyPoly1);
 142
 143             // use orientation flag from dialog
 144             if(!pDlg->IsOrientationFade())
 145                 aPolyPoly2.flip();
 146
 147             // force same point counts
 148             for( sal_uInt32 a(0); a < aPolyPoly1.count(); a++ )
 149             {
 150                 ::basegfx::B2DPolygon aSub1(aPolyPoly1.getB2DPolygon(a));
 151                 ::basegfx::B2DPolygon aSub2(aPolyPoly2.getB2DPolygon(a));
 152
 153                 if(aSub1.count() < aSub2.count())
 154                     ImpEqualizePolyPointCount(aSub1, aSub2);
 155                 else if(aSub2.count() < aSub1.count())
 156                     ImpEqualizePolyPointCount(aSub2, aSub1);
 157
 158                 aPolyPoly1.setB2DPolygon(a, aSub1);
 159                 aPolyPoly2.setB2DPolygon(a, aSub2);
 160             }
 161
 162             ImpMorphPolygons(aPolyPoly1, aPolyPoly2, pDlg->GetFadeSteps(), aPolyPolyList);
 163
 164             OUString aString(mpView->GetDescriptionOfMarkedObjects());
 165             aString += " " + SdResId(STR_UNDO_MORPHING);
 166
 167             mpView->BegUndo(aString);
 168             ImpInsertPolygons(aPolyPolyList, pDlg->IsAttributeFade(), pObj1, pObj2);
 169             mpView->EndUndo();
 170         }
 171     }
 172     SdrObject::Free( pCloneObj1 );
 173     SdrObject::Free( pCloneObj2 );
 174
 175     SdrObject::Free( pPolyObj1 );
 176     SdrObject::Free( pPolyObj2 );
 177 }
 178
 179 static ::basegfx::B2DPolygon ImpGetExpandedPolygon(
 180     const ::basegfx::B2DPolygon& rCandidate,
 181     sal_uInt32 nNum
 182 )
 183 {
 184     if(rCandidate.count() && nNum && rCandidate.count() != nNum)
 185     {
 186         // length of step in dest poly
 187         ::basegfx::B2DPolygon aRetval;
 188         const double fStep(::basegfx::utils::getLength(rCandidate) / static_cast<double>(rCandidate.isClosed() ? nNum : nNum - 1));
 189         double fDestPos(0.0);
 190         double fSrcPos(0.0);
 191         sal_uInt32 nSrcPos(0);
 192         sal_uInt32 nSrcPosNext((nSrcPos + 1 == rCandidate.count()) ? 0L : nSrcPos + 1);
 193         double fNextSrcLen(::basegfx::B2DVector(rCandidate.getB2DPoint(nSrcPos) - rCandidate.getB2DPoint(nSrcPosNext)).getLength());
 194
 195         for(sal_uInt32 b(0); b < nNum; b++)
 196         {
 197             // calc fDestPos in source
 198             while(fSrcPos + fNextSrcLen < fDestPos)
 199             {
 200                 fSrcPos += fNextSrcLen;
 201                 nSrcPos++;
 202                 nSrcPosNext = (nSrcPos + 1 == rCandidate.count()) ? 0L : nSrcPos + 1;
 203                 fNextSrcLen = ::basegfx::B2DVector(rCandidate.getB2DPoint(nSrcPos) - rCandidate.getB2DPoint(nSrcPosNext)).getLength();
 204             }
 205
 206             // fDestPos is between fSrcPos and (fSrcPos + fNextSrcLen)
 207             const double fLenA((fDestPos - fSrcPos) / fNextSrcLen);
 208             const ::basegfx::B2DPoint aOld1(rCandidate.getB2DPoint(nSrcPos));
 209             const ::basegfx::B2DPoint aOld2(rCandidate.getB2DPoint(nSrcPosNext));
 210             ::basegfx::B2DPoint aNewPoint(basegfx::interpolate(aOld1, aOld2, fLenA));
 211             aRetval.append(aNewPoint);
 212
 213             // next step
 214             fDestPos += fStep;
 215         }
 216
 217         if(aRetval.count() >= 3)
 218         {
 219             aRetval.setClosed(rCandidate.isClosed());
 220         }
 221
 222         return aRetval;
 223     }
 224     else
 225     {
 226         return rCandidate;
 227     }
 228 }
 229
 230 /**
 231  * make the point count of the polygons equal in adding points
 232  */
 233 void FuMorph::ImpEqualizePolyPointCount(
 234     ::basegfx::B2DPolygon& rSmall,
 235     const ::basegfx::B2DPolygon& rBig
 236 )
 237 {
 238     // create poly with equal point count
 239     const sal_uInt32 nCnt(rBig.count());
 240     ::basegfx::B2DPolygon aPoly1(ImpGetExpandedPolygon(rSmall, nCnt));
 241
 242     // create transformation for rBig to do the compare
 243     const ::basegfx::B2DRange aSrcSize(::basegfx::utils::getRange(rBig));
 244     const ::basegfx::B2DPoint aSrcPos(aSrcSize.getCenter());
 245     const ::basegfx::B2DRange aDstSize(::basegfx::utils::getRange(rSmall));
 246     const ::basegfx::B2DPoint aDstPos(aDstSize.getCenter());
 247
 248     basegfx::B2DHomMatrix aTrans(basegfx::utils::createTranslateB2DHomMatrix(-aSrcPos.getX(), -aSrcPos.getY()));
 249     aTrans.scale(aDstSize.getWidth() / aSrcSize.getWidth(), aDstSize.getHeight() / aSrcSize.getHeight());
 250     aTrans.translate(aDstPos.getX(), aDstPos.getY());
 251
 252     // transpose points to have smooth linear blending
 253     ::basegfx::B2DPolygon aPoly2;
 254     aPoly2.append(::basegfx::B2DPoint(), nCnt);
 255     sal_uInt32 nInd(ImpGetNearestIndex(aPoly1, aTrans * rBig.getB2DPoint(0)));
 256
 257     for(sal_uInt32 a(0); a < nCnt; a++)
 258     {
 259         aPoly2.setB2DPoint((a + nCnt - nInd) % nCnt, aPoly1.getB2DPoint(a));
 260     }
 261
 262     aPoly2.setClosed(rBig.isClosed());
 263     rSmall = aPoly2;
 264 }
 265
 266 sal_uInt32 FuMorph::ImpGetNearestIndex(
 267     const ::basegfx::B2DPolygon& rPoly,
 268     const ::basegfx::B2DPoint& rPos
 269 )
 270 {
 271     double fMinDist = 0.0;
 272     sal_uInt32 nActInd = 0;
 273
 274     for(sal_uInt32 a(0); a < rPoly.count(); a++)
 275     {
 276         double fNewDist(::basegfx::B2DVector(rPoly.getB2DPoint(a) - rPos).getLength());
 277
 278         if(!a || fNewDist < fMinDist)
 279         {
 280             fMinDist = fNewDist;
 281             nActInd = a;
 282         }
 283     }
 284
 285     return nActInd;
 286 }
 287
 288 /**
 289  * add to a point reduced polys until count is same
 290  */
 291 void FuMorph::ImpAddPolys(
 292     ::basegfx::B2DPolyPolygon& rSmaller,
 293     const ::basegfx::B2DPolyPolygon& rBigger
 294 )
 295 {
 296     while(rSmaller.count() < rBigger.count())
 297     {
 298         const ::basegfx::B2DPolygon& aToBeCopied(rBigger.getB2DPolygon(rSmaller.count()));
 299         const ::basegfx::B2DRange aToBeCopiedPolySize(::basegfx::utils::getRange(aToBeCopied));
 300         ::basegfx::B2DPoint aNewPoint(aToBeCopiedPolySize.getCenter());
 301         ::basegfx::B2DPolygon aNewPoly;
 302
 303         const ::basegfx::B2DRange aSrcSize(::basegfx::utils::getRange(rBigger.getB2DPolygon(0)));
 304         const ::basegfx::B2DPoint aSrcPos(aSrcSize.getCenter());
 305         const ::basegfx::B2DRange aDstSize(::basegfx::utils::getRange(rSmaller.getB2DPolygon(0)));
 306         const ::basegfx::B2DPoint aDstPos(aDstSize.getCenter());
 307         aNewPoint = aNewPoint - aSrcPos + aDstPos;
 308
 309         for(sal_uInt32 a(0); a < aToBeCopied.count(); a++)
 310         {
 311             aNewPoly.append(aNewPoint);
 312         }
 313
 314         rSmaller.append(aNewPoly);
 315     }
 316 }
 317
 318 /**
 319  * create group object with morphed polygons
 320  */
 321 void FuMorph::ImpInsertPolygons(
 322     B2DPolyPolygonList_impl& rPolyPolyList3D,
 323     bool bAttributeFade,
 324     const SdrObject* pObj1,
 325     const SdrObject* pObj2
 326 )
 327 {
 328     Color               aStartFillCol;
 329     Color               aEndFillCol;
 330     Color               aStartLineCol;
 331     Color               aEndLineCol;
 332     long                nStartLineWidth = 0;
 333     long                nEndLineWidth = 0;
 334     SdrPageView*        pPageView = mpView->GetSdrPageView();
 335     SfxItemPool &       rPool = pObj1->GetObjectItemPool();
 336     SfxItemSet          aSet1( rPool,svl::Items<SDRATTR_START,SDRATTR_NOTPERSIST_FIRST-1,EE_ITEMS_START,EE_ITEMS_END>{} );
 337     SfxItemSet          aSet2( aSet1 );
 338     bool                bLineColor = false;
 339     bool                bFillColor = false;
 340     bool                bLineWidth = false;
 341     bool                bIgnoreLine = false;
 342     bool                bIgnoreFill = false;
 343
 344     aSet1.Put(pObj1->GetMergedItemSet());
 345     aSet2.Put(pObj2->GetMergedItemSet());
 346
 347     const drawing::LineStyle eLineStyle1 = aSet1.Get(XATTR_LINESTYLE).GetValue();
 348     const drawing::LineStyle eLineStyle2 = aSet2.Get(XATTR_LINESTYLE).GetValue();
 349     const drawing::FillStyle eFillStyle1 = aSet1.Get(XATTR_FILLSTYLE).GetValue();
 350     const drawing::FillStyle eFillStyle2 = aSet2.Get(XATTR_FILLSTYLE).GetValue();
 351
 352     if ( bAttributeFade )
 353     {
 354         if ( ( eLineStyle1 != drawing::LineStyle_NONE ) && ( eLineStyle2 != drawing::LineStyle_NONE ) )
 355         {
 356             bLineWidth = bLineColor = true;
 357
 358             aStartLineCol = aSet1.Get(XATTR_LINECOLOR).GetColorValue();
 359             aEndLineCol = aSet2.Get(XATTR_LINECOLOR).GetColorValue();
 360
 361             nStartLineWidth = aSet1.Get(XATTR_LINEWIDTH).GetValue();
 362             nEndLineWidth = aSet2.Get(XATTR_LINEWIDTH).GetValue();
 363         }
 364         else if ( ( eLineStyle1 == drawing::LineStyle_NONE ) && ( eLineStyle2 == drawing::LineStyle_NONE ) )
 365             bIgnoreLine = true;
 366
 367         if ( ( eFillStyle1 == drawing::FillStyle_SOLID ) && ( eFillStyle2 == drawing::FillStyle_SOLID ) )
 368         {
 369             bFillColor = true;
 370             aStartFillCol = aSet1.Get(XATTR_FILLCOLOR).GetColorValue();
 371             aEndFillCol = aSet2.Get(XATTR_FILLCOLOR).GetColorValue();
 372         }
 373         else if ( ( eFillStyle1 == drawing::FillStyle_NONE ) && ( eFillStyle2 == drawing::FillStyle_NONE ) )
 374             bIgnoreFill = true;
 375     }
 376
 377     if ( !pPageView )
 378         return;
 379
 380     SfxItemSet      aSet( aSet1 );
 381     SdrObjGroup*    pObjGroup = new SdrObjGroup(mpView->getSdrModelFromSdrView());
 382     SdrObjList*     pObjList = pObjGroup->GetSubList();
 383     const size_t    nCount = rPolyPolyList3D.size();
 384     const double    fStep = 1. / ( nCount + 1 );
 385     const double    fDelta = nEndLineWidth - nStartLineWidth;
 386     double          fFactor = fStep;
 387
 388     aSet.Put( XLineStyleItem( drawing::LineStyle_SOLID ) );
 389     aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) );
 390
 391     for ( size_t i = 0; i < nCount; i++, fFactor += fStep )
 392     {
 393         const ::basegfx::B2DPolyPolygon& rPolyPoly3D = rPolyPolyList3D[ i ];
 394         SdrPathObj* pNewObj = new SdrPathObj(
 395             mpView->getSdrModelFromSdrView(),
 396             OBJ_POLY,
 397             rPolyPoly3D);
 398
 399         // line color
 400         if ( bLineColor )
 401         {
 402             const basegfx::BColor aLineColor(basegfx::interpolate(aStartLineCol.getBColor(), aEndLineCol.getBColor(), fFactor));
 403             aSet.Put( XLineColorItem( "", Color(aLineColor)));
 404         }
 405         else if ( bIgnoreLine )
 406             aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) );
 407
 408         // fill color
 409         if ( bFillColor )
 410         {
 411             const basegfx::BColor aFillColor(basegfx::interpolate(aStartFillCol.getBColor(), aEndFillCol.getBColor(), fFactor));
 412             aSet.Put( XFillColorItem( "", Color(aFillColor)));
 413         }
 414         else if ( bIgnoreFill )
 415             aSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) );
 416
 417         // line width
 418         if ( bLineWidth )
 419             aSet.Put( XLineWidthItem( nStartLineWidth + static_cast<long>( fFactor * fDelta + 0.5 ) ) );
 420
 421         pNewObj->SetMergedItemSetAndBroadcast(aSet);
 422
 423         pObjList->InsertObject( pNewObj );
 424     }
 425
 426     if ( nCount )
 427     {
 428         pObjList->InsertObject(
 429             pObj1->CloneSdrObject(pObj1->getSdrModelFromSdrObject()),
 430             0 );
 431         pObjList->InsertObject(
 432             pObj2->CloneSdrObject(pObj2->getSdrModelFromSdrObject()) );
 433
 434         mpView->DeleteMarked();
 435         mpView->InsertObjectAtView( pObjGroup, *pPageView, SdrInsertFlags:: SETDEFLAYER );
 436     }
 437 }
 438
 439 /**
 440  * create single morphed PolyPolygon
 441  */
 442 ::basegfx::B2DPolyPolygon FuMorph::ImpCreateMorphedPolygon(
 443     const ::basegfx::B2DPolyPolygon& rPolyPolyStart,
 444     const ::basegfx::B2DPolyPolygon& rPolyPolyEnd,
 445     double fMorphingFactor
 446 )
 447 {
 448     ::basegfx::B2DPolyPolygon aNewPolyPolygon;
 449     const double fFactor = 1.0 - fMorphingFactor;
 450
 451     for(sal_uInt32 a(0); a < rPolyPolyStart.count(); a++)
 452     {
 453         const ::basegfx::B2DPolygon& aPolyStart(rPolyPolyStart.getB2DPolygon(a));
 454         const ::basegfx::B2DPolygon& aPolyEnd(rPolyPolyEnd.getB2DPolygon(a));
 455         const sal_uInt32 nCount(aPolyStart.count());
 456         ::basegfx::B2DPolygon aNewPolygon;
 457
 458         for(sal_uInt32 b(0); b < nCount; b++)
 459         {
 460             const ::basegfx::B2DPoint& aPtStart(aPolyStart.getB2DPoint(b));
 461             const ::basegfx::B2DPoint& aPtEnd(aPolyEnd.getB2DPoint(b));
 462             aNewPolygon.append(aPtEnd + ((aPtStart - aPtEnd) * fFactor));
 463         }
 464
 465         aNewPolygon.setClosed(aPolyStart.isClosed() && aPolyEnd.isClosed());
 466         aNewPolyPolygon.append(aNewPolygon);
 467     }
 468
 469     return aNewPolyPolygon;
 470 }
 471
 472 /**
 473  * create morphed PolyPolygons
 474  */
 475 void FuMorph::ImpMorphPolygons(
 476     const ::basegfx::B2DPolyPolygon& rPolyPoly1,
 477     const ::basegfx::B2DPolyPolygon& rPolyPoly2,
 478     const sal_uInt16 nSteps,
 479     B2DPolyPolygonList_impl& rPolyPolyList3D
 480 )
 481 {
 482     if(!nSteps)
 483         return;
 484
 485     const ::basegfx::B2DRange aStartPolySize(::basegfx::utils::getRange(rPolyPoly1));
 486     const ::basegfx::B2DPoint aStartCenter(aStartPolySize.getCenter());
 487     const ::basegfx::B2DRange aEndPolySize(::basegfx::utils::getRange(rPolyPoly2));
 488     const ::basegfx::B2DPoint aEndCenter(aEndPolySize.getCenter());
 489     const ::basegfx::B2DPoint aDelta(aEndCenter - aStartCenter);
 490     const double fFactor(1.0 / (nSteps + 1));
 491     double fValue(0.0);
 492
 493     for(sal_uInt16 i(0); i < nSteps; i++)
 494     {
 495         fValue += fFactor;
 496         ::basegfx::B2DPolyPolygon aNewPolyPoly2D = ImpCreateMorphedPolygon(rPolyPoly1, rPolyPoly2, fValue);
 497
 498         const ::basegfx::B2DRange aNewPolySize(::basegfx::utils::getRange(aNewPolyPoly2D));
 499         const ::basegfx::B2DPoint aNewS(aNewPolySize.getCenter());
 500         const ::basegfx::B2DPoint aRealS(aStartCenter + (aDelta * fValue));
 501         const ::basegfx::B2DPoint aDiff(aRealS - aNewS);
 502
 503         aNewPolyPoly2D.transform(basegfx::utils::createTranslateB2DHomMatrix(aDiff));
 504         rPolyPolyList3D.push_back( std::move(aNewPolyPoly2D) );
 505     }
 506 }
 507
 508 } // end of namespace sd
 509
 510 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */