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