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