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