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 278616 : class ImplB3DPolyPolygon
31 : {
32 : typedef ::std::vector< ::basegfx::B3DPolygon > PolygonVector;
33 :
34 : PolygonVector maPolygons;
35 :
36 : public:
37 5 : ImplB3DPolyPolygon() : maPolygons()
38 : {
39 5 : }
40 :
41 28219 : explicit ImplB3DPolyPolygon(const ::basegfx::B3DPolygon& rToBeCopied) :
42 28219 : maPolygons(1,rToBeCopied)
43 : {
44 28219 : }
45 :
46 4755 : bool operator==(const ImplB3DPolyPolygon& rPolygonList) const
47 : {
48 : // same polygon count?
49 4755 : if(maPolygons.size() != rPolygonList.maPolygons.size())
50 891 : return false;
51 :
52 : // compare polygon content
53 3864 : if(maPolygons != rPolygonList.maPolygons)
54 0 : return false;
55 :
56 3864 : return true;
57 : }
58 :
59 581845 : const ::basegfx::B3DPolygon& getB3DPolygon(sal_uInt32 nIndex) const
60 : {
61 581845 : return maPolygons[nIndex];
62 : }
63 :
64 56529 : void setB3DPolygon(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon)
65 : {
66 56529 : maPolygons[nIndex] = rPolygon;
67 56529 : }
68 :
69 47072 : void insert(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon, sal_uInt32 nCount)
70 : {
71 47072 : if(nCount)
72 : {
73 : // add nCount copies of rPolygon
74 47072 : PolygonVector::iterator aIndex(maPolygons.begin());
75 47072 : if( nIndex )
76 18507 : aIndex += nIndex;
77 47072 : maPolygons.insert(aIndex, nCount, rPolygon);
78 : }
79 47072 : }
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 585508 : sal_uInt32 count() const
104 : {
105 585508 : return maPolygons.size();
106 : }
107 :
108 4158 : void flip()
109 : {
110 : std::for_each( maPolygons.begin(),
111 : maPolygons.end(),
112 4158 : std::mem_fun_ref( &::basegfx::B3DPolygon::flip ));
113 4158 : }
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 50614 : void transform(const ::basegfx::B3DHomMatrix& rMatrix)
123 : {
124 108660 : for(size_t a(0L); a < maPolygons.size(); a++)
125 : {
126 58046 : maPolygons[a].transform(rMatrix);
127 : }
128 50614 : }
129 :
130 0 : void clearBColors()
131 : {
132 0 : for(size_t a(0L); a < maPolygons.size(); a++)
133 : {
134 0 : maPolygons[a].clearBColors();
135 : }
136 0 : }
137 :
138 164 : void transformNormals(const ::basegfx::B3DHomMatrix& rMatrix)
139 : {
140 328 : for(size_t a(0L); a < maPolygons.size(); a++)
141 : {
142 164 : maPolygons[a].transformNormals(rMatrix);
143 : }
144 164 : }
145 :
146 36594 : void clearNormals()
147 : {
148 73188 : for(size_t a(0L); a < maPolygons.size(); a++)
149 : {
150 36594 : maPolygons[a].clearNormals();
151 : }
152 36594 : }
153 :
154 8373 : void transformTextureCoordiantes(const ::basegfx::B2DHomMatrix& rMatrix)
155 : {
156 24330 : for(size_t a(0L); a < maPolygons.size(); a++)
157 : {
158 15957 : maPolygons[a].transformTextureCoordiantes(rMatrix);
159 : }
160 8373 : }
161 :
162 4114 : void clearTextureCoordinates()
163 : {
164 8228 : for(size_t a(0L); a < maPolygons.size(); a++)
165 : {
166 4114 : maPolygons[a].clearTextureCoordinates();
167 : }
168 4114 : }
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 30080 : B3DPolyPolygon::B3DPolyPolygon() :
209 30080 : mpPolyPolygon(DefaultPolyPolygon::get())
210 : {
211 30080 : }
212 :
213 163653 : B3DPolyPolygon::B3DPolyPolygon(const B3DPolyPolygon& rPolyPolygon) :
214 163653 : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
215 : {
216 163653 : }
217 :
218 28219 : B3DPolyPolygon::B3DPolyPolygon(const B3DPolygon& rPolygon) :
219 28219 : mpPolyPolygon( ImplB3DPolyPolygon(rPolygon) )
220 : {
221 28219 : }
222 :
223 221952 : B3DPolyPolygon::~B3DPolyPolygon()
224 : {
225 221952 : }
226 :
227 2280 : B3DPolyPolygon& B3DPolyPolygon::operator=(const B3DPolyPolygon& rPolyPolygon)
228 : {
229 2280 : mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
230 2280 : return *this;
231 : }
232 :
233 5616 : bool B3DPolyPolygon::operator==(const B3DPolyPolygon& rPolyPolygon) const
234 : {
235 5616 : if(mpPolyPolygon.same_object(rPolyPolygon.mpPolyPolygon))
236 861 : return true;
237 :
238 4755 : return ((*mpPolyPolygon) == (*rPolyPolygon.mpPolyPolygon));
239 : }
240 :
241 1045 : bool B3DPolyPolygon::operator!=(const B3DPolyPolygon& rPolyPolygon) const
242 : {
243 1045 : return !(*this == rPolyPolygon);
244 : }
245 :
246 241606 : sal_uInt32 B3DPolyPolygon::count() const
247 : {
248 241606 : return mpPolyPolygon->count();
249 : }
250 :
251 421674 : B3DPolygon B3DPolyPolygon::getB3DPolygon(sal_uInt32 nIndex) const
252 : {
253 : OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
254 :
255 421674 : return mpPolyPolygon->getB3DPolygon(nIndex);
256 : }
257 :
258 65745 : void B3DPolyPolygon::setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon)
259 : {
260 : OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
261 :
262 65745 : if(getB3DPolygon(nIndex) != rPolygon)
263 56529 : mpPolyPolygon->setB3DPolygon(nIndex, rPolygon);
264 65745 : }
265 :
266 36455 : bool B3DPolyPolygon::areBColorsUsed() const
267 : {
268 72910 : for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
269 : {
270 36455 : if((mpPolyPolygon->getB3DPolygon(a)).areBColorsUsed())
271 : {
272 0 : return true;
273 : }
274 : }
275 :
276 36455 : return false;
277 : }
278 :
279 36455 : void B3DPolyPolygon::clearBColors()
280 : {
281 36455 : if(areBColorsUsed())
282 0 : mpPolyPolygon->clearBColors();
283 36455 : }
284 :
285 8324 : void B3DPolyPolygon::transformNormals(const B3DHomMatrix& rMatrix)
286 : {
287 8324 : if(!rMatrix.isIdentity())
288 164 : mpPolyPolygon->transformNormals(rMatrix);
289 8324 : }
290 :
291 81859 : bool B3DPolyPolygon::areNormalsUsed() const
292 : {
293 82816 : for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
294 : {
295 82391 : if((mpPolyPolygon->getB3DPolygon(a)).areNormalsUsed())
296 : {
297 81434 : return true;
298 : }
299 : }
300 :
301 425 : return false;
302 : }
303 :
304 36739 : void B3DPolyPolygon::clearNormals()
305 : {
306 36739 : if(areNormalsUsed())
307 36594 : mpPolyPolygon->clearNormals();
308 36739 : }
309 :
310 8373 : void B3DPolyPolygon::transformTextureCoordiantes(const B2DHomMatrix& rMatrix)
311 : {
312 8373 : if(!rMatrix.isIdentity())
313 8373 : mpPolyPolygon->transformTextureCoordiantes(rMatrix);
314 8373 : }
315 :
316 41059 : bool B3DPolyPolygon::areTextureCoordinatesUsed() const
317 : {
318 73815 : for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
319 : {
320 41325 : if((mpPolyPolygon->getB3DPolygon(a)).areTextureCoordinatesUsed())
321 : {
322 8569 : return true;
323 : }
324 : }
325 :
326 32490 : return false;
327 : }
328 :
329 4124 : void B3DPolyPolygon::clearTextureCoordinates()
330 : {
331 4124 : if(areTextureCoordinatesUsed())
332 4114 : mpPolyPolygon->clearTextureCoordinates();
333 4124 : }
334 :
335 47072 : void B3DPolyPolygon::append(const B3DPolygon& rPolygon, sal_uInt32 nCount)
336 : {
337 47072 : if(nCount)
338 47072 : mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
339 47072 : }
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 4158 : void B3DPolyPolygon::flip()
361 : {
362 4158 : mpPolyPolygon->flip();
363 4158 : }
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 67289 : void B3DPolyPolygon::transform(const B3DHomMatrix& rMatrix)
387 : {
388 67289 : if(mpPolyPolygon->count() && !rMatrix.isIdentity())
389 : {
390 50614 : mpPolyPolygon->transform(rMatrix);
391 : }
392 67289 : }
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: */
|
