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