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