basegfx/source/polygon/b2dpolypolygon.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/polygon/b2dpolypolygon.hxx>
  21 #include <osl/diagnose.h>
  22 #include <basegfx/polygon/b2dpolygon.hxx>
  23 #include <basegfx/matrix/b2dhommatrix.hxx>
  24 #include <basegfx/utils/systemdependentdata.hxx>
  25 #include <algorithm>
  26
  27 class ImplB2DPolyPolygon
  28 {
  29     basegfx::B2DPolygonVector                               maPolygons;
  30     std::unique_ptr< basegfx::SystemDependentDataHolder >   mpSystemDependentDataHolder;
  31
  32 public:
  33     ImplB2DPolyPolygon()
  34     :   maPolygons(),
  35         mpSystemDependentDataHolder()
  36     {
  37     }
  38
  39     explicit ImplB2DPolyPolygon(const ImplB2DPolyPolygon& rSource)
  40     :   maPolygons(rSource.maPolygons),
  41         mpSystemDependentDataHolder()
  42     {
  43     }
  44
  45     explicit ImplB2DPolyPolygon(const basegfx::B2DPolygon& rToBeCopied)
  46     :   maPolygons(1,rToBeCopied),
  47         mpSystemDependentDataHolder()
  48     {
  49     }
  50
  51     ImplB2DPolyPolygon& operator=(const ImplB2DPolyPolygon& rSource)
  52     {
  53         if (this != &rSource)
  54         {
  55             maPolygons = rSource.maPolygons;
  56             mpSystemDependentDataHolder.reset();
  57         }
  58
  59         return *this;
  60     }
  61
  62     void addOrReplaceSystemDependentData(basegfx::SystemDependentData_SharedPtr& rData)
  63     {
  64         if(!mpSystemDependentDataHolder)
  65         {
  66             mpSystemDependentDataHolder.reset(new basegfx::SystemDependentDataHolder());
  67         }
  68
  69         mpSystemDependentDataHolder->addOrReplaceSystemDependentData(rData);
  70     }
  71
  72     basegfx::SystemDependentData_SharedPtr getSystemDependentData(size_t hash_code) const
  73     {
  74         if(!mpSystemDependentDataHolder)
  75         {
  76             return basegfx::SystemDependentData_SharedPtr();
  77         }
  78
  79         return mpSystemDependentDataHolder->getSystemDependentData(hash_code);
  80     }
  81
  82     bool operator==(const ImplB2DPolyPolygon& rPolygonList) const
  83     {
  84         return maPolygons == rPolygonList.maPolygons;
  85     }
  86
  87     const basegfx::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
  88     {
  89         return maPolygons[nIndex];
  90     }
  91
  92     void setB2DPolygon(sal_uInt32 nIndex, const basegfx::B2DPolygon& rPolygon)
  93     {
  94         maPolygons[nIndex] = rPolygon;
  95     }
  96
  97     void insert(sal_uInt32 nIndex, const basegfx::B2DPolygon& rPolygon, sal_uInt32 nCount)
  98     {
  99         if(nCount)
 100         {
 101             // add nCount copies of rPolygon
 102             basegfx::B2DPolygonVector::iterator aIndex(maPolygons.begin());
 103             if( nIndex )
 104                 aIndex += nIndex;
 105             maPolygons.insert(aIndex, nCount, rPolygon);
 106         }
 107     }
 108
 109     void insert(sal_uInt32 nIndex, const basegfx::B2DPolyPolygon& rPolyPolygon)
 110     {
 111         // add nCount polygons from rPolyPolygon
 112         basegfx::B2DPolygonVector::iterator aIndex(maPolygons.begin());
 113         if( nIndex )
 114             aIndex += nIndex;
 115         maPolygons.insert(aIndex, rPolyPolygon.begin(), rPolyPolygon.end());
 116     }
 117
 118     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 119     {
 120         if(nCount)
 121         {
 122             // remove polygon data
 123             basegfx::B2DPolygonVector::iterator aStart(maPolygons.begin());
 124             aStart += nIndex;
 125             const basegfx::B2DPolygonVector::iterator aEnd(aStart + nCount);
 126
 127             maPolygons.erase(aStart, aEnd);
 128         }
 129     }
 130
 131     sal_uInt32 count() const
 132     {
 133         return maPolygons.size();
 134     }
 135
 136     void setClosed(bool bNew)
 137     {
 138         for(basegfx::B2DPolygon & rPolygon : maPolygons)
 139         {
 140             rPolygon.setClosed(bNew);
 141         }
 142     }
 143
 144     void flip()
 145     {
 146         for (auto& aPolygon : maPolygons)
 147             aPolygon.flip();
 148     }
 149
 150     void removeDoublePoints()
 151     {
 152         for (auto& aPolygon : maPolygons)
 153             aPolygon.removeDoublePoints();
 154     }
 155
 156     void transform(const basegfx::B2DHomMatrix& rMatrix)
 157     {
 158         for (auto& aPolygon : maPolygons)
 159             aPolygon.transform(rMatrix);
 160     }
 161
 162     void makeUnique()
 163     {
 164         for (auto& aPolygon : maPolygons)
 165             aPolygon.makeUnique();
 166     }
 167
 168     const basegfx::B2DPolygon* begin() const
 169     {
 170         if (maPolygons.empty())
 171             return nullptr;
 172         else
 173             return maPolygons.data();
 174     }
 175
 176     const basegfx::B2DPolygon* end() const
 177     {
 178         if (maPolygons.empty())
 179             return nullptr;
 180         else
 181             return maPolygons.data() + maPolygons.size();
 182     }
 183
 184     basegfx::B2DPolygon* begin()
 185     {
 186         if (maPolygons.empty())
 187             return nullptr;
 188         else
 189             return maPolygons.data();
 190     }
 191
 192     basegfx::B2DPolygon* end()
 193     {
 194         if (maPolygons.empty())
 195             return nullptr;
 196         else
 197             return maPolygons.data() + maPolygons.size();
 198     }
 199 };
 200
 201 namespace basegfx
 202 {
 203
 204     B2DPolyPolygon::B2DPolyPolygon() = default;
 205
 206     B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon&) = default;
 207
 208     B2DPolyPolygon::B2DPolyPolygon(B2DPolyPolygon&&) = default;
 209
 210     B2DPolyPolygon::B2DPolyPolygon(const B2DPolygon& rPolygon) :
 211         mpPolyPolygon( ImplB2DPolyPolygon(rPolygon) )
 212     {
 213     }
 214
 215     B2DPolyPolygon::~B2DPolyPolygon() = default;
 216
 217     B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon&) = default;
 218
 219     B2DPolyPolygon& B2DPolyPolygon::operator=(B2DPolyPolygon&&) = default;
 220
 221     void B2DPolyPolygon::makeUnique()
 222     {
 223         mpPolyPolygon.make_unique();
 224         mpPolyPolygon->makeUnique();
 225     }
 226
 227     bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
 228     {
 229         if(mpPolyPolygon.same_object(rPolyPolygon.mpPolyPolygon))
 230             return true;
 231
 232         return ((*mpPolyPolygon) == (*rPolyPolygon.mpPolyPolygon));
 233     }
 234
 235     bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
 236     {
 237         return !((*this) == rPolyPolygon);
 238     }
 239
 240     sal_uInt32 B2DPolyPolygon::count() const
 241     {
 242         return mpPolyPolygon->count();
 243     }
 244
 245     B2DPolygon const & B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
 246     {
 247         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
 248
 249         return mpPolyPolygon->getB2DPolygon(nIndex);
 250     }
 251
 252     void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
 253     {
 254         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
 255
 256         if(getB2DPolygon(nIndex) != rPolygon)
 257             mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
 258     }
 259
 260     bool B2DPolyPolygon::areControlPointsUsed() const
 261     {
 262         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 263         {
 264             const B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
 265
 266             if(rPolygon.areControlPointsUsed())
 267             {
 268                 return true;
 269             }
 270         }
 271
 272         return false;
 273     }
 274
 275     void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
 276     {
 277         OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
 278
 279         if(nCount)
 280             mpPolyPolygon->insert(nIndex, rPolygon, nCount);
 281     }
 282
 283     void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
 284     {
 285         if(nCount)
 286             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
 287     }
 288
 289     B2DPolyPolygon B2DPolyPolygon::getDefaultAdaptiveSubdivision() const
 290     {
 291         B2DPolyPolygon aRetval;
 292
 293         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 294         {
 295             aRetval.append(mpPolyPolygon->getB2DPolygon(a).getDefaultAdaptiveSubdivision());
 296         }
 297
 298         return aRetval;
 299     }
 300
 301     B2DRange B2DPolyPolygon::getB2DRange() const
 302     {
 303         B2DRange aRetval;
 304
 305         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 306         {
 307             aRetval.expand(mpPolyPolygon->getB2DPolygon(a).getB2DRange());
 308         }
 309
 310         return aRetval;
 311     }
 312
 313     void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
 314     {
 315         OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
 316
 317         if(rPolyPolygon.count())
 318             mpPolyPolygon->insert(nIndex, rPolyPolygon);
 319     }
 320
 321     void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
 322     {
 323         if(rPolyPolygon.count())
 324             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
 325     }
 326
 327     void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 328     {
 329         OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
 330
 331         if(nCount)
 332             mpPolyPolygon->remove(nIndex, nCount);
 333     }
 334
 335     void B2DPolyPolygon::clear()
 336     {
 337         *mpPolyPolygon = ImplB2DPolyPolygon();
 338     }
 339
 340     bool B2DPolyPolygon::isClosed() const
 341     {
 342         bool bRetval(true);
 343
 344         // PolyPOlygon is closed when all contained Polygons are closed or
 345         // no Polygon exists.
 346         for(sal_uInt32 a(0); bRetval && a < mpPolyPolygon->count(); a++)
 347         {
 348             if(!mpPolyPolygon->getB2DPolygon(a).isClosed())
 349             {
 350                 bRetval = false;
 351             }
 352         }
 353
 354         return bRetval;
 355     }
 356
 357     void B2DPolyPolygon::setClosed(bool bNew)
 358     {
 359         if(bNew != isClosed())
 360             mpPolyPolygon->setClosed(bNew);
 361     }
 362
 363     void B2DPolyPolygon::flip()
 364     {
 365         if(mpPolyPolygon->count())
 366         {
 367             mpPolyPolygon->flip();
 368         }
 369     }
 370
 371     bool B2DPolyPolygon::hasDoublePoints() const
 372     {
 373         bool bRetval(false);
 374
 375         for(sal_uInt32 a(0); !bRetval && a < mpPolyPolygon->count(); a++)
 376         {
 377             if(mpPolyPolygon->getB2DPolygon(a).hasDoublePoints())
 378             {
 379                 bRetval = true;
 380             }
 381         }
 382
 383         return bRetval;
 384     }
 385
 386     void B2DPolyPolygon::removeDoublePoints()
 387     {
 388         if(hasDoublePoints())
 389             mpPolyPolygon->removeDoublePoints();
 390     }
 391
 392     void B2DPolyPolygon::transform(const B2DHomMatrix& rMatrix)
 393     {
 394         if(mpPolyPolygon->count() && !rMatrix.isIdentity())
 395         {
 396             mpPolyPolygon->transform(rMatrix);
 397         }
 398     }
 399
 400     const B2DPolygon* B2DPolyPolygon::begin() const
 401     {
 402         return mpPolyPolygon->begin();
 403     }
 404
 405     const B2DPolygon* B2DPolyPolygon::end() const
 406     {
 407         return mpPolyPolygon->end();
 408     }
 409
 410     B2DPolygon* B2DPolyPolygon::begin()
 411     {
 412         return mpPolyPolygon->begin();
 413     }
 414
 415     B2DPolygon* B2DPolyPolygon::end()
 416     {
 417         return mpPolyPolygon->end();
 418     }
 419
 420     void B2DPolyPolygon::addOrReplaceSystemDependentDataInternal(SystemDependentData_SharedPtr& rData) const
 421     {
 422         // Need to get ImplB2DPolyPolygon* from cow_wrapper *without*
 423         // calling make_unique() here - we do not want to
 424         // 'modify' the ImplB2DPolyPolygon, but add buffered data that
 425         // is valid for all referencing instances
 426         const B2DPolyPolygon* pMe(this);
 427         const ImplB2DPolyPolygon* pMyImpl(pMe->mpPolyPolygon.get());
 428
 429         const_cast<ImplB2DPolyPolygon*>(pMyImpl)->addOrReplaceSystemDependentData(rData);
 430     }
 431
 432     SystemDependentData_SharedPtr B2DPolyPolygon::getSystemDependantDataInternal(size_t hash_code) const
 433     {
 434         return mpPolyPolygon->getSystemDependentData(hash_code);
 435     }
 436
 437 } // end of namespace basegfx
 438
 439 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */