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