1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski
28*b1cdbd2cSJim Jagielski
29*b1cdbd2cSJim Jagielski
30*b1cdbd2cSJim Jagielski #include <tools/debug.hxx>
31*b1cdbd2cSJim Jagielski #include "swtypes.hxx"
32*b1cdbd2cSJim Jagielski #include "swrect.hxx"
33*b1cdbd2cSJim Jagielski #include "swregion.hxx"
34*b1cdbd2cSJim Jagielski
35*b1cdbd2cSJim Jagielski
36*b1cdbd2cSJim Jagielski SV_IMPL_VARARR( SwRects, SwRect );
37*b1cdbd2cSJim Jagielski
38*b1cdbd2cSJim Jagielski /*************************************************************************
39*b1cdbd2cSJim Jagielski |*
40*b1cdbd2cSJim Jagielski |* SwRegionRects::SwRegionRects()
41*b1cdbd2cSJim Jagielski |*
42*b1cdbd2cSJim Jagielski |* Ersterstellung MA 28. Oct. 92
43*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 01. Feb. 93
44*b1cdbd2cSJim Jagielski |*
45*b1cdbd2cSJim Jagielski |*************************************************************************/
46*b1cdbd2cSJim Jagielski
SwRegionRects(const SwRect & rStartRect,sal_uInt16 nInit,sal_uInt16 nGrow)47*b1cdbd2cSJim Jagielski SwRegionRects::SwRegionRects( const SwRect &rStartRect, sal_uInt16 nInit,
48*b1cdbd2cSJim Jagielski sal_uInt16 nGrow ) :
49*b1cdbd2cSJim Jagielski SwRects( (sal_uInt8)nInit, (sal_uInt8)nGrow ),
50*b1cdbd2cSJim Jagielski aOrigin( rStartRect )
51*b1cdbd2cSJim Jagielski {
52*b1cdbd2cSJim Jagielski Insert( aOrigin, 0 );
53*b1cdbd2cSJim Jagielski }
54*b1cdbd2cSJim Jagielski
55*b1cdbd2cSJim Jagielski /*************************************************************************
56*b1cdbd2cSJim Jagielski * inline InsertRect()
57*b1cdbd2cSJim Jagielski *
58*b1cdbd2cSJim Jagielski * InsertRect() wird nur von operator-=() gerufen.
59*b1cdbd2cSJim Jagielski * Wenn bDel == sal_True ist, dann wird das Rect an der Position nPos mit
60*b1cdbd2cSJim Jagielski * rRect ueberschrieben, ansonsten wird rRect hinten angehaengt.
61*b1cdbd2cSJim Jagielski *************************************************************************/
62*b1cdbd2cSJim Jagielski
InsertRect(const SwRect & rRect,const sal_uInt16 nPos,sal_Bool & rDel)63*b1cdbd2cSJim Jagielski inline void SwRegionRects::InsertRect( const SwRect &rRect, const sal_uInt16 nPos,
64*b1cdbd2cSJim Jagielski sal_Bool &rDel )
65*b1cdbd2cSJim Jagielski {
66*b1cdbd2cSJim Jagielski if( rDel )
67*b1cdbd2cSJim Jagielski {
68*b1cdbd2cSJim Jagielski pData = (SwRect*)pData; // looks weird but seems to help gcc ->i78417
69*b1cdbd2cSJim Jagielski *(pData+nPos) = rRect;
70*b1cdbd2cSJim Jagielski rDel = sal_False;
71*b1cdbd2cSJim Jagielski }
72*b1cdbd2cSJim Jagielski else
73*b1cdbd2cSJim Jagielski Insert( rRect, Count() );
74*b1cdbd2cSJim Jagielski }
75*b1cdbd2cSJim Jagielski
76*b1cdbd2cSJim Jagielski /*************************************************************************
77*b1cdbd2cSJim Jagielski |*
78*b1cdbd2cSJim Jagielski |* SwRegionRects::operator-=()
79*b1cdbd2cSJim Jagielski |*
80*b1cdbd2cSJim Jagielski |* Beschreibung Alle Ueberschneidungen der Rechtecke, die sich
81*b1cdbd2cSJim Jagielski |* gerade im Array befinden, mit dem uebergebenen Rechteck werden
82*b1cdbd2cSJim Jagielski |* entfernt.
83*b1cdbd2cSJim Jagielski |* Dazu muessen die vorhandenen Rechtecke entweder aufgeteilt oder
84*b1cdbd2cSJim Jagielski |* geloescht werden.
85*b1cdbd2cSJim Jagielski |* Ersterstellung MA 28. Oct. 92
86*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 09. Sep. 93
87*b1cdbd2cSJim Jagielski |*
88*b1cdbd2cSJim Jagielski |*************************************************************************/
89*b1cdbd2cSJim Jagielski
operator -=(const SwRect & rRect)90*b1cdbd2cSJim Jagielski void SwRegionRects::operator-=( const SwRect &rRect )
91*b1cdbd2cSJim Jagielski {
92*b1cdbd2cSJim Jagielski sal_uInt16 nMax = Count();
93*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < nMax; ++i )
94*b1cdbd2cSJim Jagielski {
95*b1cdbd2cSJim Jagielski if ( rRect.IsOver( *(pData+i) ) )
96*b1cdbd2cSJim Jagielski {
97*b1cdbd2cSJim Jagielski SwRect aTmp( *(pData+i) );
98*b1cdbd2cSJim Jagielski SwRect aInter( aTmp );
99*b1cdbd2cSJim Jagielski aInter._Intersection( rRect );
100*b1cdbd2cSJim Jagielski
101*b1cdbd2cSJim Jagielski // Das erste Rect, das wir inserten wollen, nimmt die
102*b1cdbd2cSJim Jagielski // Stelle von i ein. So ersparen wir uns das Delete().
103*b1cdbd2cSJim Jagielski sal_Bool bDel = sal_True;
104*b1cdbd2cSJim Jagielski
105*b1cdbd2cSJim Jagielski //Jetzt aufteilen das Teil: Es sollen diejenigen Rechtecke
106*b1cdbd2cSJim Jagielski //zurueckbleiben, die im alten aber nicht im neuen liegen.
107*b1cdbd2cSJim Jagielski //Sprich alle Rechtecke die im alten aber nicht in der Intersection
108*b1cdbd2cSJim Jagielski //liegen.
109*b1cdbd2cSJim Jagielski long nTmp;
110*b1cdbd2cSJim Jagielski if ( 0 < (nTmp = aInter.Top() - aTmp.Top()) )
111*b1cdbd2cSJim Jagielski {
112*b1cdbd2cSJim Jagielski const long nOldVal = aTmp.Height();
113*b1cdbd2cSJim Jagielski aTmp.Height(nTmp);
114*b1cdbd2cSJim Jagielski InsertRect( aTmp, i, bDel );
115*b1cdbd2cSJim Jagielski aTmp.Height( nOldVal );
116*b1cdbd2cSJim Jagielski }
117*b1cdbd2cSJim Jagielski
118*b1cdbd2cSJim Jagielski aTmp.Top( aInter.Top() + aInter.Height() );
119*b1cdbd2cSJim Jagielski if ( aTmp.Height() > 0 )
120*b1cdbd2cSJim Jagielski InsertRect( aTmp, i, bDel );
121*b1cdbd2cSJim Jagielski
122*b1cdbd2cSJim Jagielski aTmp.Top( aInter.Top() );
123*b1cdbd2cSJim Jagielski aTmp.Bottom( aInter.Bottom() );
124*b1cdbd2cSJim Jagielski if ( 0 < (nTmp = aInter.Left() - aTmp.Left()) )
125*b1cdbd2cSJim Jagielski {
126*b1cdbd2cSJim Jagielski const long nOldVal = aTmp.Width();
127*b1cdbd2cSJim Jagielski aTmp.Width( nTmp );
128*b1cdbd2cSJim Jagielski InsertRect( aTmp, i, bDel );
129*b1cdbd2cSJim Jagielski aTmp.Width( nOldVal );
130*b1cdbd2cSJim Jagielski }
131*b1cdbd2cSJim Jagielski
132*b1cdbd2cSJim Jagielski aTmp.Left( aInter.Left() + aInter.Width() ); //+1?
133*b1cdbd2cSJim Jagielski if ( aTmp.Width() > 0 )
134*b1cdbd2cSJim Jagielski InsertRect( aTmp, i, bDel );
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski if( bDel )
137*b1cdbd2cSJim Jagielski {
138*b1cdbd2cSJim Jagielski Remove( i );
139*b1cdbd2cSJim Jagielski --i; //Damit wir keinen uebergehen.
140*b1cdbd2cSJim Jagielski --nMax; //Damit wir keinen zuviel verarbeiten.
141*b1cdbd2cSJim Jagielski }
142*b1cdbd2cSJim Jagielski }
143*b1cdbd2cSJim Jagielski }
144*b1cdbd2cSJim Jagielski
145*b1cdbd2cSJim Jagielski }
146*b1cdbd2cSJim Jagielski
147*b1cdbd2cSJim Jagielski /*************************************************************************
148*b1cdbd2cSJim Jagielski * SwRegionRects::Invert()
149*b1cdbd2cSJim Jagielski *
150*b1cdbd2cSJim Jagielski * Bezugspunkt ist aOrigin, das Original-SRectangle.
151*b1cdbd2cSJim Jagielski * Aus Loechern werden Flaechen, aus Flaechen werden Loecher.
152*b1cdbd2cSJim Jagielski * Ein Hinweis: Wenn keine Rects abgezogen wurden, so ist das enthaltene
153*b1cdbd2cSJim Jagielski * Rechteck identisch mit aOrigin. Nach Invert() besteht die Region aus
154*b1cdbd2cSJim Jagielski * einem Null-SRectangle.
155*b1cdbd2cSJim Jagielski *************************************************************************/
156*b1cdbd2cSJim Jagielski
Invert()157*b1cdbd2cSJim Jagielski void SwRegionRects::Invert()
158*b1cdbd2cSJim Jagielski {
159*b1cdbd2cSJim Jagielski // Nicht besonders elegant und schnell, aber wirkungsvoll:
160*b1cdbd2cSJim Jagielski // Wir legen eine weitere Region an und ziehen alle Flaechen ab,
161*b1cdbd2cSJim Jagielski // die in uns noch uebrig geblieben sind. Danach werden alle
162*b1cdbd2cSJim Jagielski // Werte uebertragen.
163*b1cdbd2cSJim Jagielski
164*b1cdbd2cSJim Jagielski // Um unuetze Speicheranforderungen zu vermeiden versuchen wir die
165*b1cdbd2cSJim Jagielski // iniale Groesse moeglichst brauchbar anzulegen:
166*b1cdbd2cSJim Jagielski // Anzahl der Rechtecke in der Region * 2 + 2
167*b1cdbd2cSJim Jagielski // plus zwei um den Sonderfall eines einzelnen Loches (macht vier
168*b1cdbd2cSJim Jagielski // Rechtecke im inversen Fall) abzudecken.
169*b1cdbd2cSJim Jagielski
170*b1cdbd2cSJim Jagielski SwRegionRects aInvRegion( aOrigin, Count()*2+2 );
171*b1cdbd2cSJim Jagielski const SwRect *pDat = GetData();
172*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < Count(); ++pDat, ++i )
173*b1cdbd2cSJim Jagielski aInvRegion -= *pDat;
174*b1cdbd2cSJim Jagielski
175*b1cdbd2cSJim Jagielski sal_uInt16 nCpy = Count(), nDel = 0;
176*b1cdbd2cSJim Jagielski if( aInvRegion.Count() < Count() )
177*b1cdbd2cSJim Jagielski {
178*b1cdbd2cSJim Jagielski nDel = Count() - aInvRegion.Count();
179*b1cdbd2cSJim Jagielski nCpy = aInvRegion.Count();
180*b1cdbd2cSJim Jagielski }
181*b1cdbd2cSJim Jagielski // alle vorhandenen ueberschreiben
182*b1cdbd2cSJim Jagielski memcpy( pData, aInvRegion.GetData(), nCpy * sizeof( SwRect ));
183*b1cdbd2cSJim Jagielski
184*b1cdbd2cSJim Jagielski if( nCpy < aInvRegion.Count() )
185*b1cdbd2cSJim Jagielski Insert( &aInvRegion, nCpy, nCpy );
186*b1cdbd2cSJim Jagielski else if( nDel )
187*b1cdbd2cSJim Jagielski Remove( nCpy, nDel );
188*b1cdbd2cSJim Jagielski }
189*b1cdbd2cSJim Jagielski /*************************************************************************
190*b1cdbd2cSJim Jagielski |*
191*b1cdbd2cSJim Jagielski |* SwRegionRects::Compress()
192*b1cdbd2cSJim Jagielski |*
193*b1cdbd2cSJim Jagielski |* Beschreibung Zusammenfassen von benachbarten Rechtecken.
194*b1cdbd2cSJim Jagielski |* Ersterstellung MA 16. Apr. 93
195*b1cdbd2cSJim Jagielski |* Letzte Aenderung MA 21. Apr. 93
196*b1cdbd2cSJim Jagielski |*
197*b1cdbd2cSJim Jagielski |*************************************************************************/
CalcArea(const SwRect & rRect)198*b1cdbd2cSJim Jagielski inline SwTwips CalcArea( const SwRect &rRect )
199*b1cdbd2cSJim Jagielski {
200*b1cdbd2cSJim Jagielski return rRect.Width() * rRect.Height();
201*b1cdbd2cSJim Jagielski }
202*b1cdbd2cSJim Jagielski
203*b1cdbd2cSJim Jagielski
Compress(sal_Bool bFuzzy)204*b1cdbd2cSJim Jagielski void SwRegionRects::Compress( sal_Bool bFuzzy )
205*b1cdbd2cSJim Jagielski {
206*b1cdbd2cSJim Jagielski for ( int i = 0; i < Count(); ++i )
207*b1cdbd2cSJim Jagielski {
208*b1cdbd2cSJim Jagielski for ( int j = i+1; j < Count(); ++j )
209*b1cdbd2cSJim Jagielski {
210*b1cdbd2cSJim Jagielski //Wenn zwei Rechtecke ineinanderliegen, so ist eins davon
211*b1cdbd2cSJim Jagielski //uberfluessig.
212*b1cdbd2cSJim Jagielski if ( (*(pData + i)).IsInside( *(pData + j) ) )
213*b1cdbd2cSJim Jagielski {
214*b1cdbd2cSJim Jagielski Remove( static_cast<sal_uInt16>(j), 1 );
215*b1cdbd2cSJim Jagielski --j;
216*b1cdbd2cSJim Jagielski }
217*b1cdbd2cSJim Jagielski else if ( (*(pData + j)).IsInside( *(pData + i) ) )
218*b1cdbd2cSJim Jagielski {
219*b1cdbd2cSJim Jagielski *(pData + i) = *(pData + j);
220*b1cdbd2cSJim Jagielski Remove( static_cast<sal_uInt16>(j), 1 );
221*b1cdbd2cSJim Jagielski i = -1;
222*b1cdbd2cSJim Jagielski break;
223*b1cdbd2cSJim Jagielski }
224*b1cdbd2cSJim Jagielski else
225*b1cdbd2cSJim Jagielski {
226*b1cdbd2cSJim Jagielski //Wenn zwei Rechtecke dieselbe Flaeche haben wie deren
227*b1cdbd2cSJim Jagielski //Union abzueglich deren Intersection, so ist eines
228*b1cdbd2cSJim Jagielski //davon ueberfluessig.
229*b1cdbd2cSJim Jagielski //Um moeglichst viel zusammenzufassen und in der Folge
230*b1cdbd2cSJim Jagielski //moeglichst wenig einzelne Paints zu haben darf die Flaeche
231*b1cdbd2cSJim Jagielski //der Union ruhig ein bischen groesser sein
232*b1cdbd2cSJim Jagielski //( 9622 * 141.5 = 1361513 ~= ein virtel Zentimeter ueber die
233*b1cdbd2cSJim Jagielski // Breite einer DINA4 Seite)
234*b1cdbd2cSJim Jagielski const long nFuzzy = bFuzzy ? 1361513 : 0;
235*b1cdbd2cSJim Jagielski SwRect aUnion( *(pData + i) );aUnion.Union( *(pData + j) );
236*b1cdbd2cSJim Jagielski SwRect aInter( *(pData + i) );aInter.Intersection( *(pData + j));
237*b1cdbd2cSJim Jagielski if ( (::CalcArea( *(pData + i) ) +
238*b1cdbd2cSJim Jagielski ::CalcArea( *(pData + j) ) + nFuzzy) >=
239*b1cdbd2cSJim Jagielski (::CalcArea( aUnion ) - CalcArea( aInter )) )
240*b1cdbd2cSJim Jagielski {
241*b1cdbd2cSJim Jagielski *(pData + i) = aUnion;
242*b1cdbd2cSJim Jagielski Remove( static_cast<sal_uInt16>(j), 1 );
243*b1cdbd2cSJim Jagielski i = -1;
244*b1cdbd2cSJim Jagielski break;
245*b1cdbd2cSJim Jagielski }
246*b1cdbd2cSJim Jagielski }
247*b1cdbd2cSJim Jagielski }
248*b1cdbd2cSJim Jagielski }
249*b1cdbd2cSJim Jagielski }
250*b1cdbd2cSJim Jagielski
251