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