basegfx/source/polygon/b2dpolypolygon.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b2dpolypolygon.cxx,v $
  10  * $Revision: 1.21.4.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <basegfx/polygon/b2dpolypolygon.hxx>
  34 #include <osl/diagnose.h>
  35 #include <basegfx/polygon/b2dpolygon.hxx>
  36 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  37 #include <rtl/instance.hxx>
  38 #include <basegfx/matrix/b2dhommatrix.hxx>
  39
  40 #include <functional>
  41 #include <vector>
  42 #include <algorithm>
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45
  46 class ImplB2DPolyPolygon
  47 {
  48     typedef ::std::vector< basegfx::B2DPolygon >        PolygonVector;
  49
  50     PolygonVector                                                                       maPolygons;
  51
  52 public:
  53     ImplB2DPolyPolygon() : maPolygons()
  54     {
  55     }
  56
  57     ImplB2DPolyPolygon(const basegfx::B2DPolygon& rToBeCopied) :
  58         maPolygons(1,rToBeCopied)
  59     {
  60     }
  61
  62     bool operator==(const ImplB2DPolyPolygon& rPolygonList) const
  63     {
  64         // same polygon count?
  65         if(maPolygons.size() != rPolygonList.maPolygons.size())
  66             return false;
  67
  68         // compare polygon content
  69         if(!(maPolygons == rPolygonList.maPolygons))
  70             return false;
  71
  72         return true;
  73     }
  74
  75     const basegfx::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
  76     {
  77         return maPolygons[nIndex];
  78     }
  79
  80     void setB2DPolygon(sal_uInt32 nIndex, const basegfx::B2DPolygon& rPolygon)
  81     {
  82         maPolygons[nIndex] = rPolygon;
  83     }
  84
  85     void insert(sal_uInt32 nIndex, const basegfx::B2DPolygon& rPolygon, sal_uInt32 nCount)
  86     {
  87         if(nCount)
  88         {
  89             // add nCount copies of rPolygon
  90             PolygonVector::iterator aIndex(maPolygons.begin());
  91             aIndex += nIndex;
  92             maPolygons.insert(aIndex, nCount, rPolygon);
  93         }
  94     }
  95
  96     void insert(sal_uInt32 nIndex, const basegfx::B2DPolyPolygon& rPolyPolygon)
  97     {
  98         const sal_uInt32 nCount = rPolyPolygon.count();
  99
 100         if(nCount)
 101         {
 102             // add nCount polygons from rPolyPolygon
 103             maPolygons.reserve(maPolygons.size() + nCount);
 104             PolygonVector::iterator aIndex(maPolygons.begin());
 105             aIndex += nIndex;
 106
 107             for(sal_uInt32 a(0L); a < nCount; a++)
 108             {
 109                 aIndex = maPolygons.insert(aIndex, rPolyPolygon.getB2DPolygon(a));
 110                 aIndex++;
 111             }
 112         }
 113     }
 114
 115     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 116     {
 117         if(nCount)
 118         {
 119             // remove polygon data
 120             PolygonVector::iterator aStart(maPolygons.begin());
 121             aStart += nIndex;
 122             const PolygonVector::iterator aEnd(aStart + nCount);
 123
 124             maPolygons.erase(aStart, aEnd);
 125         }
 126     }
 127
 128     sal_uInt32 count() const
 129     {
 130         return maPolygons.size();
 131     }
 132
 133     void setClosed(bool bNew)
 134     {
 135         for(sal_uInt32 a(0L); a < maPolygons.size(); a++)
 136         {
 137             maPolygons[a].setClosed(bNew);
 138         }
 139     }
 140
 141     void flip()
 142     {
 143         std::for_each( maPolygons.begin(),
 144                        maPolygons.end(),
 145                        std::mem_fun_ref( &basegfx::B2DPolygon::flip ));
 146     }
 147
 148     void removeDoublePoints()
 149     {
 150         std::for_each( maPolygons.begin(),
 151                        maPolygons.end(),
 152                        std::mem_fun_ref( &basegfx::B2DPolygon::removeDoublePoints ));
 153     }
 154
 155     void transform(const basegfx::B2DHomMatrix& rMatrix)
 156     {
 157         for(sal_uInt32 a(0L); a < maPolygons.size(); a++)
 158         {
 159             maPolygons[a].transform(rMatrix);
 160         }
 161     }
 162
 163     void makeUnique()
 164     {
 165         std::for_each( maPolygons.begin(),
 166                        maPolygons.end(),
 167                        std::mem_fun_ref( &basegfx::B2DPolygon::makeUnique ));
 168     }
 169 };
 170
 171 //////////////////////////////////////////////////////////////////////////////
 172
 173 namespace basegfx
 174 {
 175     namespace { struct DefaultPolyPolygon: public rtl::Static<B2DPolyPolygon::ImplType,
 176                                                               DefaultPolyPolygon> {}; }
 177
 178     B2DPolyPolygon::B2DPolyPolygon() :
 179         mpPolyPolygon(DefaultPolyPolygon::get())
 180     {
 181     }
 182
 183     B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon) :
 184         mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
 185     {
 186     }
 187
 188     B2DPolyPolygon::B2DPolyPolygon(const B2DPolygon& rPolygon) :
 189         mpPolyPolygon( ImplB2DPolyPolygon(rPolygon) )
 190     {
 191     }
 192
 193     B2DPolyPolygon::~B2DPolyPolygon()
 194     {
 195     }
 196
 197     B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon& rPolyPolygon)
 198     {
 199         mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
 200         return *this;
 201     }
 202
 203     void B2DPolyPolygon::makeUnique()
 204     {
 205         mpPolyPolygon.make_unique();
 206         mpPolyPolygon->makeUnique();
 207     }
 208
 209     bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
 210     {
 211         if(mpPolyPolygon.same_object(rPolyPolygon.mpPolyPolygon))
 212             return true;
 213
 214         return ((*mpPolyPolygon) == (*rPolyPolygon.mpPolyPolygon));
 215     }
 216
 217     bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
 218     {
 219         return !((*this) == rPolyPolygon);
 220     }
 221
 222     sal_uInt32 B2DPolyPolygon::count() const
 223     {
 224         return mpPolyPolygon->count();
 225     }
 226
 227     B2DPolygon B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
 228     {
 229         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
 230
 231         return mpPolyPolygon->getB2DPolygon(nIndex);
 232     }
 233
 234     void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
 235     {
 236         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
 237
 238         if(getB2DPolygon(nIndex) != rPolygon)
 239             mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
 240     }
 241
 242     bool B2DPolyPolygon::areControlPointsUsed() const
 243     {
 244         for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
 245         {
 246             const B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
 247
 248             if(rPolygon.areControlPointsUsed())
 249             {
 250                 return true;
 251             }
 252         }
 253
 254         return false;
 255     }
 256
 257     void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
 258     {
 259         OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
 260
 261         if(nCount)
 262             mpPolyPolygon->insert(nIndex, rPolygon, nCount);
 263     }
 264
 265     void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
 266     {
 267         if(nCount)
 268             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
 269     }
 270
 271     B2DPolyPolygon B2DPolyPolygon::getDefaultAdaptiveSubdivision() const
 272     {
 273         B2DPolyPolygon aRetval;
 274
 275         for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
 276         {
 277             aRetval.append(mpPolyPolygon->getB2DPolygon(a).getDefaultAdaptiveSubdivision());
 278         }
 279
 280         return aRetval;
 281     }
 282
 283     B2DRange B2DPolyPolygon::getB2DRange() const
 284     {
 285         B2DRange aRetval;
 286
 287         for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
 288         {
 289             aRetval.expand(mpPolyPolygon->getB2DPolygon(a).getB2DRange());
 290         }
 291
 292         return aRetval;
 293     }
 294
 295     void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
 296     {
 297         OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
 298
 299         if(rPolyPolygon.count())
 300             mpPolyPolygon->insert(nIndex, rPolyPolygon);
 301     }
 302
 303     void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
 304     {
 305         if(rPolyPolygon.count())
 306             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
 307     }
 308
 309     void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 310     {
 311         OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
 312
 313         if(nCount)
 314             mpPolyPolygon->remove(nIndex, nCount);
 315     }
 316
 317     void B2DPolyPolygon::clear()
 318     {
 319         mpPolyPolygon = DefaultPolyPolygon::get();
 320     }
 321
 322     bool B2DPolyPolygon::isClosed() const
 323     {
 324         bool bRetval(true);
 325
 326         // PolyPOlygon is closed when all contained Polygons are closed or
 327         // no Polygon exists.
 328         for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
 329         {
 330             if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
 331             {
 332                 bRetval = false;
 333             }
 334         }
 335
 336         return bRetval;
 337     }
 338
 339     void B2DPolyPolygon::setClosed(bool bNew)
 340     {
 341         if(bNew != isClosed())
 342             mpPolyPolygon->setClosed(bNew);
 343     }
 344
 345     void B2DPolyPolygon::flip()
 346     {
 347         if(mpPolyPolygon->count())
 348         {
 349             mpPolyPolygon->flip();
 350         }
 351     }
 352
 353     bool B2DPolyPolygon::hasDoublePoints() const
 354     {
 355         bool bRetval(false);
 356
 357         for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
 358         {
 359             if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
 360             {
 361                 bRetval = true;
 362             }
 363         }
 364
 365         return bRetval;
 366     }
 367
 368     void B2DPolyPolygon::removeDoublePoints()
 369     {
 370         if(hasDoublePoints())
 371             mpPolyPolygon->removeDoublePoints();
 372     }
 373
 374     void B2DPolyPolygon::transform(const B2DHomMatrix& rMatrix)
 375     {
 376         if(mpPolyPolygon->count() && !rMatrix.isIdentity())
 377         {
 378             mpPolyPolygon->transform(rMatrix);
 379         }
 380     }
 381 } // end of namespace basegfx
 382
 383 // eof