xref: /aoo41x/main/vcl/source/gdi/outmap.cxx (revision 35726d9d)
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_vcl.hxx"
26 
27 #include <limits.h>
28 
29 #include <tools/bigint.hxx>
30 #include <tools/debug.hxx>
31 #include <tools/poly.hxx>
32 
33 #include <vcl/virdev.hxx>
34 #include <vcl/region.hxx>
35 #include <vcl/wrkwin.hxx>
36 #include <vcl/cursor.hxx>
37 #include <vcl/metaact.hxx>
38 #include <vcl/gdimtf.hxx>
39 #include <vcl/lineinfo.hxx>
40 #include <vcl/outdev.hxx>
41 
42 #include <svdata.hxx>
43 #include <window.h>
44 #include <outdev.h>
45 #include <salgdi.hxx>
46 
47 #include <basegfx/matrix/b2dhommatrix.hxx>
48 #include <basegfx/polygon/b2dpolygon.hxx>
49 #include <basegfx/polygon/b2dpolypolygon.hxx>
50 
51 #define USE_64BIT_INTS
52 
53 // =======================================================================
54 
55 DBG_NAMEEX( OutputDevice )
56 DBG_NAMEEX( Polygon )
57 DBG_NAMEEX( PolyPolygon )
58 DBG_NAMEEX( Region )
59 
60 // =======================================================================
61 
62 static int const s_ImplArySize = MAP_PIXEL+1;
63 static long aImplNumeratorAry[s_ImplArySize] =
64 	{	 1,   1,   5,  50,	  1,   1,  1, 1,  1,	1, 1 };
65 static long aImplDenominatorAry[s_ImplArySize] =
66 	 { 2540, 254, 127, 127, 1000, 100, 10, 1, 72, 1440, 1 };
67 
68 // -----------------------------------------------------------------------
69 
70 /*
71 Reduziert die Genauigkeit bis eine Fraction draus wird (sollte mal
72 ein Fraction ctor werden) koennte man dann auch mit BigInts machen
73 */
74 
ImplMakeFraction(long nN1,long nN2,long nD1,long nD2)75 static Fraction ImplMakeFraction( long nN1, long nN2, long nD1, long nD2 )
76 {
77 	long i = 1;
78 
79 	if ( nN1 < 0 ) { i = -i; nN1 = -nN1; }
80 	if ( nN2 < 0 ) { i = -i; nN2 = -nN2; }
81 	if ( nD1 < 0 ) { i = -i; nD1 = -nD1; }
82 	if ( nD2 < 0 ) { i = -i; nD2 = -nD2; }
83 	// alle positiv; i Vorzeichen
84 
85 	Fraction aF( i*nN1, nD1 );
86 	aF *= Fraction( nN2, nD2 );
87 
88     if( nD1 == 0 || nD2 == 0 ) //under these bad circumstances the following while loop will be endless
89     {
90         DBG_ASSERT(false,"Invalid parameter for ImplMakeFraction");
91         return Fraction( 1, 1 );
92     }
93 
94 	while ( aF.GetDenominator() == -1 )
95 	{
96 		if ( nN1 > nN2 )
97 			nN1 = (nN1 + 1) / 2;
98 		else
99 			nN2 = (nN2 + 1) / 2;
100 		if ( nD1 > nD2 )
101 			nD1 = (nD1 + 1) / 2;
102 		else
103 			nD2 = (nD2 + 1) / 2;
104 
105 		aF = Fraction( i*nN1, nD1 );
106 		aF *= Fraction( nN2, nD2 );
107 	}
108 
109 	return aF;
110 }
111 
112 // -----------------------------------------------------------------------
113 
114 // Fraction.GetNumerator()
115 // Fraction.GetDenominator()	> 0
116 // rOutRes.nPixPerInch? 		> 0
117 // rMapRes.nMapScNum?
118 // rMapRes.nMapScDenom? 		> 0
119 
ImplCalcBigIntThreshold(long nDPIX,long nDPIY,const ImplMapRes & rMapRes,ImplThresholdRes & rThresRes)120 static void ImplCalcBigIntThreshold( long nDPIX, long nDPIY,
121 									 const ImplMapRes& rMapRes,
122 									 ImplThresholdRes& rThresRes )
123 {
124 	if ( nDPIX && (LONG_MAX / nDPIX < Abs( rMapRes.mnMapScNumX ) ) ) // #111139# avoid div by zero
125 	{
126 		rThresRes.mnThresLogToPixX = 0;
127 		rThresRes.mnThresPixToLogX = 0;
128 	}
129 	else
130 	{
131 		// Schwellenwerte fuer BigInt Arithmetik berechnen
132 		long	nDenomHalfX = rMapRes.mnMapScDenomX / 2;
133 		sal_uLong	nDenomX 	= rMapRes.mnMapScDenomX;
134 		long	nProductX	= nDPIX * rMapRes.mnMapScNumX;
135 
136 		if ( !nProductX )
137 			rThresRes.mnThresLogToPixX = LONG_MAX;
138 		else
139 			rThresRes.mnThresLogToPixX = Abs( (LONG_MAX - nDenomHalfX) / nProductX );
140 
141 		if ( !nDenomX )
142 			rThresRes.mnThresPixToLogX = LONG_MAX;
143 		else if ( nProductX >= 0 )
144 			rThresRes.mnThresPixToLogX = (long)(((sal_uLong)LONG_MAX - (sal_uLong)( nProductX/2)) / nDenomX);
145 		else
146 			rThresRes.mnThresPixToLogX = (long)(((sal_uLong)LONG_MAX + (sal_uLong)(-nProductX/2)) / nDenomX);
147 	}
148 
149 	if ( nDPIY && (LONG_MAX / nDPIY < Abs( rMapRes.mnMapScNumY ) ) ) // #111139# avoid div by zero
150 	{
151 		rThresRes.mnThresLogToPixY = 0;
152 		rThresRes.mnThresPixToLogY = 0;
153 	}
154 	else
155 	{
156 		// Schwellenwerte fuer BigInt Arithmetik berechnen
157 		long	nDenomHalfY = rMapRes.mnMapScDenomY / 2;
158 		sal_uLong	nDenomY 	= rMapRes.mnMapScDenomY;
159 		long	nProductY	= nDPIY * rMapRes.mnMapScNumY;
160 
161 		if ( !nProductY )
162 			rThresRes.mnThresLogToPixY = LONG_MAX;
163 		else
164 			rThresRes.mnThresLogToPixY = Abs( (LONG_MAX - nDenomHalfY) / nProductY );
165 
166 		if ( !nDenomY )
167 			rThresRes.mnThresPixToLogY = LONG_MAX;
168 		else if ( nProductY >= 0 )
169 			rThresRes.mnThresPixToLogY = (long)(((sal_uLong)LONG_MAX - (sal_uLong)( nProductY/2)) / nDenomY);
170 		else
171 			rThresRes.mnThresPixToLogY = (long)(((sal_uLong)LONG_MAX + (sal_uLong)(-nProductY/2)) / nDenomY);
172 	}
173 
174 #ifdef USE_64BIT_INTS
175     rThresRes.mnThresLogToPixX /= 2;
176     rThresRes.mnThresLogToPixY /= 2;
177     rThresRes.mnThresPixToLogX /= 2;
178     rThresRes.mnThresPixToLogY /= 2;
179 #endif
180 }
181 
182 // -----------------------------------------------------------------------
183 
ImplCalcMapResolution(const MapMode & rMapMode,long nDPIX,long nDPIY,ImplMapRes & rMapRes)184 static void ImplCalcMapResolution( const MapMode& rMapMode,
185 								   long nDPIX, long nDPIY, ImplMapRes& rMapRes )
186 {
187 	switch ( rMapMode.GetMapUnit() )
188 	{
189 		case MAP_RELATIVE:
190 			break;
191 		case MAP_100TH_MM:
192 			rMapRes.mnMapScNumX   = 1;
193 			rMapRes.mnMapScDenomX = 2540;
194 			rMapRes.mnMapScNumY   = 1;
195 			rMapRes.mnMapScDenomY = 2540;
196 			break;
197 		case MAP_10TH_MM:
198 			rMapRes.mnMapScNumX   = 1;
199 			rMapRes.mnMapScDenomX = 254;
200 			rMapRes.mnMapScNumY   = 1;
201 			rMapRes.mnMapScDenomY = 254;
202 			break;
203 		case MAP_MM:
204 			rMapRes.mnMapScNumX   = 5;		// 10
205 			rMapRes.mnMapScDenomX = 127;	// 254
206 			rMapRes.mnMapScNumY   = 5;		// 10
207 			rMapRes.mnMapScDenomY = 127;	// 254
208 			break;
209 		case MAP_CM:
210 			rMapRes.mnMapScNumX   = 50; 	// 100
211 			rMapRes.mnMapScDenomX = 127;	// 254
212 			rMapRes.mnMapScNumY   = 50; 	// 100
213 			rMapRes.mnMapScDenomY = 127;	// 254
214 			break;
215 		case MAP_1000TH_INCH:
216 			rMapRes.mnMapScNumX   = 1;
217 			rMapRes.mnMapScDenomX = 1000;
218 			rMapRes.mnMapScNumY   = 1;
219 			rMapRes.mnMapScDenomY = 1000;
220 			break;
221 		case MAP_100TH_INCH:
222 			rMapRes.mnMapScNumX   = 1;
223 			rMapRes.mnMapScDenomX = 100;
224 			rMapRes.mnMapScNumY   = 1;
225 			rMapRes.mnMapScDenomY = 100;
226 			break;
227 		case MAP_10TH_INCH:
228 			rMapRes.mnMapScNumX   = 1;
229 			rMapRes.mnMapScDenomX = 10;
230 			rMapRes.mnMapScNumY   = 1;
231 			rMapRes.mnMapScDenomY = 10;
232 			break;
233 		case MAP_INCH:
234 			rMapRes.mnMapScNumX   = 1;
235 			rMapRes.mnMapScDenomX = 1;
236 			rMapRes.mnMapScNumY   = 1;
237 			rMapRes.mnMapScDenomY = 1;
238 			break;
239 		case MAP_POINT:
240 			rMapRes.mnMapScNumX   = 1;
241 			rMapRes.mnMapScDenomX = 72;
242 			rMapRes.mnMapScNumY   = 1;
243 			rMapRes.mnMapScDenomY = 72;
244 			break;
245 		case MAP_TWIP:
246 			rMapRes.mnMapScNumX   = 1;
247 			rMapRes.mnMapScDenomX = 1440;
248 			rMapRes.mnMapScNumY   = 1;
249 			rMapRes.mnMapScDenomY = 1440;
250 			break;
251 		case MAP_PIXEL:
252 			rMapRes.mnMapScNumX   = 1;
253 			rMapRes.mnMapScDenomX = nDPIX;
254 			rMapRes.mnMapScNumY   = 1;
255 			rMapRes.mnMapScDenomY = nDPIY;
256 			break;
257 		case MAP_SYSFONT:
258 		case MAP_APPFONT:
259 		case MAP_REALAPPFONT:
260 			{
261 			ImplSVData* pSVData = ImplGetSVData();
262 			if ( !pSVData->maGDIData.mnAppFontX )
263 			{
264                 if( pSVData->maWinData.mpFirstFrame )
265                     Window::ImplInitAppFontData( pSVData->maWinData.mpFirstFrame );
266                 else
267                 {
268                     WorkWindow* pWin = new WorkWindow( NULL, 0 );
269                     Window::ImplInitAppFontData( pWin );
270                     delete pWin;
271                 }
272 			}
273 			if ( rMapMode.GetMapUnit() == MAP_REALAPPFONT )
274 				rMapRes.mnMapScNumX   = pSVData->maGDIData.mnRealAppFontX;
275 			else
276 				rMapRes.mnMapScNumX   = pSVData->maGDIData.mnAppFontX;
277 			rMapRes.mnMapScDenomX = nDPIX * 40;
278 			rMapRes.mnMapScNumY   = pSVData->maGDIData.mnAppFontY;;
279 			rMapRes.mnMapScDenomY = nDPIY * 80;
280 			}
281 			break;
282         default:
283             DBG_ERROR( "unhandled MapUnit" );
284             break;
285 	}
286 
287 	Fraction aScaleX = rMapMode.GetScaleX();
288 	Fraction aScaleY = rMapMode.GetScaleY();
289 
290 	// Offset laut MapMode setzen
291 	Point aOrigin = rMapMode.GetOrigin();
292 	if ( rMapMode.GetMapUnit() != MAP_RELATIVE )
293 	{
294 		rMapRes.mnMapOfsX = aOrigin.X();
295 		rMapRes.mnMapOfsY = aOrigin.Y();
296 	}
297 	else
298 	{
299 		BigInt aX( rMapRes.mnMapOfsX );
300 		aX *= BigInt( aScaleX.GetDenominator() );
301 		if ( rMapRes.mnMapOfsX >= 0 )
302 		{
303 			if ( aScaleX.GetNumerator() >= 0 )
304 				aX += BigInt( aScaleX.GetNumerator()/2 );
305 			else
306 				aX -= BigInt( (aScaleX.GetNumerator()+1)/2 );
307 		}
308 		else
309 		{
310 			if ( aScaleX.GetNumerator() >= 0 )
311 				aX -= BigInt( (aScaleX.GetNumerator()-1)/2 );
312 			else
313 				aX += BigInt( aScaleX.GetNumerator()/2 );
314 		}
315 		aX /= BigInt( aScaleX.GetNumerator() );
316 		rMapRes.mnMapOfsX = (long)aX + aOrigin.X();
317 		BigInt aY( rMapRes.mnMapOfsY );
318 		aY *= BigInt( aScaleY.GetDenominator() );
319 		if( rMapRes.mnMapOfsY >= 0 )
320 		{
321 			if ( aScaleY.GetNumerator() >= 0 )
322 				aY += BigInt( aScaleY.GetNumerator()/2 );
323 			else
324 				aY -= BigInt( (aScaleY.GetNumerator()+1)/2 );
325 		}
326 		else
327 		{
328 			if ( aScaleY.GetNumerator() >= 0 )
329 				aY -= BigInt( (aScaleY.GetNumerator()-1)/2 );
330 			else
331 				aY += BigInt( aScaleY.GetNumerator()/2 );
332 		}
333 		aY /= BigInt( aScaleY.GetNumerator() );
334 		rMapRes.mnMapOfsY = (long)aY + aOrigin.Y();
335 	}
336 
337 	// Scaling Faktor laut MapMode einberechnen
338 	// aTemp? = rMapRes.mnMapSc? * aScale?
339 	Fraction aTempX = ImplMakeFraction( rMapRes.mnMapScNumX,
340 										aScaleX.GetNumerator(),
341 										rMapRes.mnMapScDenomX,
342 										aScaleX.GetDenominator() );
343 	Fraction aTempY = ImplMakeFraction( rMapRes.mnMapScNumY,
344 										aScaleY.GetNumerator(),
345 										rMapRes.mnMapScDenomY,
346 										aScaleY.GetDenominator() );
347 	rMapRes.mnMapScNumX   = aTempX.GetNumerator();
348 	rMapRes.mnMapScDenomX = aTempX.GetDenominator();
349 	rMapRes.mnMapScNumY   = aTempY.GetNumerator();
350 	rMapRes.mnMapScDenomY = aTempY.GetDenominator();
351 
352 	// hack: 0/n ungef"ahr 1/max
353 	if ( !rMapRes.mnMapScNumX )
354 	{
355 		rMapRes.mnMapScNumX = 1;
356 		rMapRes.mnMapScDenomX = LONG_MAX;
357 	}
358 	if ( !rMapRes.mnMapScNumY )
359 	{
360 		rMapRes.mnMapScNumY = 1;
361 		rMapRes.mnMapScDenomY = LONG_MAX;
362 	}
363 }
364 
365 // -----------------------------------------------------------------------
366 
ImplCalcMapResolution(const MapMode & rMapMode,long nDPIX,long nDPIY,ImplMapRes & rMapRes,ImplThresholdRes & rThresRes)367 inline void ImplCalcMapResolution( const MapMode& rMapMode,
368 								   long nDPIX, long nDPIY,
369 								   ImplMapRes& rMapRes,
370 								   ImplThresholdRes& rThresRes )
371 {
372 	ImplCalcMapResolution( rMapMode, nDPIX, nDPIY, rMapRes );
373 	ImplCalcBigIntThreshold( nDPIX, nDPIY, rMapRes, rThresRes );
374 }
375 
376 // -----------------------------------------------------------------------
377 
ImplLogicToPixel(long n,long nDPI,long nMapNum,long nMapDenom,long nThres)378 static long ImplLogicToPixel( long n, long nDPI, long nMapNum, long nMapDenom,
379 							  long nThres )
380 {
381     // To "use" it...
382     (void) nThres;
383 #ifdef USE_64BIT_INTS
384 #if (SAL_TYPES_SIZEOFLONG < 8)
385     if( (+n < nThres) && (-n < nThres) )
386     {
387        n *= nMapNum * nDPI;
388        if( nMapDenom != 1 )
389        {
390           n = (2 * n) / nMapDenom;
391           if( n < 0 ) --n; else ++n;
392           n /= 2;
393        }
394     }
395     else
396 #endif
397     {
398        sal_Int64 n64 = n;
399        n64 *= nMapNum;
400        n64 *= nDPI;
401        if( nMapDenom == 1 )
402           n = (long)n64;
403        else
404        {
405           n = (long)(2 * n64 / nMapDenom);
406           if( n < 0 ) --n; else ++n;
407           n /= 2;
408        }
409     }
410     return n;
411 #else // USE_64BIT_INTS
412 	if ( Abs( n ) < nThres )
413 	{
414 		n *= nDPI * nMapNum;
415 		n += n >= 0 ? nMapDenom/2 : -((nMapDenom-1)/2);
416                 return (n / nMapDenom);
417 	}
418 	else
419 	{
420 		BigInt aTemp( n );
421 		aTemp *= BigInt( nDPI );
422 		aTemp *= BigInt( nMapNum );
423 
424 		if ( aTemp.IsNeg() )
425 		{
426 			BigInt aMapScDenom2( (nMapDenom-1)/2 );
427 			aTemp -= aMapScDenom2;
428 		}
429 		else
430 		{
431 			BigInt aMapScDenom2( nMapDenom/2 );
432 			aTemp += aMapScDenom2;
433 		}
434 
435 		aTemp /= BigInt( nMapDenom );
436 		return (long)aTemp;
437 	}
438 #endif
439 }
440 
441 // -----------------------------------------------------------------------
442 
ImplPixelToLogic(long n,long nDPI,long nMapNum,long nMapDenom,long nThres)443 static long ImplPixelToLogic( long n, long nDPI, long nMapNum, long nMapDenom,
444 							  long nThres )
445 {
446     // To "use" it...
447    (void) nThres;
448 #ifdef USE_64BIT_INTS
449 #if (SAL_TYPES_SIZEOFLONG < 8)
450     if( (+n < nThres) && (-n < nThres) )
451         n = (2 * n * nMapDenom) / (nDPI * nMapNum);
452     else
453 #endif
454     {
455         sal_Int64 n64 = n;
456         n64 *= nMapDenom;
457         long nDenom  = nDPI * nMapNum;
458         n = (long)(2 * n64 / nDenom);
459     }
460     if( n < 0 ) --n; else ++n;
461     return (n / 2);
462 #else // USE_64BIT_INTS
463 	if ( Abs( n ) < nThres )
464 	{
465 		long nDenom  = nDPI * nMapNum;
466 		long nNum    = n * nMapDenom;
467 		if( (nNum ^ nDenom) >= 0 )
468 			nNum += nDenom/2;
469 		else
470 			nNum -= nDenom/2;
471 		return (nNum / nDenom);
472 	}
473 	else
474 	{
475 		BigInt aDenom( nDPI );
476 		aDenom *= BigInt( nMapNum );
477 
478 		BigInt aNum( n );
479 		aNum *= BigInt( nMapDenom );
480 
481 		BigInt aDenom2( aDenom );
482 		if ( aNum.IsNeg() )
483 		{
484 			if ( aDenom.IsNeg() )
485 			{
486 				aDenom2 /= BigInt(2);
487 				aNum += aDenom2;
488 			}
489 			else
490 			{
491 				aDenom2 -= 1;
492 				aDenom2 /= BigInt(2);
493 				aNum -= aDenom2;
494 			}
495 		}
496 		else
497 		{
498 			if ( aDenom.IsNeg() )
499 			{
500 				aDenom2 += 1;
501 				aDenom2 /= BigInt(2);
502 				aNum -= aDenom2;
503 			}
504 			else
505 			{
506 				aDenom2 /= BigInt(2);
507 				aNum += aDenom2;
508 			}
509 		}
510 
511 		aNum  /= aDenom;
512 		return (long)aNum;
513 	}
514 #endif
515 }
516 
517 // -----------------------------------------------------------------------
518 
ImplLogicXToDevicePixel(long nX) const519 long OutputDevice::ImplLogicXToDevicePixel( long nX ) const
520 {
521 	if ( !mbMap )
522 		return nX+mnOutOffX;
523 
524 	return ImplLogicToPixel( nX + maMapRes.mnMapOfsX, mnDPIX,
525 							 maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
526 							 maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX;
527 }
528 
529 // -----------------------------------------------------------------------
530 
ImplLogicYToDevicePixel(long nY) const531 long OutputDevice::ImplLogicYToDevicePixel( long nY ) const
532 {
533 	if ( !mbMap )
534 		return nY+mnOutOffY;
535 
536 	return ImplLogicToPixel( nY + maMapRes.mnMapOfsY, mnDPIY,
537 							 maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
538 							 maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY;
539 }
540 
541 // -----------------------------------------------------------------------
542 
ImplLogicWidthToDevicePixel(long nWidth) const543 long OutputDevice::ImplLogicWidthToDevicePixel( long nWidth ) const
544 {
545 	if ( !mbMap )
546 		return nWidth;
547 
548 	return ImplLogicToPixel( nWidth, mnDPIX,
549 							 maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
550 							 maThresRes.mnThresLogToPixX );
551 }
552 
ImplFloatLogicWidthToDevicePixel(float fLogicWidth) const553 float OutputDevice::ImplFloatLogicWidthToDevicePixel( float fLogicWidth) const
554 {
555 	if( !mbMap)
556 		return fLogicWidth;
557 	// TODO: consolidate the calculation into one multiplication
558 	float fPixelWidth = (fLogicWidth * mnDPIX * maMapRes.mnMapScNumX) / maMapRes.mnMapScDenomX;
559 	return fPixelWidth;
560 }
561 
562 // -----------------------------------------------------------------------
563 
ImplLogicHeightToDevicePixel(long nHeight) const564 long OutputDevice::ImplLogicHeightToDevicePixel( long nHeight ) const
565 {
566 	if ( !mbMap )
567 		return nHeight;
568 
569 	return ImplLogicToPixel( nHeight, mnDPIY,
570 							 maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
571 							 maThresRes.mnThresLogToPixY );
572 }
573 
ImplFloatLogicHeightToDevicePixel(float fLogicHeight) const574 float OutputDevice::ImplFloatLogicHeightToDevicePixel( float fLogicHeight) const
575 {
576 	if( !mbMap)
577 		return fLogicHeight;
578 	float fPixelHeight = (fLogicHeight * mnDPIY * maMapRes.mnMapScNumY) / maMapRes.mnMapScDenomY;
579 	return fPixelHeight;
580 }
581 
582 // -----------------------------------------------------------------------
583 
ImplDevicePixelToLogicWidth(long nWidth) const584 long OutputDevice::ImplDevicePixelToLogicWidth( long nWidth ) const
585 {
586 	if ( !mbMap )
587 		return nWidth;
588 
589 	return ImplPixelToLogic( nWidth, mnDPIX,
590 							 maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
591 							 maThresRes.mnThresPixToLogX );
592 }
593 
ImplFloatDevicePixelToLogicWidth(float fPixelWidth) const594 float OutputDevice::ImplFloatDevicePixelToLogicWidth( float fPixelWidth) const
595 {
596 	if( !mbMap)
597 		return fPixelWidth;
598 	float fLogicHeight = (fPixelWidth * maMapRes.mnMapScDenomX) / (mnDPIX * maMapRes.mnMapScNumX);
599 	return fLogicHeight;
600 }
601 
602 // -----------------------------------------------------------------------
603 
ImplDevicePixelToLogicHeight(long nHeight) const604 long OutputDevice::ImplDevicePixelToLogicHeight( long nHeight ) const
605 {
606 	if ( !mbMap )
607 		return nHeight;
608 
609 	return ImplPixelToLogic( nHeight, mnDPIY,
610 							 maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
611 							 maThresRes.mnThresPixToLogY );
612 }
613 
ImplFloatDevicePixelToLogicHeight(float fPixelHeight) const614 float OutputDevice::ImplFloatDevicePixelToLogicHeight( float fPixelHeight) const
615 {
616 	if( !mbMap)
617 		return fPixelHeight;
618 	float fLogicHeight = (fPixelHeight * maMapRes.mnMapScDenomY) / (mnDPIY * maMapRes.mnMapScNumY);
619 	return fLogicHeight;
620 }
621 
622 
623 // -----------------------------------------------------------------------
624 
ImplLogicToDevicePixel(const Point & rLogicPt) const625 Point OutputDevice::ImplLogicToDevicePixel( const Point& rLogicPt ) const
626 {
627 	if ( !mbMap )
628 		return Point( rLogicPt.X()+mnOutOffX, rLogicPt.Y()+mnOutOffY );
629 
630 	return Point( ImplLogicToPixel( rLogicPt.X() + maMapRes.mnMapOfsX, mnDPIX,
631 									maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
632 									maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
633 				  ImplLogicToPixel( rLogicPt.Y() + maMapRes.mnMapOfsY, mnDPIY,
634 									maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
635 									maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY );
636 }
637 
638 // -----------------------------------------------------------------------
639 
ImplLogicToDevicePixel(const Size & rLogicSize) const640 Size OutputDevice::ImplLogicToDevicePixel( const Size& rLogicSize ) const
641 {
642 	if ( !mbMap )
643 		return rLogicSize;
644 
645 	return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
646 								   maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
647 								   maThresRes.mnThresLogToPixX ),
648 				 ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
649 								   maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
650 								   maThresRes.mnThresLogToPixY ) );
651 }
652 
653 // -----------------------------------------------------------------------
654 
ImplLogicToDevicePixel(const Rectangle & rLogicRect) const655 Rectangle OutputDevice::ImplLogicToDevicePixel( const Rectangle& rLogicRect ) const
656 {
657 	if ( rLogicRect.IsEmpty() )
658 		return rLogicRect;
659 
660 	if ( !mbMap )
661 	{
662 		return Rectangle( rLogicRect.Left()+mnOutOffX, rLogicRect.Top()+mnOutOffY,
663 						  rLogicRect.Right()+mnOutOffX, rLogicRect.Bottom()+mnOutOffY );
664 	}
665 
666 	return Rectangle( ImplLogicToPixel( rLogicRect.Left()+maMapRes.mnMapOfsX, mnDPIX,
667 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
668 										maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
669 					  ImplLogicToPixel( rLogicRect.Top()+maMapRes.mnMapOfsY, mnDPIY,
670 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
671 										maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY,
672 					  ImplLogicToPixel( rLogicRect.Right()+maMapRes.mnMapOfsX, mnDPIX,
673 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
674 										maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
675 					  ImplLogicToPixel( rLogicRect.Bottom()+maMapRes.mnMapOfsY, mnDPIY,
676 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
677 										maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY );
678 }
679 
680 // -----------------------------------------------------------------------
681 
ImplLogicToDevicePixel(const Polygon & rLogicPoly) const682 Polygon OutputDevice::ImplLogicToDevicePixel( const Polygon& rLogicPoly ) const
683 {
684 	if ( !mbMap && !mnOutOffX && !mnOutOffY )
685 		return rLogicPoly;
686 
687 	sal_uInt16	i;
688 	sal_uInt16	nPoints = rLogicPoly.GetSize();
689 	Polygon aPoly( rLogicPoly );
690 
691 	// Pointer auf das Point-Array holen (Daten werden kopiert)
692 	const Point* pPointAry = aPoly.GetConstPointAry();
693 
694 	if ( mbMap )
695 	{
696 		for ( i = 0; i < nPoints; i++ )
697 		{
698 			const Point* pPt = &(pPointAry[i]);
699             Point aPt;
700 			aPt.X() = ImplLogicToPixel( pPt->X()+maMapRes.mnMapOfsX, mnDPIX,
701                                         maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
702                                         maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX;
703 			aPt.Y() = ImplLogicToPixel( pPt->Y()+maMapRes.mnMapOfsY, mnDPIY,
704                                         maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
705                                         maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY;
706             aPoly[i] = aPt;
707 		}
708 	}
709 	else
710 	{
711 		for ( i = 0; i < nPoints; i++ )
712 		{
713 			Point aPt = pPointAry[i];
714 			aPt.X() += mnOutOffX;
715 			aPt.Y() += mnOutOffY;
716             aPoly[i] = aPt;
717 		}
718 	}
719 
720 	return aPoly;
721 }
722 
723 // -----------------------------------------------------------------------
724 
ImplLogicToDevicePixel(const PolyPolygon & rLogicPolyPoly) const725 PolyPolygon OutputDevice::ImplLogicToDevicePixel( const PolyPolygon& rLogicPolyPoly ) const
726 {
727 	if ( !mbMap && !mnOutOffX && !mnOutOffY )
728 		return rLogicPolyPoly;
729 
730 	PolyPolygon aPolyPoly( rLogicPolyPoly );
731 	sal_uInt16		nPoly = aPolyPoly.Count();
732 	for( sal_uInt16 i = 0; i < nPoly; i++ )
733 	{
734 		Polygon& rPoly = aPolyPoly[i];
735 		rPoly = ImplLogicToDevicePixel( rPoly );
736 	}
737 	return aPolyPoly;
738 }
739 
740 // -----------------------------------------------------------------------
741 
ImplLogicToDevicePixel(const LineInfo & rLineInfo) const742 LineInfo OutputDevice::ImplLogicToDevicePixel( const LineInfo& rLineInfo ) const
743 {
744 	LineInfo aInfo( rLineInfo );
745 
746 	if( aInfo.GetStyle() == LINE_DASH )
747 	{
748 		if( aInfo.GetDotCount() && aInfo.GetDotLen() )
749 			aInfo.SetDotLen( Max( ImplLogicWidthToDevicePixel( aInfo.GetDotLen() ), 1L ) );
750 		else
751 			aInfo.SetDotCount( 0 );
752 
753 		if( aInfo.GetDashCount() && aInfo.GetDashLen() )
754 			aInfo.SetDashLen( Max( ImplLogicWidthToDevicePixel( aInfo.GetDashLen() ), 1L ) );
755 		else
756 			aInfo.SetDashCount( 0 );
757 
758 		aInfo.SetDistance( ImplLogicWidthToDevicePixel( aInfo.GetDistance() ) );
759 
760 		if( ( !aInfo.GetDashCount() && !aInfo.GetDotCount() ) || !aInfo.GetDistance() )
761 			aInfo.SetStyle( LINE_SOLID );
762 	}
763 
764 	aInfo.SetWidth( ImplLogicWidthToDevicePixel( aInfo.GetWidth() ) );
765 
766 	return aInfo;
767 }
768 
769 // -----------------------------------------------------------------------
770 
ImplDevicePixelToLogic(const Rectangle & rPixelRect) const771 Rectangle OutputDevice::ImplDevicePixelToLogic( const Rectangle& rPixelRect ) const
772 {
773 	if ( rPixelRect.IsEmpty() )
774 		return rPixelRect;
775 
776 	if ( !mbMap )
777 	{
778 		return Rectangle( rPixelRect.Left()-mnOutOffX, rPixelRect.Top()-mnOutOffY,
779 						  rPixelRect.Right()-mnOutOffX, rPixelRect.Bottom()-mnOutOffY );
780 	}
781 
782 	return Rectangle( ImplPixelToLogic( rPixelRect.Left()-mnOutOffX-mnOutOffOrigX, mnDPIX,
783 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
784 										maThresRes.mnThresPixToLogX )-maMapRes.mnMapOfsX,
785 					  ImplPixelToLogic( rPixelRect.Top()-mnOutOffY-mnOutOffOrigY, mnDPIY,
786 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
787 										maThresRes.mnThresPixToLogY )-maMapRes.mnMapOfsY,
788 					  ImplPixelToLogic( rPixelRect.Right()-mnOutOffX-mnOutOffOrigX, mnDPIX,
789 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
790 										maThresRes.mnThresPixToLogX )-maMapRes.mnMapOfsX,
791 					  ImplPixelToLogic( rPixelRect.Bottom()-mnOutOffY-mnOutOffOrigY, mnDPIY,
792 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
793 										maThresRes.mnThresPixToLogY )-maMapRes.mnMapOfsY );
794 }
795 
796 // -----------------------------------------------------------------------
797 
ImplPixelToDevicePixel(const Region & rRegion) const798 Region OutputDevice::ImplPixelToDevicePixel( const Region& rRegion ) const
799 {
800 	if ( !mnOutOffX && !mnOutOffY )
801 		return rRegion;
802 
803 	Region aRegion( rRegion );
804 	aRegion.Move( mnOutOffX+mnOutOffOrigX, mnOutOffY+mnOutOffOrigY );
805 	return aRegion;
806 }
807 
808 // -----------------------------------------------------------------------
809 
EnableMapMode(sal_Bool bEnable)810 void OutputDevice::EnableMapMode( sal_Bool bEnable )
811 {
812     mbMap = (bEnable != 0);
813 
814     if( mpAlphaVDev )
815         mpAlphaVDev->EnableMapMode( bEnable );
816 }
817 
818 // -----------------------------------------------------------------------
819 
SetMapMode()820 void OutputDevice::SetMapMode()
821 {
822 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
823 
824 	if ( mpMetaFile )
825 		mpMetaFile->AddAction( new MetaMapModeAction( MapMode() ) );
826 
827 	if ( mbMap || !maMapMode.IsDefault() )
828 	{
829 		mbMap		= sal_False;
830 		maMapMode	= MapMode();
831 
832 		// create new objects (clip region werden nicht neu skaliert)
833 		mbNewFont	= sal_True;
834 		mbInitFont	= sal_True;
835 		if ( GetOutDevType() == OUTDEV_WINDOW )
836 		{
837 			if ( ((Window*)this)->mpWindowImpl->mpCursor )
838 				((Window*)this)->mpWindowImpl->mpCursor->ImplNew();
839 		}
840 
841         // #106426# Adapt logical offset when changing mapmode
842         mnOutOffLogicX = mnOutOffOrigX; // no mapping -> equal offsets
843         mnOutOffLogicY = mnOutOffOrigY;
844 
845 		// #i75163#
846 		ImplInvalidateViewTransform();
847 	}
848 
849     if( mpAlphaVDev )
850         mpAlphaVDev->SetMapMode();
851 }
852 
853 // -----------------------------------------------------------------------
854 
SetMapMode(const MapMode & rNewMapMode)855 void OutputDevice::SetMapMode( const MapMode& rNewMapMode )
856 {
857 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
858 
859 	sal_Bool bRelMap = (rNewMapMode.GetMapUnit() == MAP_RELATIVE);
860 
861 	if ( mpMetaFile )
862 	{
863 		mpMetaFile->AddAction( new MetaMapModeAction( rNewMapMode ) );
864 #ifdef DBG_UTIL
865 		if ( GetOutDevType() != OUTDEV_PRINTER )
866 			DBG_ASSERTWARNING( bRelMap, "Please record only relative MapModes!" );
867 #endif
868 	}
869 
870 	// Ist der MapMode der gleiche wie vorher, dann mache nichts
871 	if ( maMapMode == rNewMapMode )
872 		return;
873 
874     if( mpAlphaVDev )
875         mpAlphaVDev->SetMapMode( rNewMapMode );
876 
877 	// Ist Default-MapMode, dann bereche nichts
878 	bool bOldMap = mbMap;
879 	mbMap = !rNewMapMode.IsDefault();
880 	if ( mbMap )
881 	{
882 		// Falls nur der Orign umgesetzt wird, dann scaliere nichts neu
883 		if ( (rNewMapMode.GetMapUnit() == maMapMode.GetMapUnit()) &&
884 			 (rNewMapMode.GetScaleX()  == maMapMode.GetScaleX())  &&
885 			 (rNewMapMode.GetScaleY()  == maMapMode.GetScaleY())  &&
886 			 (bOldMap				   == mbMap) )
887 		{
888 			// Offset setzen
889 			Point aOrigin = rNewMapMode.GetOrigin();
890 			maMapRes.mnMapOfsX = aOrigin.X();
891 			maMapRes.mnMapOfsY = aOrigin.Y();
892 			maMapMode = rNewMapMode;
893 
894 			// #i75163#
895 			ImplInvalidateViewTransform();
896 
897 			return;
898 		}
899 		if ( !bOldMap && bRelMap )
900 		{
901 			maMapRes.mnMapScNumX	= 1;
902 			maMapRes.mnMapScNumY	= 1;
903 			maMapRes.mnMapScDenomX	= mnDPIX;
904 			maMapRes.mnMapScDenomY	= mnDPIY;
905 			maMapRes.mnMapOfsX		= 0;
906 			maMapRes.mnMapOfsY		= 0;
907 		}
908 
909 		// Neue MapMode-Aufloesung berechnen
910 		ImplCalcMapResolution( rNewMapMode, mnDPIX, mnDPIY, maMapRes, maThresRes );
911 	}
912 
913 	// Neuen MapMode setzen
914 	if ( bRelMap )
915 	{
916 		Point aOrigin( maMapRes.mnMapOfsX, maMapRes.mnMapOfsY );
917 		// aScale? = maMapMode.GetScale?() * rNewMapMode.GetScale?()
918 		Fraction aScaleX = ImplMakeFraction( maMapMode.GetScaleX().GetNumerator(),
919 											 rNewMapMode.GetScaleX().GetNumerator(),
920 											 maMapMode.GetScaleX().GetDenominator(),
921 											 rNewMapMode.GetScaleX().GetDenominator() );
922 		Fraction aScaleY = ImplMakeFraction( maMapMode.GetScaleY().GetNumerator(),
923 											 rNewMapMode.GetScaleY().GetNumerator(),
924 											 maMapMode.GetScaleY().GetDenominator(),
925 											 rNewMapMode.GetScaleY().GetDenominator() );
926 		maMapMode.SetOrigin( aOrigin );
927 		maMapMode.SetScaleX( aScaleX );
928 		maMapMode.SetScaleY( aScaleY );
929 	}
930 	else
931 		maMapMode = rNewMapMode;
932 
933 	// create new objects (clip region werden nicht neu skaliert)
934 	mbNewFont	= sal_True;
935 	mbInitFont	= sal_True;
936 	if ( GetOutDevType() == OUTDEV_WINDOW )
937 	{
938 		if ( ((Window*)this)->mpWindowImpl->mpCursor )
939 			((Window*)this)->mpWindowImpl->mpCursor->ImplNew();
940 	}
941 
942     // #106426# Adapt logical offset when changing mapmode
943 	mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
944                                        maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
945                                        maThresRes.mnThresPixToLogX );
946 	mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
947                                        maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
948                                        maThresRes.mnThresPixToLogY );
949 
950 	// #i75163#
951 	ImplInvalidateViewTransform();
952 }
953 
954 // -----------------------------------------------------------------------
955 
SetRelativeMapMode(const MapMode & rNewMapMode)956 void OutputDevice::SetRelativeMapMode( const MapMode& rNewMapMode )
957 {
958 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
959 
960 	// Ist der MapMode der gleiche wie vorher, dann mache nichts
961 	if ( maMapMode == rNewMapMode )
962 		return;
963 
964 	MapUnit eOld = maMapMode.GetMapUnit();
965 	MapUnit eNew = rNewMapMode.GetMapUnit();
966 
967 	// a?F = rNewMapMode.GetScale?() / maMapMode.GetScale?()
968 	Fraction aXF = ImplMakeFraction( rNewMapMode.GetScaleX().GetNumerator(),
969 									 maMapMode.GetScaleX().GetDenominator(),
970 									 rNewMapMode.GetScaleX().GetDenominator(),
971 									 maMapMode.GetScaleX().GetNumerator() );
972 	Fraction aYF = ImplMakeFraction( rNewMapMode.GetScaleY().GetNumerator(),
973 									 maMapMode.GetScaleY().GetDenominator(),
974 									 rNewMapMode.GetScaleY().GetDenominator(),
975 									 maMapMode.GetScaleY().GetNumerator() );
976 
977 	Point aPt( LogicToLogic( Point(), NULL, &rNewMapMode ) );
978 	if ( eNew != eOld )
979 	{
980 		if ( eOld > MAP_PIXEL )
981 		{
982 			DBG_ERRORFILE( "Not implemented MapUnit" );
983 		}
984 		else if ( eNew > MAP_PIXEL )
985 		{
986 			DBG_ERRORFILE( "Not implemented MapUnit" );
987 		}
988 		else
989 		{
990 			Fraction aF( aImplNumeratorAry[eNew] * aImplDenominatorAry[eOld],
991 						 aImplNumeratorAry[eOld] * aImplDenominatorAry[eNew] );
992 
993 			// a?F =  a?F * aF
994 			aXF = ImplMakeFraction( aXF.GetNumerator(),   aF.GetNumerator(),
995 									aXF.GetDenominator(), aF.GetDenominator() );
996 			aYF = ImplMakeFraction( aYF.GetNumerator(),   aF.GetNumerator(),
997 									aYF.GetDenominator(), aF.GetDenominator() );
998 			if ( eOld == MAP_PIXEL )
999 			{
1000 				aXF *= Fraction( mnDPIX, 1 );
1001 				aYF *= Fraction( mnDPIY, 1 );
1002 			}
1003 			else if ( eNew == MAP_PIXEL )
1004 			{
1005 				aXF *= Fraction( 1, mnDPIX );
1006 				aYF *= Fraction( 1, mnDPIY );
1007 			}
1008 		}
1009 	}
1010 
1011 	MapMode aNewMapMode( MAP_RELATIVE, Point( -aPt.X(), -aPt.Y() ), aXF, aYF );
1012 	SetMapMode( aNewMapMode );
1013 
1014 	if ( eNew != eOld )
1015 		maMapMode = rNewMapMode;
1016 
1017     // #106426# Adapt logical offset when changing mapmode
1018 	mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
1019                                        maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1020                                        maThresRes.mnThresPixToLogX );
1021 	mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
1022                                        maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1023                                        maThresRes.mnThresPixToLogY );
1024 
1025     if( mpAlphaVDev )
1026         mpAlphaVDev->SetRelativeMapMode( rNewMapMode );
1027 }
1028 
1029 // -----------------------------------------------------------------------
1030 
1031 // #i75163#
GetViewTransformation() const1032 basegfx::B2DHomMatrix OutputDevice::GetViewTransformation() const
1033 {
1034     if(mbMap)
1035     {
1036         // #i82615#
1037         if(!mpOutDevData)
1038         {
1039     		const_cast< OutputDevice* >(this)->ImplInitOutDevData();
1040         }
1041 
1042 		if(!mpOutDevData->mpViewTransform)
1043 		{
1044 			mpOutDevData->mpViewTransform = new basegfx::B2DHomMatrix;
1045 
1046 			const double fScaleFactorX((double)mnDPIX * (double)maMapRes.mnMapScNumX / (double)maMapRes.mnMapScDenomX);
1047 			const double fScaleFactorY((double)mnDPIY * (double)maMapRes.mnMapScNumY / (double)maMapRes.mnMapScDenomY);
1048 			const double fZeroPointX(((double)maMapRes.mnMapOfsX * fScaleFactorX) + (double)mnOutOffOrigX);
1049 			const double fZeroPointY(((double)maMapRes.mnMapOfsY * fScaleFactorY) + (double)mnOutOffOrigY);
1050 
1051 			mpOutDevData->mpViewTransform->set(0, 0, fScaleFactorX);
1052 			mpOutDevData->mpViewTransform->set(1, 1, fScaleFactorY);
1053 			mpOutDevData->mpViewTransform->set(0, 2, fZeroPointX);
1054 			mpOutDevData->mpViewTransform->set(1, 2, fZeroPointY);
1055 		}
1056 
1057 		return *mpOutDevData->mpViewTransform;
1058     }
1059 	else
1060 	{
1061 		return basegfx::B2DHomMatrix();
1062 	}
1063 }
1064 
1065 // -----------------------------------------------------------------------
1066 
1067 // #i75163#
GetInverseViewTransformation() const1068 basegfx::B2DHomMatrix OutputDevice::GetInverseViewTransformation() const
1069 {
1070     if(mbMap)
1071     {
1072         // #i82615#
1073         if(!mpOutDevData)
1074         {
1075     		const_cast< OutputDevice* >(this)->ImplInitOutDevData();
1076         }
1077 
1078         if(!mpOutDevData->mpInverseViewTransform)
1079 		{
1080 			GetViewTransformation();
1081 			mpOutDevData->mpInverseViewTransform = new basegfx::B2DHomMatrix(*mpOutDevData->mpViewTransform);
1082 			mpOutDevData->mpInverseViewTransform->invert();
1083 		}
1084 
1085 		return *mpOutDevData->mpInverseViewTransform;
1086 	}
1087 	else
1088 	{
1089 		return basegfx::B2DHomMatrix();
1090 	}
1091 }
1092 
1093 // -----------------------------------------------------------------------
1094 
1095 // #i75163#
GetViewTransformation(const MapMode & rMapMode) const1096 basegfx::B2DHomMatrix OutputDevice::GetViewTransformation( const MapMode& rMapMode ) const
1097 {
1098     // #i82615#
1099 	ImplMapRes			aMapRes;
1100 	ImplThresholdRes	aThresRes;
1101 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1102 
1103 	basegfx::B2DHomMatrix aTransform;
1104 
1105 	const double fScaleFactorX((double)mnDPIX * (double)aMapRes.mnMapScNumX / (double)aMapRes.mnMapScDenomX);
1106 	const double fScaleFactorY((double)mnDPIY * (double)aMapRes.mnMapScNumY / (double)aMapRes.mnMapScDenomY);
1107 	const double fZeroPointX(((double)aMapRes.mnMapOfsX * fScaleFactorX) + (double)mnOutOffOrigX);
1108 	const double fZeroPointY(((double)aMapRes.mnMapOfsY * fScaleFactorY) + (double)mnOutOffOrigY);
1109 
1110 	aTransform.set(0, 0, fScaleFactorX);
1111 	aTransform.set(1, 1, fScaleFactorY);
1112 	aTransform.set(0, 2, fZeroPointX);
1113 	aTransform.set(1, 2, fZeroPointY);
1114 
1115 	return aTransform;
1116 }
1117 
1118 // -----------------------------------------------------------------------
1119 
1120 // #i75163#
GetInverseViewTransformation(const MapMode & rMapMode) const1121 basegfx::B2DHomMatrix OutputDevice::GetInverseViewTransformation( const MapMode& rMapMode ) const
1122 {
1123     basegfx::B2DHomMatrix aMatrix( GetViewTransformation( rMapMode ) );
1124     aMatrix.invert();
1125     return aMatrix;
1126 }
1127 
1128 // -----------------------------------------------------------------------
1129 
ImplGetDeviceTransformation() const1130 basegfx::B2DHomMatrix OutputDevice::ImplGetDeviceTransformation() const
1131 {
1132 	basegfx::B2DHomMatrix aTransformation = GetViewTransformation();
1133 	// TODO: is it worth to cache the transformed result?
1134 	if( mnOutOffX || mnOutOffY )
1135 		aTransformation.translate( mnOutOffX, mnOutOffY );
1136 	return aTransformation;
1137 }
1138 
1139 // -----------------------------------------------------------------------
1140 
LogicToPixel(const Point & rLogicPt) const1141 Point OutputDevice::LogicToPixel( const Point& rLogicPt ) const
1142 {
1143 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1144 
1145 	if ( !mbMap )
1146 		return rLogicPt;
1147 
1148 	return Point( ImplLogicToPixel( rLogicPt.X() + maMapRes.mnMapOfsX, mnDPIX,
1149 									maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1150 									maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1151 				  ImplLogicToPixel( rLogicPt.Y() + maMapRes.mnMapOfsY, mnDPIY,
1152 									maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1153 									maThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1154 }
1155 
1156 // -----------------------------------------------------------------------
1157 
LogicToPixel(const Size & rLogicSize) const1158 Size OutputDevice::LogicToPixel( const Size& rLogicSize ) const
1159 {
1160 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1161 
1162 	if ( !mbMap )
1163 		return rLogicSize;
1164 
1165 	return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
1166 								   maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1167 								   maThresRes.mnThresLogToPixX ),
1168 				 ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
1169 								   maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1170 								   maThresRes.mnThresLogToPixY ) );
1171 }
1172 
1173 // -----------------------------------------------------------------------
1174 
LogicToPixel(const Rectangle & rLogicRect) const1175 Rectangle OutputDevice::LogicToPixel( const Rectangle& rLogicRect ) const
1176 {
1177 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1178 
1179 	if ( !mbMap || rLogicRect.IsEmpty() )
1180 		return rLogicRect;
1181 
1182 	return Rectangle( ImplLogicToPixel( rLogicRect.Left() + maMapRes.mnMapOfsX, mnDPIX,
1183 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1184 										maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1185 					  ImplLogicToPixel( rLogicRect.Top() + maMapRes.mnMapOfsY, mnDPIY,
1186 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1187 										maThresRes.mnThresLogToPixY )+mnOutOffOrigY,
1188 					  ImplLogicToPixel( rLogicRect.Right() + maMapRes.mnMapOfsX, mnDPIX,
1189 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1190 										maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1191 					  ImplLogicToPixel( rLogicRect.Bottom() + maMapRes.mnMapOfsY, mnDPIY,
1192 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1193 										maThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1194 }
1195 
1196 // -----------------------------------------------------------------------
1197 
LogicToPixel(const Polygon & rLogicPoly) const1198 Polygon OutputDevice::LogicToPixel( const Polygon& rLogicPoly ) const
1199 {
1200 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1201 	DBG_CHKOBJ( &rLogicPoly, Polygon, NULL );
1202 
1203 	if ( !mbMap )
1204 		return rLogicPoly;
1205 
1206 	sal_uInt16	i;
1207 	sal_uInt16	nPoints = rLogicPoly.GetSize();
1208 	Polygon aPoly( rLogicPoly );
1209 
1210 	// Pointer auf das Point-Array holen (Daten werden kopiert)
1211 	const Point* pPointAry = aPoly.GetConstPointAry();
1212 
1213     for ( i = 0; i < nPoints; i++ )
1214     {
1215         const Point* pPt = &(pPointAry[i]);
1216         Point aPt;
1217         aPt.X() = ImplLogicToPixel( pPt->X() + maMapRes.mnMapOfsX, mnDPIX,
1218                                     maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1219                                     maThresRes.mnThresLogToPixX )+mnOutOffOrigX;
1220         aPt.Y() = ImplLogicToPixel( pPt->Y() + maMapRes.mnMapOfsY, mnDPIY,
1221                                     maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1222                                     maThresRes.mnThresLogToPixY )+mnOutOffOrigY;
1223         aPoly[i] = aPt;
1224     }
1225 
1226 	return aPoly;
1227 }
1228 
1229 // -----------------------------------------------------------------------
1230 
LogicToPixel(const PolyPolygon & rLogicPolyPoly) const1231 PolyPolygon OutputDevice::LogicToPixel( const PolyPolygon& rLogicPolyPoly ) const
1232 {
1233 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1234 	DBG_CHKOBJ( &rLogicPolyPoly, PolyPolygon, NULL );
1235 
1236 	if ( !mbMap )
1237 		return rLogicPolyPoly;
1238 
1239 	PolyPolygon aPolyPoly( rLogicPolyPoly );
1240 	sal_uInt16		nPoly = aPolyPoly.Count();
1241 	for( sal_uInt16 i = 0; i < nPoly; i++ )
1242 	{
1243 		Polygon& rPoly = aPolyPoly[i];
1244 		rPoly = LogicToPixel( rPoly );
1245 	}
1246 	return aPolyPoly;
1247 }
1248 
1249 // -----------------------------------------------------------------------
1250 
LogicToPixel(const basegfx::B2DPolygon & rLogicPoly) const1251 basegfx::B2DPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolygon& rLogicPoly ) const
1252 {
1253     basegfx::B2DPolygon aTransformedPoly = rLogicPoly;
1254     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
1255     aTransformedPoly.transform( rTransformationMatrix );
1256     return aTransformedPoly;
1257 }
1258 
1259 // -----------------------------------------------------------------------
1260 
LogicToPixel(const basegfx::B2DPolyPolygon & rLogicPolyPoly) const1261 basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const
1262 {
1263     basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
1264     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
1265     aTransformedPoly.transform( rTransformationMatrix );
1266     return aTransformedPoly;
1267 }
1268 
1269 // -----------------------------------------------------------------------
1270 
LogicToPixel(const Region & rLogicRegion) const1271 Region OutputDevice::LogicToPixel( const Region& rLogicRegion ) const
1272 {
1273 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1274 
1275 	if(!mbMap || rLogicRegion.IsNull() || rLogicRegion.IsEmpty())
1276     {
1277 		return rLogicRegion;
1278     }
1279 
1280 	Region aRegion;
1281 
1282     if(rLogicRegion.getB2DPolyPolygon())
1283     {
1284         aRegion = Region(LogicToPixel(*rLogicRegion.getB2DPolyPolygon()));
1285     }
1286     else if(rLogicRegion.getPolyPolygon())
1287     {
1288         aRegion = Region(LogicToPixel(*rLogicRegion.getPolyPolygon()));
1289     }
1290     else if(rLogicRegion.getRegionBand())
1291     {
1292         RectangleVector aRectangles;
1293         rLogicRegion.GetRegionRectangles(aRectangles);
1294         const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1295 
1296         // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1297         for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); aRectIter++)
1298         {
1299             aRegion.Union(LogicToPixel(*aRectIter));
1300         }
1301 
1302         //long nX(0);
1303 		//long nY(0);
1304 		//long nWidth(0);
1305 		//long nHeight(0);
1306 		//ImplRegionInfo aInfo;
1307 		//aRegion.ImplBeginAddRect();
1308         //bool bRegionRect(rLogicRegion.ImplGetFirstRect(aInfo, nX, nY, nWidth, nHeight));
1309         //
1310         //while(bRegionRect)
1311 		//{
1312 		//	const Rectangle aRect(Point(nX, nY), Size(nWidth, nHeight));
1313 		//	aRegion.ImplAddRect(LogicToPixel(aRect));
1314 		//	bRegionRect = rLogicRegion.ImplGetNextRect(aInfo, nX, nY, nWidth, nHeight);
1315 		//}
1316         //
1317         //aRegion.ImplEndAddRect();
1318     }
1319 
1320 	return aRegion;
1321 }
1322 
1323 // -----------------------------------------------------------------------
1324 
LogicToPixel(const Point & rLogicPt,const MapMode & rMapMode) const1325 Point OutputDevice::LogicToPixel( const Point& rLogicPt,
1326 								  const MapMode& rMapMode ) const
1327 {
1328 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1329 
1330 	if ( rMapMode.IsDefault() )
1331 		return rLogicPt;
1332 
1333 	// MapMode-Aufloesung berechnen und Umrechnen
1334 	ImplMapRes			aMapRes;
1335 	ImplThresholdRes	aThresRes;
1336 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1337 
1338 	return Point( ImplLogicToPixel( rLogicPt.X() + aMapRes.mnMapOfsX, mnDPIX,
1339 									aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1340 									aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1341 				  ImplLogicToPixel( rLogicPt.Y() + aMapRes.mnMapOfsY, mnDPIY,
1342 									aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1343 									aThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1344 }
1345 
1346 // -----------------------------------------------------------------------
1347 
LogicToPixel(const Size & rLogicSize,const MapMode & rMapMode) const1348 Size OutputDevice::LogicToPixel( const Size& rLogicSize,
1349 								 const MapMode& rMapMode ) const
1350 {
1351 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1352 
1353 	if ( rMapMode.IsDefault() )
1354 		return rLogicSize;
1355 
1356 	// MapMode-Aufloesung berechnen und Umrechnen
1357 	ImplMapRes			aMapRes;
1358 	ImplThresholdRes	aThresRes;
1359 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1360 
1361 	return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
1362 								   aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1363 								   aThresRes.mnThresLogToPixX ),
1364 				 ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
1365 								   aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1366 								   aThresRes.mnThresLogToPixY ) );
1367 }
1368 
1369 // -----------------------------------------------------------------------
1370 
LogicToPixel(const Rectangle & rLogicRect,const MapMode & rMapMode) const1371 Rectangle OutputDevice::LogicToPixel( const Rectangle& rLogicRect,
1372 									  const MapMode& rMapMode ) const
1373 {
1374 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1375 
1376 	if ( rMapMode.IsDefault() || rLogicRect.IsEmpty() )
1377 		return rLogicRect;
1378 
1379 	// MapMode-Aufloesung berechnen und Umrechnen
1380 	ImplMapRes			aMapRes;
1381 	ImplThresholdRes	aThresRes;
1382 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1383 
1384 	return Rectangle( ImplLogicToPixel( rLogicRect.Left() + aMapRes.mnMapOfsX, mnDPIX,
1385 										aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1386 										aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1387 					  ImplLogicToPixel( rLogicRect.Top() + aMapRes.mnMapOfsY, mnDPIY,
1388 										aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1389 										aThresRes.mnThresLogToPixY )+mnOutOffOrigY,
1390 					  ImplLogicToPixel( rLogicRect.Right() + aMapRes.mnMapOfsX, mnDPIX,
1391 										aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1392 										aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1393 					  ImplLogicToPixel( rLogicRect.Bottom() + aMapRes.mnMapOfsY, mnDPIY,
1394 										aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1395 										aThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1396 }
1397 
1398 // -----------------------------------------------------------------------
1399 
LogicToPixel(const Polygon & rLogicPoly,const MapMode & rMapMode) const1400 Polygon OutputDevice::LogicToPixel( const Polygon& rLogicPoly,
1401 									const MapMode& rMapMode ) const
1402 {
1403 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1404 	DBG_CHKOBJ( &rLogicPoly, Polygon, NULL );
1405 
1406 	if ( rMapMode.IsDefault() )
1407 		return rLogicPoly;
1408 
1409 	// MapMode-Aufloesung berechnen und Umrechnen
1410 	ImplMapRes			aMapRes;
1411 	ImplThresholdRes	aThresRes;
1412 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1413 
1414 	sal_uInt16	i;
1415 	sal_uInt16	nPoints = rLogicPoly.GetSize();
1416 	Polygon aPoly( rLogicPoly );
1417 
1418 	// Pointer auf das Point-Array holen (Daten werden kopiert)
1419 	const Point* pPointAry = aPoly.GetConstPointAry();
1420 
1421     for ( i = 0; i < nPoints; i++ )
1422     {
1423         const Point* pPt = &(pPointAry[i]);
1424         Point aPt;
1425         aPt.X() = ImplLogicToPixel( pPt->X() + aMapRes.mnMapOfsX, mnDPIX,
1426                                     aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1427                                     aThresRes.mnThresLogToPixX )+mnOutOffOrigX;
1428         aPt.Y() = ImplLogicToPixel( pPt->Y() + aMapRes.mnMapOfsY, mnDPIY,
1429                                     aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1430                                     aThresRes.mnThresLogToPixY )+mnOutOffOrigY;
1431         aPoly[i] = aPt;
1432     }
1433 
1434 	return aPoly;
1435 }
1436 
1437 // -----------------------------------------------------------------------
1438 
LogicToPixel(const PolyPolygon & rLogicPolyPoly,const MapMode & rMapMode) const1439 PolyPolygon OutputDevice::LogicToPixel( const PolyPolygon& rLogicPolyPoly,
1440 										const MapMode& rMapMode ) const
1441 {
1442 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1443 	DBG_CHKOBJ( &rLogicPolyPoly, PolyPolygon, NULL );
1444 
1445 	if ( rMapMode.IsDefault() )
1446 		return rLogicPolyPoly;
1447 
1448 	PolyPolygon aPolyPoly( rLogicPolyPoly );
1449 	sal_uInt16		nPoly = aPolyPoly.Count();
1450 	for( sal_uInt16 i = 0; i < nPoly; i++ )
1451 	{
1452 		Polygon& rPoly = aPolyPoly[i];
1453 		rPoly = LogicToPixel( rPoly, rMapMode );
1454 	}
1455 	return aPolyPoly;
1456 }
1457 
1458 // -----------------------------------------------------------------------
1459 
LogicToPixel(const basegfx::B2DPolyPolygon & rLogicPolyPoly,const MapMode & rMapMode) const1460 basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly,
1461                                                     const MapMode& rMapMode ) const
1462 {
1463     basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
1464     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
1465     aTransformedPoly.transform( rTransformationMatrix );
1466     return aTransformedPoly;
1467 }
1468 
1469 // -----------------------------------------------------------------------
1470 
LogicToPixel(const basegfx::B2DPolygon & rLogicPoly,const MapMode & rMapMode) const1471 basegfx::B2DPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolygon& rLogicPoly,
1472                                                 const MapMode& rMapMode ) const
1473 {
1474     basegfx::B2DPolygon aTransformedPoly = rLogicPoly;
1475     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
1476     aTransformedPoly.transform( rTransformationMatrix );
1477     return aTransformedPoly;
1478 }
1479 
1480 // -----------------------------------------------------------------------
1481 
LogicToPixel(const Region & rLogicRegion,const MapMode & rMapMode) const1482 Region OutputDevice::LogicToPixel( const Region& rLogicRegion, const MapMode& rMapMode ) const
1483 {
1484 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1485 
1486 	if(rMapMode.IsDefault() || rLogicRegion.IsNull() || rLogicRegion.IsEmpty())
1487     {
1488 		return rLogicRegion;
1489     }
1490 
1491 	Region aRegion;
1492 
1493     if(rLogicRegion.getB2DPolyPolygon())
1494     {
1495         aRegion = Region(LogicToPixel(*rLogicRegion.getB2DPolyPolygon(), rMapMode));
1496     }
1497     else if(rLogicRegion.getPolyPolygon())
1498     {
1499         aRegion = Region(LogicToPixel(*rLogicRegion.getPolyPolygon(), rMapMode));
1500     }
1501     else if(rLogicRegion.getRegionBand())
1502     {
1503         RectangleVector aRectangles;
1504         rLogicRegion.GetRegionRectangles(aRectangles);
1505         const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1506 
1507         // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1508         for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); aRectIter++)
1509         {
1510             aRegion.Union(LogicToPixel(*aRectIter, rMapMode));
1511         }
1512 
1513 		//long nX(0);
1514 		//long nY(0);
1515 		//long nWidth(0);
1516 		//long nHeight(0);
1517 		//ImplRegionInfo aInfo;
1518 		//aRegion.ImplBeginAddRect();
1519 		//bool bRegionRect(rLogicRegion.ImplGetFirstRect(aInfo, nX, nY, nWidth, nHeight));
1520         //
1521 		//while(bRegionRect)
1522 		//{
1523 		//	const Rectangle aRect(Point(nX, nY), Size(nWidth, nHeight));
1524 		//	aRegion.ImplAddRect(LogicToPixel(aRect, rMapMode));
1525 		//	bRegionRect = rLogicRegion.ImplGetNextRect(aInfo, nX, nY, nWidth, nHeight);
1526 		//}
1527         //
1528         //aRegion.ImplEndAddRect();
1529     }
1530 
1531 	return aRegion;
1532 }
1533 
1534 // -----------------------------------------------------------------------
1535 
PixelToLogic(const Point & rDevicePt) const1536 Point OutputDevice::PixelToLogic( const Point& rDevicePt ) const
1537 {
1538 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1539 
1540 	if ( !mbMap )
1541 		return rDevicePt;
1542 
1543 	return Point( ImplPixelToLogic( rDevicePt.X(), mnDPIX,
1544 									maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1545 									maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1546 				  ImplPixelToLogic( rDevicePt.Y(), mnDPIY,
1547 									maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1548 									maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY );
1549 }
1550 
1551 // -----------------------------------------------------------------------
1552 
PixelToLogic(const Size & rDeviceSize) const1553 Size OutputDevice::PixelToLogic( const Size& rDeviceSize ) const
1554 {
1555 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1556 
1557 	if ( !mbMap )
1558 		return rDeviceSize;
1559 
1560 	return Size( ImplPixelToLogic( rDeviceSize.Width(), mnDPIX,
1561 								   maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1562 								   maThresRes.mnThresPixToLogX ),
1563 				 ImplPixelToLogic( rDeviceSize.Height(), mnDPIY,
1564 								   maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1565 								   maThresRes.mnThresPixToLogY ) );
1566 }
1567 
1568 // -----------------------------------------------------------------------
1569 
PixelToLogic(const Rectangle & rDeviceRect) const1570 Rectangle OutputDevice::PixelToLogic( const Rectangle& rDeviceRect ) const
1571 {
1572 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1573 
1574 	if ( !mbMap || rDeviceRect.IsEmpty() )
1575 		return rDeviceRect;
1576 
1577 	return Rectangle( ImplPixelToLogic( rDeviceRect.Left(), mnDPIX,
1578 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1579 										maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1580 					  ImplPixelToLogic( rDeviceRect.Top(), mnDPIY,
1581 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1582 										maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY,
1583 					  ImplPixelToLogic( rDeviceRect.Right(), mnDPIX,
1584 										maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1585 										maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1586 					  ImplPixelToLogic( rDeviceRect.Bottom(), mnDPIY,
1587 										maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1588 										maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY );
1589 }
1590 
1591 // -----------------------------------------------------------------------
1592 
PixelToLogic(const Polygon & rDevicePoly) const1593 Polygon OutputDevice::PixelToLogic( const Polygon& rDevicePoly ) const
1594 {
1595 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1596 	DBG_CHKOBJ( &rDevicePoly, Polygon, NULL );
1597 
1598 	if ( !mbMap )
1599 		return rDevicePoly;
1600 
1601 	sal_uInt16	i;
1602 	sal_uInt16	nPoints = rDevicePoly.GetSize();
1603 	Polygon aPoly( rDevicePoly );
1604 
1605 	// Pointer auf das Point-Array holen (Daten werden kopiert)
1606 	const Point* pPointAry = aPoly.GetConstPointAry();
1607 
1608     for ( i = 0; i < nPoints; i++ )
1609     {
1610         const Point* pPt = &(pPointAry[i]);
1611         Point aPt;
1612         aPt.X() = ImplPixelToLogic( pPt->X(), mnDPIX,
1613                                     maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1614                                     maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX;
1615         aPt.Y() = ImplPixelToLogic( pPt->Y(), mnDPIY,
1616                                     maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1617                                     maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY;
1618         aPoly[i] = aPt;
1619     }
1620 
1621 	return aPoly;
1622 }
1623 
1624 // -----------------------------------------------------------------------
1625 
PixelToLogic(const PolyPolygon & rDevicePolyPoly) const1626 PolyPolygon OutputDevice::PixelToLogic( const PolyPolygon& rDevicePolyPoly ) const
1627 {
1628 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1629 	DBG_CHKOBJ( &rDevicePolyPoly, PolyPolygon, NULL );
1630 
1631 	if ( !mbMap )
1632 		return rDevicePolyPoly;
1633 
1634 	PolyPolygon aPolyPoly( rDevicePolyPoly );
1635 	sal_uInt16		nPoly = aPolyPoly.Count();
1636 	for( sal_uInt16 i = 0; i < nPoly; i++ )
1637 	{
1638 		Polygon& rPoly = aPolyPoly[i];
1639 		rPoly = PixelToLogic( rPoly );
1640 	}
1641 	return aPolyPoly;
1642 }
1643 
1644 // -----------------------------------------------------------------------
1645 
PixelToLogic(const basegfx::B2DPolygon & rPixelPoly) const1646 basegfx::B2DPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolygon& rPixelPoly ) const
1647 {
1648     basegfx::B2DPolygon aTransformedPoly = rPixelPoly;
1649     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation();
1650     aTransformedPoly.transform( rTransformationMatrix );
1651     return aTransformedPoly;
1652 }
1653 
1654 // -----------------------------------------------------------------------
1655 
PixelToLogic(const basegfx::B2DPolyPolygon & rPixelPolyPoly) const1656 basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygon& rPixelPolyPoly ) const
1657 {
1658     basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
1659     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation();
1660     aTransformedPoly.transform( rTransformationMatrix );
1661     return aTransformedPoly;
1662 }
1663 
1664 // -----------------------------------------------------------------------
1665 
PixelToLogic(const Region & rDeviceRegion) const1666 Region OutputDevice::PixelToLogic( const Region& rDeviceRegion ) const
1667 {
1668 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1669 
1670 	if(!mbMap || rDeviceRegion.IsNull() || rDeviceRegion.IsEmpty())
1671     {
1672 		return rDeviceRegion;
1673     }
1674 
1675 	Region aRegion;
1676 
1677     if(rDeviceRegion.getB2DPolyPolygon())
1678     {
1679         aRegion = Region(PixelToLogic(*rDeviceRegion.getB2DPolyPolygon()));
1680     }
1681     else if(rDeviceRegion.getPolyPolygon())
1682     {
1683 	    aRegion = Region(PixelToLogic(*rDeviceRegion.getPolyPolygon()));
1684     }
1685     else if(rDeviceRegion.getRegionBand())
1686     {
1687         RectangleVector aRectangles;
1688         rDeviceRegion.GetRegionRectangles(aRectangles);
1689         const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1690 
1691         // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1692         for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); aRectIter++)
1693         {
1694             aRegion.Union(PixelToLogic(*aRectIter));
1695         }
1696 
1697 		//long nX(0);
1698 		//long nY(0);
1699 		//long nWidth(0);
1700 		//long nHeight(0);
1701 		//ImplRegionInfo aInfo;
1702 		//aRegion.ImplBeginAddRect();
1703 		//bool bRegionRect(rDeviceRegion.ImplGetFirstRect(aInfo, nX, nY, nWidth, nHeight));
1704         //
1705 		//while(bRegionRect)
1706 		//{
1707 		//	const Rectangle aRect(Point(nX, nY), Size(nWidth, nHeight));
1708 		//	aRegion.ImplAddRect(PixelToLogic(aRect));
1709 		//	bRegionRect = rDeviceRegion.ImplGetNextRect(aInfo, nX, nY, nWidth, nHeight);
1710 		//}
1711         //
1712         //aRegion.ImplEndAddRect();
1713     }
1714 
1715 	return aRegion;
1716 }
1717 
1718 // -----------------------------------------------------------------------
1719 
PixelToLogic(const Point & rDevicePt,const MapMode & rMapMode) const1720 Point OutputDevice::PixelToLogic( const Point& rDevicePt,
1721 								  const MapMode& rMapMode ) const
1722 {
1723 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1724 
1725 	// Ist Default-MapMode, dann bereche nichts
1726 	if ( rMapMode.IsDefault() )
1727 		return rDevicePt;
1728 
1729 	// MapMode-Aufloesung berechnen und Umrechnen
1730 	ImplMapRes			aMapRes;
1731 	ImplThresholdRes	aThresRes;
1732 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1733 
1734 	return Point( ImplPixelToLogic( rDevicePt.X(), mnDPIX,
1735 									aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1736 									aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1737 				  ImplPixelToLogic( rDevicePt.Y(), mnDPIY,
1738 									aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1739 									aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY );
1740 }
1741 
1742 // -----------------------------------------------------------------------
1743 
PixelToLogic(const Size & rDeviceSize,const MapMode & rMapMode) const1744 Size OutputDevice::PixelToLogic( const Size& rDeviceSize,
1745 								 const MapMode& rMapMode ) const
1746 {
1747 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1748 
1749 	// Ist Default-MapMode, dann bereche nichts
1750 	if ( rMapMode.IsDefault() )
1751 		return rDeviceSize;
1752 
1753 	// MapMode-Aufloesung berechnen und Umrechnen
1754 	ImplMapRes			aMapRes;
1755 	ImplThresholdRes	aThresRes;
1756 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1757 
1758 	return Size( ImplPixelToLogic( rDeviceSize.Width(), mnDPIX,
1759 								   aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1760 								   aThresRes.mnThresPixToLogX ),
1761 				 ImplPixelToLogic( rDeviceSize.Height(), mnDPIY,
1762 								   aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1763 								   aThresRes.mnThresPixToLogY ) );
1764 }
1765 
1766 // -----------------------------------------------------------------------
1767 
PixelToLogic(const Rectangle & rDeviceRect,const MapMode & rMapMode) const1768 Rectangle OutputDevice::PixelToLogic( const Rectangle& rDeviceRect,
1769 									  const MapMode& rMapMode ) const
1770 {
1771 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1772 
1773 	// Ist Default-MapMode, dann bereche nichts
1774 	if ( rMapMode.IsDefault() || rDeviceRect.IsEmpty() )
1775 		return rDeviceRect;
1776 
1777 	// MapMode-Aufloesung berechnen und Umrechnen
1778 	ImplMapRes			aMapRes;
1779 	ImplThresholdRes	aThresRes;
1780 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1781 
1782 	return Rectangle( ImplPixelToLogic( rDeviceRect.Left(), mnDPIX,
1783 										aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1784 										aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1785 					  ImplPixelToLogic( rDeviceRect.Top(), mnDPIY,
1786 										aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1787 										aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY,
1788 					  ImplPixelToLogic( rDeviceRect.Right(), mnDPIX,
1789 										aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1790 										aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1791 					  ImplPixelToLogic( rDeviceRect.Bottom(), mnDPIY,
1792 										aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1793 										aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY );
1794 }
1795 
1796 // -----------------------------------------------------------------------
1797 
PixelToLogic(const Polygon & rDevicePoly,const MapMode & rMapMode) const1798 Polygon OutputDevice::PixelToLogic( const Polygon& rDevicePoly,
1799 									const MapMode& rMapMode ) const
1800 {
1801 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1802 	DBG_CHKOBJ( &rDevicePoly, Polygon, NULL );
1803 
1804 	// Ist Default-MapMode, dann bereche nichts
1805 	if ( rMapMode.IsDefault() )
1806 		return rDevicePoly;
1807 
1808 	// MapMode-Aufloesung berechnen und Umrechnen
1809 	ImplMapRes			aMapRes;
1810 	ImplThresholdRes	aThresRes;
1811 	ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1812 
1813 	sal_uInt16	i;
1814 	sal_uInt16	nPoints = rDevicePoly.GetSize();
1815 	Polygon aPoly( rDevicePoly );
1816 
1817 	// Pointer auf das Point-Array holen (Daten werden kopiert)
1818 	const Point* pPointAry = aPoly.GetConstPointAry();
1819 
1820     for ( i = 0; i < nPoints; i++ )
1821     {
1822         const Point* pPt = &(pPointAry[i]);
1823         Point aPt;
1824         aPt.X() = ImplPixelToLogic( pPt->X(), mnDPIX,
1825                                     aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1826                                     aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX;
1827         aPt.Y() = ImplPixelToLogic( pPt->Y(), mnDPIY,
1828                                     aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1829                                     aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY;
1830         aPoly[i] = aPt;
1831     }
1832 
1833 	return aPoly;
1834 }
1835 
1836 // -----------------------------------------------------------------------
1837 
PixelToLogic(const PolyPolygon & rDevicePolyPoly,const MapMode & rMapMode) const1838 PolyPolygon OutputDevice::PixelToLogic( const PolyPolygon& rDevicePolyPoly,
1839 										const MapMode& rMapMode ) const
1840 {
1841 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1842 	DBG_CHKOBJ( &rDevicePolyPoly, PolyPolygon, NULL );
1843 
1844 	if ( rMapMode.IsDefault() )
1845 		return rDevicePolyPoly;
1846 
1847 	PolyPolygon aPolyPoly( rDevicePolyPoly );
1848 	sal_uInt16		nPoly = aPolyPoly.Count();
1849 	for( sal_uInt16 i = 0; i < nPoly; i++ )
1850 	{
1851 		Polygon& rPoly = aPolyPoly[i];
1852 		rPoly = PixelToLogic( rPoly, rMapMode );
1853 	}
1854 	return aPolyPoly;
1855 }
1856 
1857 // -----------------------------------------------------------------------
1858 
PixelToLogic(const basegfx::B2DPolygon & rPixelPoly,const MapMode & rMapMode) const1859 basegfx::B2DPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolygon& rPixelPoly,
1860                                                 const MapMode& rMapMode ) const
1861 {
1862     basegfx::B2DPolygon aTransformedPoly = rPixelPoly;
1863     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
1864     aTransformedPoly.transform( rTransformationMatrix );
1865     return aTransformedPoly;
1866 }
1867 
1868 // -----------------------------------------------------------------------
1869 
PixelToLogic(const basegfx::B2DPolyPolygon & rPixelPolyPoly,const MapMode & rMapMode) const1870 basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygon& rPixelPolyPoly,
1871                                                     const MapMode& rMapMode ) const
1872 {
1873     basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
1874     const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
1875     aTransformedPoly.transform( rTransformationMatrix );
1876     return aTransformedPoly;
1877 }
1878 
1879 // -----------------------------------------------------------------------
1880 
PixelToLogic(const Region & rDeviceRegion,const MapMode & rMapMode) const1881 Region OutputDevice::PixelToLogic( const Region& rDeviceRegion, const MapMode& rMapMode ) const
1882 {
1883 	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1884 
1885 	if(rMapMode.IsDefault() || rDeviceRegion.IsNull() || rDeviceRegion.IsEmpty())
1886     {
1887 		return rDeviceRegion;
1888     }
1889 
1890 	Region aRegion;
1891 
1892     if(rDeviceRegion.getB2DPolyPolygon())
1893     {
1894         aRegion = Region(PixelToLogic(*rDeviceRegion.getB2DPolyPolygon(), rMapMode));
1895     }
1896     else if(rDeviceRegion.getPolyPolygon())
1897     {
1898 	    aRegion = Region(PixelToLogic(*rDeviceRegion.getPolyPolygon(), rMapMode));
1899     }
1900     else if(rDeviceRegion.getRegionBand())
1901     {
1902         RectangleVector aRectangles;
1903         rDeviceRegion.GetRegionRectangles(aRectangles);
1904         const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1905 
1906         // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1907         for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); aRectIter++)
1908         {
1909             aRegion.Union(PixelToLogic(*aRectIter, rMapMode));
1910         }
1911 
1912 		//long nX(0);
1913 		//long nY(0);
1914 		//long nWidth(0);
1915 		//long nHeight(0);
1916 		//ImplRegionInfo aInfo;
1917 		//aRegion.ImplBeginAddRect();
1918 		//bool bRegionRect(rDeviceRegion.ImplGetFirstRect(aInfo, nX, nY, nWidth, nHeight));
1919         //
1920 		//while(bRegionRect)
1921 		//{
1922 		//	const Rectangle aRect(Point(nX, nY), Size(nWidth, nHeight));
1923 		//	aRegion.ImplAddRect(PixelToLogic(aRect, rMapMode));
1924 		//	bRegionRect = rDeviceRegion.ImplGetNextRect(aInfo, nX, nY, nWidth, nHeight);
1925 		//}
1926         //
1927         //aRegion.ImplEndAddRect();
1928     }
1929 
1930 	return aRegion;
1931 }
1932 
1933 // -----------------------------------------------------------------------
1934 
1935 #define ENTER0( rSource, pMapModeSource, pMapModeDest ) 				\
1936 	if ( !pMapModeSource )												\
1937 		pMapModeSource = &maMapMode;									\
1938 	if ( !pMapModeDest )												\
1939 		pMapModeDest = &maMapMode;										\
1940 	if ( *pMapModeSource == *pMapModeDest ) 							\
1941 		return rSource
1942 
1943 // -----------------------------------------------------------------------
1944 
1945 #define ENTER1( rSource, pMapModeSource, pMapModeDest ) 				\
1946 	ENTER0( rSource, pMapModeSource, pMapModeDest );					\
1947 																		\
1948 	ImplMapRes aMapResSource;											\
1949 	ImplMapRes aMapResDest; 											\
1950 																		\
1951 	if ( !mbMap || pMapModeSource != &maMapMode )						\
1952 	{																	\
1953 		if ( pMapModeSource->GetMapUnit() == MAP_RELATIVE ) 			\
1954 			aMapResSource = maMapRes;									\
1955 		ImplCalcMapResolution( *pMapModeSource, 						\
1956 							   mnDPIX, mnDPIY, aMapResSource ); 		\
1957 	}																	\
1958 	else																\
1959 		aMapResSource = maMapRes;										\
1960 	if ( !mbMap || pMapModeDest != &maMapMode ) 						\
1961 	{																	\
1962 		if ( pMapModeDest->GetMapUnit() == MAP_RELATIVE )				\
1963 			aMapResDest = maMapRes; 									\
1964 		ImplCalcMapResolution( *pMapModeDest,							\
1965 							   mnDPIX, mnDPIY, aMapResDest );			\
1966 	}																	\
1967 	else																\
1968 		aMapResDest = maMapRes
1969 
1970 // -----------------------------------------------------------------------
1971 
1972 #define ENTER2( eUnitSource, eUnitDest )								\
1973 	DBG_ASSERT( eUnitSource != MAP_SYSFONT								\
1974 				&& eUnitSource != MAP_APPFONT							\
1975 				&& eUnitSource != MAP_RELATIVE, 						\
1976 				"Source MapUnit nicht erlaubt" );                       \
1977 	DBG_ASSERT( eUnitDest != MAP_SYSFONT								\
1978 				&& eUnitDest != MAP_APPFONT 							\
1979 				&& eUnitDest != MAP_RELATIVE,							\
1980 				"Destination MapUnit nicht erlaubt" );                  \
1981 	DBG_ASSERTWARNING( eUnitSource != MAP_PIXEL,						\
1982 					   "MAP_PIXEL mit 72dpi angenaehert" );             \
1983 	DBG_ASSERTWARNING( eUnitDest != MAP_PIXEL,							\
1984 					   "MAP_PIXEL mit 72dpi angenaehert" )
1985 
1986 // -----------------------------------------------------------------------
1987 
1988 #define ENTER3( eUnitSource, eUnitDest )								\
1989 	long nNumerator 	 = 1;		\
1990 	long nDenominator	 = 1;		\
1991 	DBG_ASSERT( eUnitSource < s_ImplArySize, "Invalid source map unit");	\
1992 	DBG_ASSERT( eUnitDest < s_ImplArySize, "Invalid destination map unit");	\
1993 	if( (eUnitSource < s_ImplArySize) && (eUnitDest < s_ImplArySize) )	\
1994 	{	\
1995 		nNumerator 	 = aImplNumeratorAry[eUnitSource] * 			\
1996 						   aImplDenominatorAry[eUnitDest];				\
1997 		nDenominator	 = aImplNumeratorAry[eUnitDest] *				\
1998 						   aImplDenominatorAry[eUnitSource];			\
1999 	} \
2000 	if ( eUnitSource == MAP_PIXEL ) 									\
2001 		nDenominator *= 72; 											\
2002 	else if( eUnitDest == MAP_PIXEL )									\
2003 		nNumerator *= 72
2004 
2005 // -----------------------------------------------------------------------
2006 
2007 #define ENTER4( rMapModeSource, rMapModeDest )							\
2008 	ImplMapRes aMapResSource;											\
2009 	ImplMapRes aMapResDest; 											\
2010 																		\
2011 	ImplCalcMapResolution( rMapModeSource, 72, 72, aMapResSource ); 	\
2012 	ImplCalcMapResolution( rMapModeDest, 72, 72, aMapResDest )
2013 
2014 // -----------------------------------------------------------------------
2015 
2016 // return (n1 * n2 * n3) / (n4 * n5)
fn5(const long n1,const long n2,const long n3,const long n4,const long n5)2017 static long fn5( const long n1,
2018 				 const long n2,
2019 				 const long n3,
2020 				 const long n4,
2021 				 const long n5 )
2022 {
2023 	if ( n1 == 0 || n2 == 0 || n3 == 0 || n4 == 0 || n5 == 0 )
2024 		return 0;
2025 	if ( LONG_MAX / Abs(n2) < Abs(n3) )
2026 	{
2027 		// a6 wird "ubersprungen
2028 		BigInt a7 = n2;
2029 		a7 *= n3;
2030 		a7 *= n1;
2031 
2032 		if ( LONG_MAX / Abs(n4) < Abs(n5) )
2033 		{
2034 			BigInt a8 = n4;
2035 			a8 *= n5;
2036 
2037 			BigInt a9 = a8;
2038 			a9 /= 2;
2039 			if ( a7.IsNeg() )
2040 				a7 -= a9;
2041 			else
2042 				a7 += a9;
2043 
2044 			a7 /= a8;
2045 		} // of if
2046 		else
2047 		{
2048 			long n8 = n4 * n5;
2049 
2050 			if ( a7.IsNeg() )
2051 				a7 -= n8 / 2;
2052 			else
2053 				a7 += n8 / 2;
2054 
2055 			a7 /= n8;
2056 		} // of else
2057 		return (long)a7;
2058 	} // of if
2059 	else
2060 	{
2061 		long n6 = n2 * n3;
2062 
2063 		if ( LONG_MAX / Abs(n1) < Abs(n6) )
2064 		{
2065 			BigInt a7 = n1;
2066 			a7 *= n6;
2067 
2068 			if ( LONG_MAX / Abs(n4) < Abs(n5) )
2069 			{
2070 				BigInt a8 = n4;
2071 				a8 *= n5;
2072 
2073 				BigInt a9 = a8;
2074 				a9 /= 2;
2075 				if ( a7.IsNeg() )
2076 					a7 -= a9;
2077 				else
2078 					a7 += a9;
2079 
2080 				a7 /= a8;
2081 			} // of if
2082 			else
2083 			{
2084 				long n8 = n4 * n5;
2085 
2086 				if ( a7.IsNeg() )
2087 					a7 -= n8 / 2;
2088 				else
2089 					a7 += n8 / 2;
2090 
2091 				a7 /= n8;
2092 			} // of else
2093 			return (long)a7;
2094 		} // of if
2095 		else
2096 		{
2097 			long n7 = n1 * n6;
2098 
2099 			if ( LONG_MAX / Abs(n4) < Abs(n5) )
2100 			{
2101 				BigInt a7 = n7;
2102 				BigInt a8 = n4;
2103 				a8 *= n5;
2104 
2105 				BigInt a9 = a8;
2106 				a9 /= 2;
2107 				if ( a7.IsNeg() )
2108 					a7 -= a9;
2109 				else
2110 					a7 += a9;
2111 
2112 				a7 /= a8;
2113 				return (long)a7;
2114 			} // of if
2115 			else
2116 			{
2117 				const long n8 = n4 * n5;
2118 				const long n8_2 = n8 / 2;
2119 
2120 				if( n7 < 0 )
2121 				{
2122 					if( ( n7 - LONG_MIN ) >= n8_2 )
2123 						n7 -= n8_2;
2124 				}
2125 				else if( ( LONG_MAX - n7 ) >= n8_2 )
2126 					n7 += n8_2;
2127 
2128 				return n7 / n8;
2129 			} // of else
2130 		} // of else
2131 	} // of else
2132 }
2133 
2134 // -----------------------------------------------------------------------
2135 
2136 // return (n1 * n2) / n3
fn3(const long n1,const long n2,const long n3)2137 static long fn3( const long n1, const long n2, const long n3 )
2138 {
2139 	if ( n1 == 0 || n2 == 0 || n3 == 0 )
2140 		return 0;
2141 	if ( LONG_MAX / Abs(n1) < Abs(n2) )
2142 	{
2143 		BigInt a4 = n1;
2144 		a4 *= n2;
2145 
2146 		if ( a4.IsNeg() )
2147 			a4 -= n3 / 2;
2148 		else
2149 			a4 += n3 / 2;
2150 
2151 		a4 /= n3;
2152 		return (long)a4;
2153 	} // of if
2154 	else
2155 	{
2156 		long		n4 = n1 * n2;
2157 		const long	n3_2 = n3 / 2;
2158 
2159 		if( n4 < 0 )
2160 		{
2161 			if( ( n4 - LONG_MIN ) >= n3_2 )
2162 				n4 -= n3_2;
2163 		}
2164 		else if( ( LONG_MAX - n4 ) >= n3_2 )
2165 			n4 += n3_2;
2166 
2167 		return n4 / n3;
2168 	} // of else
2169 }
2170 
2171 // -----------------------------------------------------------------------
2172 
LogicToLogic(const Point & rPtSource,const MapMode * pMapModeSource,const MapMode * pMapModeDest) const2173 Point OutputDevice::LogicToLogic( const Point& rPtSource,
2174 								  const MapMode* pMapModeSource,
2175 								  const MapMode* pMapModeDest ) const
2176 {
2177 	ENTER1( rPtSource, pMapModeSource, pMapModeDest );
2178 
2179 	return Point( fn5( rPtSource.X() + aMapResSource.mnMapOfsX,
2180 					   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2181 					   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2182 				  aMapResDest.mnMapOfsX,
2183 				  fn5( rPtSource.Y() + aMapResSource.mnMapOfsY,
2184 					   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2185 					   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2186 				  aMapResDest.mnMapOfsY );
2187 }
2188 
2189 // -----------------------------------------------------------------------
2190 
LogicToLogic(const Size & rSzSource,const MapMode * pMapModeSource,const MapMode * pMapModeDest) const2191 Size OutputDevice::LogicToLogic( const Size& rSzSource,
2192 								 const MapMode* pMapModeSource,
2193 								 const MapMode* pMapModeDest ) const
2194 {
2195 	ENTER1( rSzSource, pMapModeSource, pMapModeDest );
2196 
2197 	return Size( fn5( rSzSource.Width(),
2198 					  aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2199 					  aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ),
2200 				 fn5( rSzSource.Height(),
2201 					  aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2202 					  aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) );
2203 }
2204 
2205 // -----------------------------------------------------------------------
2206 
LogicToLogic(const Rectangle & rRectSource,const MapMode * pMapModeSource,const MapMode * pMapModeDest) const2207 Rectangle OutputDevice::LogicToLogic( const Rectangle& rRectSource,
2208 									  const MapMode* pMapModeSource,
2209 									  const MapMode* pMapModeDest ) const
2210 {
2211 	ENTER1( rRectSource, pMapModeSource, pMapModeDest );
2212 
2213 	return Rectangle( fn5( rRectSource.Left() + aMapResSource.mnMapOfsX,
2214 						   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2215 						   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2216 					  aMapResDest.mnMapOfsX,
2217 					  fn5( rRectSource.Top() + aMapResSource.mnMapOfsY,
2218 						   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2219 						   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2220 					  aMapResDest.mnMapOfsY,
2221 					  fn5( rRectSource.Right() + aMapResSource.mnMapOfsX,
2222 						   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2223 						   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2224 					  aMapResDest.mnMapOfsX,
2225 					  fn5( rRectSource.Bottom() + aMapResSource.mnMapOfsY,
2226 						   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2227 						   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2228 					  aMapResDest.mnMapOfsY );
2229 }
2230 
2231 // -----------------------------------------------------------------------
2232 
LogicToLogic(long * pX,sal_uInt16 nCount,const MapMode * pMapModeSource,const MapMode * pMapModeDest) const2233 long* OutputDevice::LogicToLogic( long* pX, sal_uInt16 nCount,
2234 								  const MapMode* pMapModeSource,
2235 								  const MapMode* pMapModeDest ) const
2236 {
2237 	ENTER1( pX, pMapModeSource, pMapModeDest );
2238 
2239 	for( ; nCount; nCount--, pX++ )
2240 	{
2241 		*pX = fn5( *pX,
2242 				   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2243 				   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX );
2244 	}
2245 
2246 	return NULL;
2247 }
2248 
2249 // -----------------------------------------------------------------------
2250 
LogicToLogic(const Point & rPtSource,const MapMode & rMapModeSource,const MapMode & rMapModeDest)2251 Point OutputDevice::LogicToLogic( const Point& rPtSource,
2252 								  const MapMode& rMapModeSource,
2253 								  const MapMode& rMapModeDest )
2254 {
2255 	if ( rMapModeSource == rMapModeDest )
2256 		return rPtSource;
2257 
2258 	MapUnit eUnitSource = rMapModeSource.GetMapUnit();
2259 	MapUnit eUnitDest	= rMapModeDest.GetMapUnit();
2260 	ENTER2( eUnitSource, eUnitDest );
2261 
2262 	if ( rMapModeSource.mpImplMapMode->mbSimple &&
2263 		 rMapModeDest.mpImplMapMode->mbSimple )
2264 	{
2265 		ENTER3( eUnitSource, eUnitDest );
2266 
2267 		return Point( fn3( rPtSource.X(), nNumerator, nDenominator ),
2268 					  fn3( rPtSource.Y(), nNumerator, nDenominator ) );
2269 	}
2270 	else
2271 	{
2272 		ENTER4( rMapModeSource, rMapModeDest );
2273 
2274 		return Point( fn5( rPtSource.X() + aMapResSource.mnMapOfsX,
2275 						   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2276 						   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2277 					  aMapResDest.mnMapOfsX,
2278 					  fn5( rPtSource.Y() + aMapResSource.mnMapOfsY,
2279 						   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2280 						   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2281 					  aMapResDest.mnMapOfsY );
2282 	}
2283 }
2284 
2285 // -----------------------------------------------------------------------
2286 
LogicToLogic(const Size & rSzSource,const MapMode & rMapModeSource,const MapMode & rMapModeDest)2287 Size OutputDevice::LogicToLogic( const Size& rSzSource,
2288 								 const MapMode& rMapModeSource,
2289 								 const MapMode& rMapModeDest )
2290 {
2291 	if ( rMapModeSource == rMapModeDest )
2292 		return rSzSource;
2293 
2294 	MapUnit eUnitSource = rMapModeSource.GetMapUnit();
2295 	MapUnit eUnitDest	= rMapModeDest.GetMapUnit();
2296 	ENTER2( eUnitSource, eUnitDest );
2297 
2298 	if ( rMapModeSource.mpImplMapMode->mbSimple &&
2299 		 rMapModeDest.mpImplMapMode->mbSimple )
2300 	{
2301 		ENTER3( eUnitSource, eUnitDest );
2302 
2303 		return Size( fn3( rSzSource.Width(),  nNumerator, nDenominator ),
2304 					 fn3( rSzSource.Height(), nNumerator, nDenominator ) );
2305 	}
2306 	else
2307 	{
2308 		ENTER4( rMapModeSource, rMapModeDest );
2309 
2310 		return Size( fn5( rSzSource.Width(),
2311 						  aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2312 						  aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ),
2313 					 fn5( rSzSource.Height(),
2314 						  aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2315 						  aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) );
2316 	}
2317 }
2318 
2319 // -----------------------------------------------------------------------
2320 
LogicToLogic(const basegfx::B2DPolygon & rPolySource,const MapMode & rMapModeSource,const MapMode & rMapModeDest)2321 basegfx::B2DPolygon OutputDevice::LogicToLogic( const basegfx::B2DPolygon& rPolySource,
2322                                                 const MapMode& rMapModeSource,
2323                                                 const MapMode& rMapModeDest )
2324 {
2325     if(rMapModeSource == rMapModeDest)
2326     {
2327         return rPolySource;
2328     }
2329 
2330     const basegfx::B2DHomMatrix aTransform(LogicToLogic(rMapModeSource, rMapModeDest));
2331     basegfx::B2DPolygon aPoly(rPolySource);
2332 
2333     aPoly.transform(aTransform);
2334     return aPoly;
2335 }
2336 
2337 // -----------------------------------------------------------------------
2338 
LogicToLogic(const basegfx::B2DPolyPolygon & rPolySource,const MapMode & rMapModeSource,const MapMode & rMapModeDest)2339 basegfx::B2DPolyPolygon OutputDevice::LogicToLogic( const basegfx::B2DPolyPolygon& rPolySource,
2340                                                     const MapMode& rMapModeSource,
2341                                                     const MapMode& rMapModeDest )
2342 {
2343     if(rMapModeSource == rMapModeDest)
2344     {
2345         return rPolySource;
2346     }
2347 
2348     const basegfx::B2DHomMatrix aTransform(LogicToLogic(rMapModeSource, rMapModeDest));
2349     basegfx::B2DPolyPolygon aPoly(rPolySource);
2350 
2351     aPoly.transform(aTransform);
2352     return aPoly;
2353 }
2354 
2355 // -----------------------------------------------------------------------
2356 
LogicToLogic(const MapMode & rMapModeSource,const MapMode & rMapModeDest)2357 basegfx::B2DHomMatrix OutputDevice::LogicToLogic(const MapMode& rMapModeSource, const MapMode& rMapModeDest)
2358 {
2359     basegfx::B2DHomMatrix aTransform;
2360 
2361     if(rMapModeSource == rMapModeDest)
2362     {
2363         return aTransform;
2364     }
2365 
2366     MapUnit eUnitSource = rMapModeSource.GetMapUnit();
2367     MapUnit eUnitDest	= rMapModeDest.GetMapUnit();
2368     ENTER2(eUnitSource, eUnitDest);
2369 
2370     if(rMapModeSource.mpImplMapMode->mbSimple && rMapModeDest.mpImplMapMode->mbSimple)
2371     {
2372         ENTER3(eUnitSource, eUnitDest);
2373 
2374         const double fScaleFactor((double)nNumerator / (double)nDenominator);
2375         aTransform.set(0, 0, fScaleFactor);
2376         aTransform.set(1, 1, fScaleFactor);
2377     }
2378     else
2379     {
2380         ENTER4(rMapModeSource, rMapModeDest);
2381 
2382         const double fScaleFactorX((double(aMapResSource.mnMapScNumX) * double(aMapResDest.mnMapScDenomX)) / (double(aMapResSource.mnMapScDenomX) * double(aMapResDest.mnMapScNumX)));
2383         const double fScaleFactorY((double(aMapResSource.mnMapScNumY) * double(aMapResDest.mnMapScDenomY)) / (double(aMapResSource.mnMapScDenomY) * double(aMapResDest.mnMapScNumY)));
2384         const double fZeroPointX(double(aMapResSource.mnMapOfsX) * fScaleFactorX - double(aMapResDest.mnMapOfsX));
2385         const double fZeroPointY(double(aMapResSource.mnMapOfsY) * fScaleFactorY - double(aMapResDest.mnMapOfsY));
2386 
2387         aTransform.set(0, 0, fScaleFactorX);
2388         aTransform.set(1, 1, fScaleFactorY);
2389         aTransform.set(0, 2, fZeroPointX);
2390         aTransform.set(1, 2, fZeroPointY);
2391     }
2392 
2393     return aTransform;
2394 }
2395 
2396 // -----------------------------------------------------------------------
2397 
LogicToLogic(const Rectangle & rRectSource,const MapMode & rMapModeSource,const MapMode & rMapModeDest)2398 Rectangle OutputDevice::LogicToLogic( const Rectangle& rRectSource,
2399 									  const MapMode& rMapModeSource,
2400 									  const MapMode& rMapModeDest )
2401 {
2402 	if ( rMapModeSource == rMapModeDest )
2403 		return rRectSource;
2404 
2405 	MapUnit eUnitSource = rMapModeSource.GetMapUnit();
2406 	MapUnit eUnitDest	= rMapModeDest.GetMapUnit();
2407 	ENTER2( eUnitSource, eUnitDest );
2408 
2409 	if ( rMapModeSource.mpImplMapMode->mbSimple &&
2410 		 rMapModeDest.mpImplMapMode->mbSimple )
2411 	{
2412 		ENTER3( eUnitSource, eUnitDest );
2413 
2414 		return Rectangle( fn3( rRectSource.Left(), nNumerator, nDenominator ),
2415 						  fn3( rRectSource.Top(), nNumerator, nDenominator ),
2416 						  fn3( rRectSource.Right(), nNumerator, nDenominator ),
2417 						  fn3( rRectSource.Bottom(), nNumerator, nDenominator ) );
2418 	}
2419 	else
2420 	{
2421 		ENTER4( rMapModeSource, rMapModeDest );
2422 
2423 		return Rectangle( fn5( rRectSource.Left() + aMapResSource.mnMapOfsX,
2424 							   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2425 							   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2426 						  aMapResDest.mnMapOfsX,
2427 						  fn5( rRectSource.Top() + aMapResSource.mnMapOfsY,
2428 							   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2429 							   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2430 						  aMapResDest.mnMapOfsY,
2431 						  fn5( rRectSource.Right() + aMapResSource.mnMapOfsX,
2432 							   aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2433 							   aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2434 						  aMapResDest.mnMapOfsX,
2435 						  fn5( rRectSource.Bottom() + aMapResSource.mnMapOfsY,
2436 							   aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2437 							   aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2438 						  aMapResDest.mnMapOfsY );
2439 	}
2440 }
2441 
2442 // -----------------------------------------------------------------------
2443 
LogicToLogic(long nLongSource,MapUnit eUnitSource,MapUnit eUnitDest)2444 long OutputDevice::LogicToLogic( long nLongSource,
2445 								 MapUnit eUnitSource, MapUnit eUnitDest )
2446 {
2447 	if ( eUnitSource == eUnitDest )
2448 		return nLongSource;
2449 
2450 	ENTER2( eUnitSource, eUnitDest );
2451 	ENTER3( eUnitSource, eUnitDest );
2452 
2453 	return fn3( nLongSource, nNumerator, nDenominator );
2454 }
2455 
2456 // -----------------------------------------------------------------------
2457 
SetPixelOffset(const Size & rOffset)2458 void OutputDevice::SetPixelOffset( const Size& rOffset )
2459 {
2460     mnOutOffOrigX  = rOffset.Width();
2461     mnOutOffOrigY  = rOffset.Height();
2462 
2463 	mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
2464                                        maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
2465                                        maThresRes.mnThresPixToLogX );
2466 	mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
2467                                        maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
2468                                        maThresRes.mnThresPixToLogY );
2469 
2470     if( mpAlphaVDev )
2471         mpAlphaVDev->SetPixelOffset( rOffset );
2472 }
2473 
2474 // -----------------------------------------------------------------------
2475 
GetPixelOffset() const2476 Size OutputDevice::GetPixelOffset() const
2477 {
2478     return Size(mnOutOffOrigX, mnOutOffOrigY);
2479 }
2480 
2481 // -----------------------------------------------------------------------
2482 
ImplLogicUnitToPixelX(long nX,MapUnit eUnit)2483 long Window::ImplLogicUnitToPixelX( long nX, MapUnit eUnit )
2484 {
2485 	if ( eUnit != MAP_PIXEL )
2486 	{
2487 		ImplFrameData* pFrameData = mpWindowImpl->mpFrameData;
2488 
2489 		// Map-Einheit verschieden, dann neu berechnen
2490 		if ( pFrameData->meMapUnit != eUnit )
2491 		{
2492 			pFrameData->meMapUnit = eUnit;
2493 			ImplCalcMapResolution( MapMode( eUnit ), mnDPIX, mnDPIY,
2494 								   pFrameData->maMapUnitRes );
2495 		}
2496 
2497 		// Es wird kein BigInt gebraucht, da diese Funktion nur zur Umrechnung
2498 		// von Fensterposition benutzt wird
2499 		nX	= nX * mnDPIX * pFrameData->maMapUnitRes.mnMapScNumX;
2500 		nX += nX >= 0 ?  (pFrameData->maMapUnitRes.mnMapScDenomX/2) :
2501 						-((pFrameData->maMapUnitRes.mnMapScDenomX-1)/2);
2502 		nX /= pFrameData->maMapUnitRes.mnMapScDenomX;
2503 	}
2504 
2505 	return nX;
2506 }
2507 
2508 // -----------------------------------------------------------------------
2509 
ImplLogicUnitToPixelY(long nY,MapUnit eUnit)2510 long Window::ImplLogicUnitToPixelY( long nY, MapUnit eUnit )
2511 {
2512 	if ( eUnit != MAP_PIXEL )
2513 	{
2514 		ImplFrameData* pFrameData = mpWindowImpl->mpFrameData;
2515 
2516 		// Map-Einheit verschieden, dann neu berechnen
2517 		if ( pFrameData->meMapUnit != eUnit )
2518 		{
2519 			pFrameData->meMapUnit = eUnit;
2520 			ImplCalcMapResolution( MapMode( eUnit ), mnDPIX, mnDPIY,
2521 								   pFrameData->maMapUnitRes );
2522 		}
2523 
2524 		// Es wird kein BigInt gebraucht, da diese Funktion nur zur Umrechnung
2525 		// von Fensterposition benutzt wird
2526 		nY	= nY * mnDPIY * pFrameData->maMapUnitRes.mnMapScNumY;
2527 		nY += nY >= 0 ?  (pFrameData->maMapUnitRes.mnMapScDenomY/2) :
2528 						-((pFrameData->maMapUnitRes.mnMapScDenomY-1)/2);
2529 		nY /= pFrameData->maMapUnitRes.mnMapScDenomY;
2530 	}
2531 
2532 	return nY;
2533 }
2534