xref: /aoo42x/main/tools/source/generic/poly2.cxx (revision 89b56da7) 
1  /**************************************************************
2   *
3   * Licensed to the Apache Software Foundation (ASF) under one
4   * or more contributor license agreements.  See the NOTICE file
5   * distributed with this work for additional information
6   * regarding copyright ownership.  The ASF licenses this file
7   * to you under the Apache License, Version 2.0 (the
8   * "License"); you may not use this file except in compliance
9   * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   *
20   *************************************************************/
21  
22  
23  
24  // MARKER(update_precomp.py): autogen include statement, do not remove
25  #include "precompiled_tools.hxx"
26  
27  #define _SV_POLY2_CXX
28  
29  #define POLY_CLIP_INT   0
30  #define POLY_CLIP_UNION 1
31  #define POLY_CLIP_DIFF  2
32  #define POLY_CLIP_XOR   3
33  
34  #include <rtl/math.hxx>
35  #include <poly.h>
36  #include <tools/poly.hxx>
37  #include <tools/debug.hxx>
38  #include <tools/stream.hxx>
39  #include <tools/vcompat.hxx>
40  #include <basegfx/polygon/b2dpolypolygon.hxx>
41  #include <basegfx/polygon/b2dpolygon.hxx>
42  #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
43  
44  // ---------------
45  // - PolyPolygon -
46  // ---------------
47  
48  DBG_NAME( PolyPolygon )
49  
50  // -----------------------------------------------------------------------
51  
52  ImplPolyPolygon::ImplPolyPolygon( sal_uInt16 nInitSize )
53  {
54  	mnRefCount	= 1;
55  	mnCount 	= nInitSize;
56  	mnSize		= nInitSize;
57  	mnResize	= 16;
58  	mpPolyAry	= new SVPPOLYGON[ nInitSize ];
59  }
60  
61  // -----------------------------------------------------------------------
62  
63  ImplPolyPolygon::ImplPolyPolygon( const ImplPolyPolygon& rImplPolyPoly )
64  {
65  	mnRefCount	= 1;
66  	mnCount 	= rImplPolyPoly.mnCount;
67  	mnSize		= rImplPolyPoly.mnSize;
68  	mnResize	= rImplPolyPoly.mnResize;
69  
70  	if ( rImplPolyPoly.mpPolyAry )
71  	{
72  		mpPolyAry = new SVPPOLYGON[mnSize];
73  		for ( sal_uInt16 i = 0; i < mnCount; i++ )
74  			mpPolyAry[i] = new Polygon( *rImplPolyPoly.mpPolyAry[i] );
75  	}
76  	else
77  		mpPolyAry = NULL;
78  }
79  
80  // -----------------------------------------------------------------------
81  
82  ImplPolyPolygon::~ImplPolyPolygon()
83  {
84  	if ( mpPolyAry )
85  	{
86  		for ( sal_uInt16 i = 0; i < mnCount; i++ )
87  			delete mpPolyAry[i];
88  		delete[] mpPolyAry;
89  	}
90  }
91  
92  // =======================================================================
93  
94  PolyPolygon::PolyPolygon( sal_uInt16 nInitSize, sal_uInt16 nResize )
95  {
96  	DBG_CTOR( PolyPolygon, NULL );
97  
98  	if ( nInitSize > MAX_POLYGONS )
99  		nInitSize = MAX_POLYGONS;
100  	else if ( !nInitSize )
101  		nInitSize = 1;
102  	if ( nResize > MAX_POLYGONS )
103  		nResize = MAX_POLYGONS;
104  	else if ( !nResize )
105  		nResize = 1;
106  	mpImplPolyPolygon = new ImplPolyPolygon( nInitSize, nResize );
107  }
108  
109  // -----------------------------------------------------------------------
110  
111  PolyPolygon::PolyPolygon( const Polygon& rPoly )
112  {
113  	DBG_CTOR( PolyPolygon, NULL );
114  
115  	if ( rPoly.GetSize() )
116  	{
117  		mpImplPolyPolygon = new ImplPolyPolygon( 1 );
118  		mpImplPolyPolygon->mpPolyAry[0] = new Polygon( rPoly );
119  	}
120  	else
121  		mpImplPolyPolygon = new ImplPolyPolygon( 16, 16 );
122  }
123  
124  // -----------------------------------------------------------------------
125  
126  PolyPolygon::PolyPolygon( sal_uInt16 nPoly, const sal_uInt16* pPointCountAry,
127  						  const Point* pPtAry )
128  {
129  	DBG_CTOR( PolyPolygon, NULL );
130  
131  	if ( nPoly > MAX_POLYGONS )
132  		nPoly = MAX_POLYGONS;
133  
134  	mpImplPolyPolygon = new ImplPolyPolygon( nPoly );
135  	for ( sal_uInt16 i = 0; i < nPoly; i++ )
136  	{
137  		mpImplPolyPolygon->mpPolyAry[i] = new Polygon( *pPointCountAry, pPtAry );
138  		pPtAry += *pPointCountAry;
139  		pPointCountAry++;
140  	}
141  }
142  
143  // -----------------------------------------------------------------------
144  
145  PolyPolygon::PolyPolygon( const PolyPolygon& rPolyPoly )
146  {
147  	DBG_CTOR( PolyPolygon, NULL );
148  	DBG_CHKOBJ( &rPolyPoly, PolyPolygon, NULL );
149  	DBG_ASSERT( rPolyPoly.mpImplPolyPolygon->mnRefCount < 0xFFFFFFFE, "PolyPolygon: RefCount overflow" );
150  
151  	mpImplPolyPolygon = rPolyPoly.mpImplPolyPolygon;
152  	mpImplPolyPolygon->mnRefCount++;
153  }
154  
155  // -----------------------------------------------------------------------
156  
157  PolyPolygon::~PolyPolygon()
158  {
159  	DBG_DTOR( PolyPolygon, NULL );
160  
161  	if ( mpImplPolyPolygon->mnRefCount > 1 )
162  		mpImplPolyPolygon->mnRefCount--;
163  	else
164  		delete mpImplPolyPolygon;
165  }
166  
167  // -----------------------------------------------------------------------
168  
169  void PolyPolygon::Insert( const Polygon& rPoly, sal_uInt16 nPos )
170  {
171  	DBG_CHKTHIS( PolyPolygon, NULL );
172  
173  	if ( mpImplPolyPolygon->mnCount >= MAX_POLYGONS )
174  		return;
175  
176  	if ( mpImplPolyPolygon->mnRefCount > 1 )
177  	{
178  		mpImplPolyPolygon->mnRefCount--;
179  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
180  	}
181  
182  	if ( nPos > mpImplPolyPolygon->mnCount )
183  		nPos = mpImplPolyPolygon->mnCount;
184  
185  	if ( !mpImplPolyPolygon->mpPolyAry )
186  		mpImplPolyPolygon->mpPolyAry = new SVPPOLYGON[mpImplPolyPolygon->mnSize];
187  	else if ( mpImplPolyPolygon->mnCount == mpImplPolyPolygon->mnSize )
188  	{
189  		sal_uInt16		nOldSize = mpImplPolyPolygon->mnSize;
190  		sal_uInt16		nNewSize = nOldSize + mpImplPolyPolygon->mnResize;
191  		SVPPOLYGON* pNewAry;
192  
193  		if ( nNewSize >= MAX_POLYGONS )
194  			nNewSize = MAX_POLYGONS;
195  		pNewAry = new SVPPOLYGON[nNewSize];
196  		memcpy( pNewAry, mpImplPolyPolygon->mpPolyAry, nPos*sizeof(SVPPOLYGON) );
197  		memcpy( pNewAry+nPos+1, mpImplPolyPolygon->mpPolyAry+nPos,
198  				(nOldSize-nPos)*sizeof(SVPPOLYGON) );
199  		delete[] mpImplPolyPolygon->mpPolyAry;
200  		mpImplPolyPolygon->mpPolyAry = pNewAry;
201  		mpImplPolyPolygon->mnSize = nNewSize;
202  	}
203  	else if ( nPos < mpImplPolyPolygon->mnCount )
204  	{
205  		memmove( mpImplPolyPolygon->mpPolyAry+nPos+1,
206  				 mpImplPolyPolygon->mpPolyAry+nPos,
207  				 (mpImplPolyPolygon->mnCount-nPos)*sizeof(SVPPOLYGON) );
208  	}
209  
210  	mpImplPolyPolygon->mpPolyAry[nPos] = new Polygon( rPoly );
211  	mpImplPolyPolygon->mnCount++;
212  }
213  
214  // -----------------------------------------------------------------------
215  
216  void PolyPolygon::Remove( sal_uInt16 nPos )
217  {
218  	DBG_CHKTHIS( PolyPolygon, NULL );
219  	DBG_ASSERT( nPos < Count(), "PolyPolygon::Remove(): nPos >= nSize" );
220  
221  	if ( mpImplPolyPolygon->mnRefCount > 1 )
222  	{
223  		mpImplPolyPolygon->mnRefCount--;
224  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
225  	}
226  
227  	delete mpImplPolyPolygon->mpPolyAry[nPos];
228  	mpImplPolyPolygon->mnCount--;
229  	memmove( mpImplPolyPolygon->mpPolyAry+nPos,
230  			 mpImplPolyPolygon->mpPolyAry+nPos+1,
231  			 (mpImplPolyPolygon->mnCount-nPos)*sizeof(SVPPOLYGON) );
232  }
233  
234  // -----------------------------------------------------------------------
235  
236  void PolyPolygon::Replace( const Polygon& rPoly, sal_uInt16 nPos )
237  {
238  	DBG_CHKTHIS( PolyPolygon, NULL );
239  	DBG_ASSERT( nPos < Count(), "PolyPolygon::Replace(): nPos >= nSize" );
240  
241  	if ( mpImplPolyPolygon->mnRefCount > 1 )
242  	{
243  		mpImplPolyPolygon->mnRefCount--;
244  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
245  	}
246  
247  	delete mpImplPolyPolygon->mpPolyAry[nPos];
248  	mpImplPolyPolygon->mpPolyAry[nPos] = new Polygon( rPoly );
249  }
250  
251  // -----------------------------------------------------------------------
252  
253  const Polygon& PolyPolygon::GetObject( sal_uInt16 nPos ) const
254  {
255  	DBG_CHKTHIS( PolyPolygon, NULL );
256  	DBG_ASSERT( nPos < Count(), "PolyPolygon::GetObject(): nPos >= nSize" );
257  
258  	return *(mpImplPolyPolygon->mpPolyAry[nPos]);
259  }
260  
261  // -----------------------------------------------------------------------
262  
263  sal_Bool PolyPolygon::IsRect() const
264  {
265  	sal_Bool bIsRect = sal_False;
266  	if ( Count() == 1 )
267  		bIsRect = mpImplPolyPolygon->mpPolyAry[ 0 ]->IsRect();
268  	return bIsRect;
269  }
270  
271  // -----------------------------------------------------------------------
272  
273  void PolyPolygon::Clear()
274  {
275  	DBG_CHKTHIS( PolyPolygon, NULL );
276  
277  	if ( mpImplPolyPolygon->mnRefCount > 1 )
278  	{
279  		mpImplPolyPolygon->mnRefCount--;
280  		mpImplPolyPolygon = new ImplPolyPolygon( mpImplPolyPolygon->mnResize,
281  												 mpImplPolyPolygon->mnResize );
282  	}
283  	else
284  	{
285  		if ( mpImplPolyPolygon->mpPolyAry )
286  		{
287  			for ( sal_uInt16 i = 0; i < mpImplPolyPolygon->mnCount; i++ )
288  				delete mpImplPolyPolygon->mpPolyAry[i];
289  			delete[] mpImplPolyPolygon->mpPolyAry;
290  			mpImplPolyPolygon->mpPolyAry = NULL;
291  			mpImplPolyPolygon->mnCount	 = 0;
292  			mpImplPolyPolygon->mnSize	 = mpImplPolyPolygon->mnResize;
293  		}
294  	}
295  }
296  
297  // -----------------------------------------------------------------------
298  
299  void PolyPolygon::Optimize( sal_uIntPtr nOptimizeFlags, const PolyOptimizeData* pData )
300  {
301  	DBG_CHKTHIS( PolyPolygon, NULL );
302  
303  	if( nOptimizeFlags )
304  	{
305  		double		fArea;
306  		const sal_Bool	bEdges = ( nOptimizeFlags & POLY_OPTIMIZE_EDGES ) == POLY_OPTIMIZE_EDGES;
307  		sal_uInt16		nPercent = 0;
308  
309  		if( bEdges )
310  		{
311  			const Rectangle aBound( GetBoundRect() );
312  
313  			fArea = ( aBound.GetWidth() + aBound.GetHeight() ) * 0.5;
314  			nPercent = pData ? pData->GetPercentValue() : 50;
315  			nOptimizeFlags &= ~POLY_OPTIMIZE_EDGES;
316  		}
317  
318  		// watch for ref counter
319  		if( mpImplPolyPolygon->mnRefCount > 1 )
320  		{
321  			mpImplPolyPolygon->mnRefCount--;
322  			mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
323  		}
324  
325  		// Optimize polygons
326  		for( sal_uInt16 i = 0, nPolyCount = mpImplPolyPolygon->mnCount; i < nPolyCount; i++ )
327  		{
328  			if( bEdges )
329  			{
330  				mpImplPolyPolygon->mpPolyAry[ i ]->Optimize( POLY_OPTIMIZE_NO_SAME );
331  				Polygon::ImplReduceEdges( *( mpImplPolyPolygon->mpPolyAry[ i ] ), fArea, nPercent );
332  			}
333  
334  			if( nOptimizeFlags )
335  				mpImplPolyPolygon->mpPolyAry[ i ]->Optimize( nOptimizeFlags, pData );
336  		}
337  	}
338  }
339  
340  // -----------------------------------------------------------------------
341  
342  void PolyPolygon::AdaptiveSubdivide( PolyPolygon& rResult, const double d ) const
343  {
344  	DBG_CHKTHIS( PolyPolygon, NULL );
345  
346  	rResult.Clear();
347  
348  	Polygon aPolygon;
349  
350  	for( sal_uInt16 i = 0; i < mpImplPolyPolygon->mnCount; i++ )
351  	{
352  		mpImplPolyPolygon->mpPolyAry[ i ]->AdaptiveSubdivide( aPolygon, d );
353  		rResult.Insert( aPolygon );
354  	}
355  }
356  
357  // -----------------------------------------------------------------------
358  
359  void PolyPolygon::GetIntersection( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const
360  {
361  	ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_INT );
362  }
363  
364  // -----------------------------------------------------------------------
365  
366  void PolyPolygon::GetUnion( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const
367  {
368  	ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_UNION );
369  }
370  
371  // -----------------------------------------------------------------------
372  
373  void PolyPolygon::GetDifference( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const
374  {
375  	ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_DIFF );
376  }
377  
378  // -----------------------------------------------------------------------
379  
380  void PolyPolygon::GetXOR( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const
381  {
382  	ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_XOR );
383  }
384  
385  // -----------------------------------------------------------------------
386  
387  void PolyPolygon::ImplDoOperation( const PolyPolygon& rPolyPoly, PolyPolygon& rResult, sal_uIntPtr nOperation ) const
388  {
389      // Convert to B2DPolyPolygon, temporarily. It might be
390      // advantageous in the future, to have a PolyPolygon adaptor that
391      // just simulates a B2DPolyPolygon here...
392      basegfx::B2DPolyPolygon aMergePolyPolygonA( getB2DPolyPolygon() );
393      basegfx::B2DPolyPolygon aMergePolyPolygonB( rPolyPoly.getB2DPolyPolygon() );
394  
395      // normalize the two polypolygons before. Force properly oriented
396      // polygons.
397      aMergePolyPolygonA = basegfx::tools::prepareForPolygonOperation( aMergePolyPolygonA );
398      aMergePolyPolygonB = basegfx::tools::prepareForPolygonOperation( aMergePolyPolygonB );
399  
400  	switch( nOperation )
401      {
402          // All code extracted from svx/source/svdraw/svedtv2.cxx
403          // -----------------------------------------------------
404  
405          case POLY_CLIP_UNION:
406          {
407              // merge A and B (OR)
408              aMergePolyPolygonA = basegfx::tools::solvePolygonOperationOr(aMergePolyPolygonA, aMergePolyPolygonB);
409              break;
410          }
411  
412          case POLY_CLIP_DIFF:
413          {
414              // substract B from A (DIFF)
415              aMergePolyPolygonA = basegfx::tools::solvePolygonOperationDiff(aMergePolyPolygonA, aMergePolyPolygonB);
416              break;
417          }
418  
419          case POLY_CLIP_XOR:
420          {
421              // compute XOR between poly A and B
422              aMergePolyPolygonA = basegfx::tools::solvePolygonOperationXor(aMergePolyPolygonA, aMergePolyPolygonB);
423              break;
424          }
425  
426          default:
427          case POLY_CLIP_INT:
428          {
429              // cut poly 1 against polys 2..n (AND)
430              aMergePolyPolygonA = basegfx::tools::solvePolygonOperationAnd(aMergePolyPolygonA, aMergePolyPolygonB);
431              break;
432          }
433      }
434  
435      rResult = PolyPolygon( aMergePolyPolygonA );
436  }
437  
438  // -----------------------------------------------------------------------
439  
440  sal_uInt16 PolyPolygon::Count() const
441  {
442  	DBG_CHKTHIS( PolyPolygon, NULL );
443  	return mpImplPolyPolygon->mnCount;
444  }
445  
446  // -----------------------------------------------------------------------
447  
448  void PolyPolygon::Move( long nHorzMove, long nVertMove )
449  {
450  	DBG_CHKTHIS( PolyPolygon, NULL );
451  
452  	// Diese Abfrage sollte man fuer die DrawEngine durchfuehren
453  	if( nHorzMove || nVertMove )
454  	{
455  		// Referenzcounter beruecksichtigen
456  		if ( mpImplPolyPolygon->mnRefCount > 1 )
457  		{
458  			mpImplPolyPolygon->mnRefCount--;
459  			mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
460  		}
461  
462  		// Punkte verschieben
463  		sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
464  		for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
465  			mpImplPolyPolygon->mpPolyAry[i]->Move( nHorzMove, nVertMove );
466  	}
467  }
468  
469  // -----------------------------------------------------------------------
470  
471  void PolyPolygon::Translate( const Point& rTrans )
472  {
473  	DBG_CHKTHIS( PolyPolygon, NULL );
474  
475  	// Referenzcounter beruecksichtigen
476  	if( mpImplPolyPolygon->mnRefCount > 1 )
477  	{
478  		mpImplPolyPolygon->mnRefCount--;
479  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
480  	}
481  
482  	// Punkte verschieben
483  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
484  		mpImplPolyPolygon->mpPolyAry[ i ]->Translate( rTrans );
485  }
486  
487  // -----------------------------------------------------------------------
488  
489  void PolyPolygon::Scale( double fScaleX, double fScaleY )
490  {
491  	DBG_CHKTHIS( PolyPolygon, NULL );
492  
493  	// Referenzcounter beruecksichtigen
494  	if( mpImplPolyPolygon->mnRefCount > 1 )
495  	{
496  		mpImplPolyPolygon->mnRefCount--;
497  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
498  	}
499  
500  	// Punkte verschieben
501  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
502  		mpImplPolyPolygon->mpPolyAry[ i ]->Scale( fScaleX, fScaleY );
503  }
504  
505  // -----------------------------------------------------------------------
506  
507  void PolyPolygon::Rotate( const Point& rCenter, sal_uInt16 nAngle10 )
508  {
509  	DBG_CHKTHIS( PolyPolygon, NULL );
510  	nAngle10 %= 3600;
511  
512  	if( nAngle10 )
513  	{
514  		const double fAngle = F_PI1800 * nAngle10;
515  		Rotate( rCenter, sin( fAngle ), cos( fAngle ) );
516  	}
517  }
518  
519  // -----------------------------------------------------------------------
520  
521  void PolyPolygon::Rotate( const Point& rCenter, double fSin, double fCos )
522  {
523  	DBG_CHKTHIS( PolyPolygon, NULL );
524  
525  	// Referenzcounter beruecksichtigen
526  	if( mpImplPolyPolygon->mnRefCount > 1 )
527  	{
528  		mpImplPolyPolygon->mnRefCount--;
529  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
530  	}
531  
532  	// Punkte verschieben
533  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
534  		mpImplPolyPolygon->mpPolyAry[ i ]->Rotate( rCenter, fSin, fCos );
535  }
536  
537  // -----------------------------------------------------------------------
538  
539  void PolyPolygon::SlantX( long nYRef, double fSin, double fCos )
540  {
541  	DBG_CHKTHIS( PolyPolygon, NULL );
542  
543  	// Referenzcounter beruecksichtigen
544  	if( mpImplPolyPolygon->mnRefCount > 1 )
545  	{
546  		mpImplPolyPolygon->mnRefCount--;
547  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
548  	}
549  
550  	// Punkte verschieben
551  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
552  		mpImplPolyPolygon->mpPolyAry[ i ]->SlantX( nYRef, fSin, fCos );
553  }
554  
555  // -----------------------------------------------------------------------
556  
557  void PolyPolygon::SlantY( long nXRef, double fSin, double fCos )
558  {
559  	DBG_CHKTHIS( PolyPolygon, NULL );
560  
561  	// Referenzcounter beruecksichtigen
562  	if( mpImplPolyPolygon->mnRefCount > 1 )
563  	{
564  		mpImplPolyPolygon->mnRefCount--;
565  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
566  	}
567  
568  	// Punkte verschieben
569  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
570  		mpImplPolyPolygon->mpPolyAry[ i ]->SlantY( nXRef, fSin, fCos );
571  }
572  
573  // -----------------------------------------------------------------------
574  
575  void PolyPolygon::Distort( const Rectangle& rRefRect, const Polygon& rDistortedRect )
576  {
577  	DBG_CHKTHIS( PolyPolygon, NULL );
578  
579  	// Referenzcounter beruecksichtigen
580  	if( mpImplPolyPolygon->mnRefCount > 1 )
581  	{
582  		mpImplPolyPolygon->mnRefCount--;
583  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
584  	}
585  
586  	// Punkte verschieben
587  	for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
588  		mpImplPolyPolygon->mpPolyAry[ i ]->Distort( rRefRect, rDistortedRect );
589  }
590  
591  
592  // -----------------------------------------------------------------------
593  
594  void PolyPolygon::Clip( const Rectangle& rRect )
595  {
596  	// Polygon-Clippen
597  	sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
598  	sal_uInt16 i;
599  
600  	if ( !nPolyCount )
601  		return;
602  
603  	// Referenzcounter beruecksichtigen
604  	if ( mpImplPolyPolygon->mnRefCount > 1 )
605  	{
606  		mpImplPolyPolygon->mnRefCount--;
607  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
608  	}
609  
610  	// Erst jedes Polygon Clippen und dann die leeren entfernen
611  	for ( i = 0; i < nPolyCount; i++ )
612  		mpImplPolyPolygon->mpPolyAry[i]->Clip( rRect );
613  	while ( nPolyCount )
614  	{
615  		if ( GetObject( nPolyCount-1 ).GetSize() <= 2 )
616  			Remove( nPolyCount-1 );
617  		nPolyCount--;
618  	}
619  }
620  
621  // -----------------------------------------------------------------------
622  
623  Rectangle PolyPolygon::GetBoundRect() const
624  {
625  	DBG_CHKTHIS( PolyPolygon, NULL );
626  
627  	long	nXMin=0, nXMax=0, nYMin=0, nYMax=0;
628  	sal_Bool	bFirst = sal_True;
629  	sal_uInt16	nPolyCount = mpImplPolyPolygon->mnCount;
630  
631  	for ( sal_uInt16 n = 0; n < nPolyCount; n++ )
632  	{
633  		const Polygon*	pPoly = mpImplPolyPolygon->mpPolyAry[n];
634  		const Point*	pAry = pPoly->GetConstPointAry();
635  		sal_uInt16			nPointCount = pPoly->GetSize();
636  
637  		for ( sal_uInt16 i = 0; i < nPointCount; i++ )
638  		{
639  			const Point* pPt = &pAry[ i ];
640  
641  			if ( bFirst )
642  			{
643  				nXMin = nXMax = pPt->X();
644  				nYMin = nYMax = pPt->Y();
645  				bFirst = sal_False;
646  			}
647  			else
648  			{
649  				if ( pPt->X() < nXMin )
650  					nXMin = pPt->X();
651  				if ( pPt->X() > nXMax )
652  					nXMax = pPt->X();
653  				if ( pPt->Y() < nYMin )
654  					nYMin = pPt->Y();
655  				if ( pPt->Y() > nYMax )
656  					nYMax = pPt->Y();
657  			}
658  		}
659  	}
660  
661  	if ( !bFirst )
662  		return Rectangle( nXMin, nYMin, nXMax, nYMax );
663  	else
664  		return Rectangle();
665  }
666  
667  // -----------------------------------------------------------------------
668  
669  Polygon& PolyPolygon::operator[]( sal_uInt16 nPos )
670  {
671  	DBG_CHKTHIS( PolyPolygon, NULL );
672  	DBG_ASSERT( nPos < Count(), "PolyPolygon::[](): nPos >= nSize" );
673  
674  	if ( mpImplPolyPolygon->mnRefCount > 1 )
675  	{
676  		mpImplPolyPolygon->mnRefCount--;
677  		mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
678  	}
679  
680  	return *(mpImplPolyPolygon->mpPolyAry[nPos]);
681  }
682  
683  // -----------------------------------------------------------------------
684  
685  PolyPolygon& PolyPolygon::operator=( const PolyPolygon& rPolyPoly )
686  {
687  	DBG_CHKTHIS( PolyPolygon, NULL );
688  	DBG_CHKOBJ( &rPolyPoly, PolyPolygon, NULL );
689  	DBG_ASSERT( rPolyPoly.mpImplPolyPolygon->mnRefCount < 0xFFFFFFFE, "PolyPolygon: RefCount overflow" );
690  
691  	rPolyPoly.mpImplPolyPolygon->mnRefCount++;
692  
693  	if ( mpImplPolyPolygon->mnRefCount > 1 )
694  		mpImplPolyPolygon->mnRefCount--;
695  	else
696  		delete mpImplPolyPolygon;
697  
698  	mpImplPolyPolygon = rPolyPoly.mpImplPolyPolygon;
699  	return *this;
700  }
701  
702  // -----------------------------------------------------------------------
703  
704  sal_Bool PolyPolygon::operator==( const PolyPolygon& rPolyPoly ) const
705  {
706  	DBG_CHKTHIS( PolyPolygon, NULL );
707  	DBG_CHKOBJ( &rPolyPoly, PolyPolygon, NULL );
708  
709  	if ( rPolyPoly.mpImplPolyPolygon == mpImplPolyPolygon )
710  		return sal_True;
711  	else
712  		return sal_False;
713  }
714  
715  // -----------------------------------------------------------------------
716  
717  sal_Bool PolyPolygon::IsEqual( const PolyPolygon& rPolyPoly ) const
718  {
719  	sal_Bool bIsEqual = sal_True;
720  	if ( Count() != rPolyPoly.Count() )
721  		bIsEqual = sal_False;
722  	else
723  	{
724  		sal_uInt16 i;
725  		for ( i = 0; i < Count(); i++ )
726  		{
727  			if (!GetObject( i ).IsEqual( rPolyPoly.GetObject( i ) ) )
728  			{
729  				bIsEqual = sal_False;
730  				break;
731  			}
732  		}
733  	}
734  	return bIsEqual;
735  }
736  
737  // -----------------------------------------------------------------------
738  
739  SvStream& operator>>( SvStream& rIStream, PolyPolygon& rPolyPoly )
740  {
741  	DBG_CHKOBJ( &rPolyPoly, PolyPolygon, NULL );
742  	DBG_ASSERTWARNING( rIStream.GetVersion(), "PolyPolygon::>> - Solar-Version not set on rIStream" );
743  
744  	Polygon* pPoly;
745  	sal_uInt16	 nPolyCount;
746  
747  	// Anzahl der Polygone einlesen
748  	rIStream >> nPolyCount;
749  
750  	// Daten anlegen
751  	if( nPolyCount )
752  	{
753  		// Referenzcounter beruecksichtigen
754  		if ( rPolyPoly.mpImplPolyPolygon->mnRefCount > 1 )
755  			rPolyPoly.mpImplPolyPolygon->mnRefCount--;
756  		else
757  			delete rPolyPoly.mpImplPolyPolygon;
758  
759  		rPolyPoly.mpImplPolyPolygon = new ImplPolyPolygon( nPolyCount );
760  
761  		for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
762  		{
763  			pPoly = new Polygon;
764  			rIStream >> *pPoly;
765  			rPolyPoly.mpImplPolyPolygon->mpPolyAry[i] = pPoly;
766  		}
767  	}
768  	else
769  		rPolyPoly = PolyPolygon();
770  
771  	return rIStream;
772  }
773  
774  // -----------------------------------------------------------------------
775  
776  SvStream& operator<<( SvStream& rOStream, const PolyPolygon& rPolyPoly )
777  {
778  	DBG_CHKOBJ( &rPolyPoly, PolyPolygon, NULL );
779  	DBG_ASSERTWARNING( rOStream.GetVersion(), "PolyPolygon::<< - Solar-Version not set on rOStream" );
780  
781  	// Anzahl der Polygone rausschreiben
782  	sal_uInt16 nPolyCount = rPolyPoly.mpImplPolyPolygon->mnCount;
783  	rOStream << nPolyCount;
784  
785  	// Die einzelnen Polygone ausgeben
786  	for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
787  		rOStream << *(rPolyPoly.mpImplPolyPolygon->mpPolyAry[i]);
788  
789  	return rOStream;
790  }
791  
792  // -----------------------------------------------------------------------
793  
794  void PolyPolygon::Read( SvStream& rIStream )
795  {
796  	VersionCompat aCompat( rIStream, STREAM_READ );
797  
798  	DBG_CHKTHIS( PolyPolygon, NULL );
799  	DBG_ASSERTWARNING( rIStream.GetVersion(), "PolyPolygon::>> - Solar-Version not set on rIStream" );
800  
801  	Polygon* pPoly;
802  	sal_uInt16	 nPolyCount;
803  
804  	// Anzahl der Polygone einlesen
805  	rIStream >> nPolyCount;
806  
807  	// Daten anlegen
808  	if( nPolyCount )
809  	{
810  		// Referenzcounter beruecksichtigen
811  		if ( mpImplPolyPolygon->mnRefCount > 1 )
812  			mpImplPolyPolygon->mnRefCount--;
813  		else
814  			delete mpImplPolyPolygon;
815  
816  		mpImplPolyPolygon = new ImplPolyPolygon( nPolyCount );
817  
818  		for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
819  		{
820  			pPoly = new Polygon;
821  			pPoly->ImplRead( rIStream );
822  			mpImplPolyPolygon->mpPolyAry[i] = pPoly;
823  		}
824  	}
825  	else
826  		*this = PolyPolygon();
827  }
828  
829  // -----------------------------------------------------------------------
830  
831  void PolyPolygon::Write( SvStream& rOStream ) const
832  {
833  	VersionCompat aCompat( rOStream, STREAM_WRITE, 1 );
834  
835  	DBG_CHKTHIS( PolyPolygon, NULL );
836  	DBG_ASSERTWARNING( rOStream.GetVersion(), "PolyPolygon::<< - Solar-Version not set on rOStream" );
837  
838  	// Anzahl der Polygone rausschreiben
839  	sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
840  	rOStream << nPolyCount;
841  
842  	// Die einzelnen Polygone ausgeben
843  	for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
844  		mpImplPolyPolygon->mpPolyAry[i]->ImplWrite( rOStream );;
845  }
846  
847  // -----------------------------------------------------------------------
848  // convert to basegfx::B2DPolyPolygon and return
849  basegfx::B2DPolyPolygon PolyPolygon::getB2DPolyPolygon() const
850  {
851  	basegfx::B2DPolyPolygon aRetval;
852  
853  	for(sal_uInt16 a(0); a < mpImplPolyPolygon->mnCount; a++)
854  	{
855  		Polygon* pCandidate = mpImplPolyPolygon->mpPolyAry[a];
856  		aRetval.append(pCandidate->getB2DPolygon());
857  	}
858  
859  	return aRetval;
860  }
861  
862  // -----------------------------------------------------------------------
863  // constructor to convert from basegfx::B2DPolyPolygon
864  PolyPolygon::PolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon)
865  {
866  	DBG_CTOR( PolyPolygon, NULL );
867  	const sal_uInt16 nCount(sal_uInt16(rPolyPolygon.count()));
868  	DBG_ASSERT(sal_uInt32(nCount) == rPolyPolygon.count(),
869  		"PolyPolygon::PolyPolygon: Too many sub-polygons in given basegfx::B2DPolyPolygon (!)");
870  
871  	if ( nCount )
872  	{
873  		mpImplPolyPolygon = new ImplPolyPolygon( nCount );
874  
875  		for(sal_uInt16 a(0); a < nCount; a++)
876  		{
877  			basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(sal_uInt32(a)));
878  			mpImplPolyPolygon->mpPolyAry[a] = new Polygon( aCandidate );
879  		}
880  	}
881  	else
882  	{
883  		mpImplPolyPolygon = new ImplPolyPolygon( 16, 16 );
884  	}
885  }
886  
887  // eof
888