Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sal/config.h>
21 :
22 : #include <cstdlib>
23 : #include <limits.h>
24 :
25 : #include <o3tl/numeric.hxx>
26 : #include <tools/bigint.hxx>
27 :
28 : #include <vcl/virdev.hxx>
29 : #include <vcl/wrkwin.hxx>
30 : #include <vcl/outdev.hxx>
31 : #include <vcl/cursor.hxx>
32 :
33 : #include <svdata.hxx>
34 : #include <window.h>
35 : #include <outdev.h>
36 :
37 : #include <basegfx/matrix/b2dhommatrix.hxx>
38 :
39 : static int const s_ImplArySize = MAP_PIXEL+1;
40 : static const long aImplNumeratorAry[s_ImplArySize] =
41 : { 1, 1, 5, 50, 1, 1, 1, 1, 1, 1, 1 };
42 : static const long aImplDenominatorAry[s_ImplArySize] =
43 : { 2540, 254, 127, 127, 1000, 100, 10, 1, 72, 1440, 1 };
44 :
45 : /*
46 : Reduces accuracy until it is a fraction (should become
47 : ctor fraction once); we could also do this with BigInts
48 : */
49 :
50 3612230 : static Fraction ImplMakeFraction( long nN1, long nN2, long nD1, long nD2 )
51 : {
52 3612230 : if( nD1 == 0 || nD2 == 0 ) //under these bad circumstances the following while loop will be endless
53 : {
54 : DBG_ASSERT(false,"Invalid parameter for ImplMakeFraction");
55 0 : return Fraction( 1, 1 );
56 : }
57 :
58 3612230 : long i = 1;
59 :
60 3612230 : if ( nN1 < 0 ) { i = -i; nN1 = -nN1; }
61 3612230 : if ( nN2 < 0 ) { i = -i; nN2 = -nN2; }
62 3612230 : if ( nD1 < 0 ) { i = -i; nD1 = -nD1; }
63 3612230 : if ( nD2 < 0 ) { i = -i; nD2 = -nD2; }
64 : // all positive; i sign
65 :
66 3612230 : Fraction aF = Fraction( i*nN1, nD1 ) * Fraction( nN2, nD2 );
67 :
68 7224460 : while ( !aF.IsValid() ) {
69 0 : if ( nN1 > nN2 )
70 0 : nN1 = (nN1 + 1) / 2;
71 : else
72 0 : nN2 = (nN2 + 1) / 2;
73 0 : if ( nD1 > nD2 )
74 0 : nD1 = (nD1 + 1) / 2;
75 : else
76 0 : nD2 = (nD2 + 1) / 2;
77 :
78 0 : aF = Fraction( i*nN1, nD1 ) * Fraction( nN2, nD2 );
79 : }
80 :
81 3612230 : aF.ReduceInaccurate(32);
82 3612230 : return aF;
83 : }
84 :
85 : // Fraction.GetNumerator()
86 : // Fraction.GetDenominator() > 0
87 : // rOutRes.nPixPerInch? > 0
88 : // rMapRes.nMapScNum?
89 : // rMapRes.nMapScDenom? > 0
90 :
91 1788559 : static void ImplCalcBigIntThreshold( long nDPIX, long nDPIY,
92 : const ImplMapRes& rMapRes,
93 : ImplThresholdRes& rThresRes )
94 : {
95 1788559 : if ( nDPIX && (LONG_MAX / nDPIX < std::abs( rMapRes.mnMapScNumX ) ) ) // #111139# avoid div by zero
96 : {
97 0 : rThresRes.mnThresLogToPixX = 0;
98 0 : rThresRes.mnThresPixToLogX = 0;
99 : }
100 : else
101 : {
102 : // calculate thresholds for BigInt arithmetic
103 1788559 : long nDenomHalfX = rMapRes.mnMapScDenomX / 2;
104 1788559 : sal_uLong nDenomX = rMapRes.mnMapScDenomX;
105 1788559 : long nProductX = nDPIX * rMapRes.mnMapScNumX;
106 :
107 1788559 : if ( !nProductX )
108 0 : rThresRes.mnThresLogToPixX = LONG_MAX;
109 : else
110 1788559 : rThresRes.mnThresLogToPixX = std::abs( (LONG_MAX - nDenomHalfX) / nProductX );
111 :
112 1788559 : if ( !nDenomX )
113 0 : rThresRes.mnThresPixToLogX = LONG_MAX;
114 1788559 : else if ( nProductX >= 0 )
115 1788559 : rThresRes.mnThresPixToLogX = (long)(((sal_uLong)LONG_MAX - (sal_uLong)( nProductX/2)) / nDenomX);
116 : else
117 0 : rThresRes.mnThresPixToLogX = (long)(((sal_uLong)LONG_MAX + (sal_uLong)(-nProductX/2)) / nDenomX);
118 : }
119 :
120 1788559 : if ( nDPIY && (LONG_MAX / nDPIY < std::abs( rMapRes.mnMapScNumY ) ) ) // #111139# avoid div by zero
121 : {
122 0 : rThresRes.mnThresLogToPixY = 0;
123 0 : rThresRes.mnThresPixToLogY = 0;
124 : }
125 : else
126 : {
127 : // calculate thresholds for BigInt arithmetic
128 1788559 : long nDenomHalfY = rMapRes.mnMapScDenomY / 2;
129 1788559 : sal_uLong nDenomY = rMapRes.mnMapScDenomY;
130 1788559 : long nProductY = nDPIY * rMapRes.mnMapScNumY;
131 :
132 1788559 : if ( !nProductY )
133 0 : rThresRes.mnThresLogToPixY = LONG_MAX;
134 : else
135 1788559 : rThresRes.mnThresLogToPixY = std::abs( (LONG_MAX - nDenomHalfY) / nProductY );
136 :
137 1788559 : if ( !nDenomY )
138 0 : rThresRes.mnThresPixToLogY = LONG_MAX;
139 1788559 : else if ( nProductY >= 0 )
140 1788559 : rThresRes.mnThresPixToLogY = (long)(((sal_uLong)LONG_MAX - (sal_uLong)( nProductY/2)) / nDenomY);
141 : else
142 0 : rThresRes.mnThresPixToLogY = (long)(((sal_uLong)LONG_MAX + (sal_uLong)(-nProductY/2)) / nDenomY);
143 : }
144 :
145 1788559 : rThresRes.mnThresLogToPixX /= 2;
146 1788559 : rThresRes.mnThresLogToPixY /= 2;
147 1788559 : rThresRes.mnThresPixToLogX /= 2;
148 1788559 : rThresRes.mnThresPixToLogY /= 2;
149 1788559 : }
150 :
151 1805083 : static void ImplCalcMapResolution( const MapMode& rMapMode,
152 : long nDPIX, long nDPIY, ImplMapRes& rMapRes )
153 : {
154 1805083 : rMapRes.mfScaleX = 1.0;
155 1805083 : rMapRes.mfScaleY = 1.0;
156 1805083 : switch ( rMapMode.GetMapUnit() )
157 : {
158 : case MAP_RELATIVE:
159 561 : break;
160 : case MAP_100TH_MM:
161 92770 : rMapRes.mnMapScNumX = 1;
162 92770 : rMapRes.mnMapScDenomX = 2540;
163 92770 : rMapRes.mnMapScNumY = 1;
164 92770 : rMapRes.mnMapScDenomY = 2540;
165 92770 : break;
166 : case MAP_10TH_MM:
167 46 : rMapRes.mnMapScNumX = 1;
168 46 : rMapRes.mnMapScDenomX = 254;
169 46 : rMapRes.mnMapScNumY = 1;
170 46 : rMapRes.mnMapScDenomY = 254;
171 46 : break;
172 : case MAP_MM:
173 43 : rMapRes.mnMapScNumX = 5; // 10
174 43 : rMapRes.mnMapScDenomX = 127; // 254
175 43 : rMapRes.mnMapScNumY = 5; // 10
176 43 : rMapRes.mnMapScDenomY = 127; // 254
177 43 : break;
178 : case MAP_CM:
179 44740 : rMapRes.mnMapScNumX = 50; // 100
180 44740 : rMapRes.mnMapScDenomX = 127; // 254
181 44740 : rMapRes.mnMapScNumY = 50; // 100
182 44740 : rMapRes.mnMapScDenomY = 127; // 254
183 44740 : break;
184 : case MAP_1000TH_INCH:
185 1412509 : rMapRes.mnMapScNumX = 1;
186 1412509 : rMapRes.mnMapScDenomX = 1000;
187 1412509 : rMapRes.mnMapScNumY = 1;
188 1412509 : rMapRes.mnMapScDenomY = 1000;
189 1412509 : break;
190 : case MAP_100TH_INCH:
191 1 : rMapRes.mnMapScNumX = 1;
192 1 : rMapRes.mnMapScDenomX = 100;
193 1 : rMapRes.mnMapScNumY = 1;
194 1 : rMapRes.mnMapScDenomY = 100;
195 1 : break;
196 : case MAP_10TH_INCH:
197 1 : rMapRes.mnMapScNumX = 1;
198 1 : rMapRes.mnMapScDenomX = 10;
199 1 : rMapRes.mnMapScNumY = 1;
200 1 : rMapRes.mnMapScDenomY = 10;
201 1 : break;
202 : case MAP_INCH:
203 5350 : rMapRes.mnMapScNumX = 1;
204 5350 : rMapRes.mnMapScDenomX = 1;
205 5350 : rMapRes.mnMapScNumY = 1;
206 5350 : rMapRes.mnMapScDenomY = 1;
207 5350 : break;
208 : case MAP_POINT:
209 427 : rMapRes.mnMapScNumX = 1;
210 427 : rMapRes.mnMapScDenomX = 72;
211 427 : rMapRes.mnMapScNumY = 1;
212 427 : rMapRes.mnMapScDenomY = 72;
213 427 : break;
214 : case MAP_TWIP:
215 222029 : rMapRes.mnMapScNumX = 1;
216 222029 : rMapRes.mnMapScDenomX = 1440;
217 222029 : rMapRes.mnMapScNumY = 1;
218 222029 : rMapRes.mnMapScDenomY = 1440;
219 222029 : break;
220 : case MAP_PIXEL:
221 14439 : rMapRes.mnMapScNumX = 1;
222 14439 : rMapRes.mnMapScDenomX = nDPIX;
223 14439 : rMapRes.mnMapScNumY = 1;
224 14439 : rMapRes.mnMapScDenomY = nDPIY;
225 14439 : break;
226 : case MAP_SYSFONT:
227 : case MAP_APPFONT:
228 : {
229 12167 : ImplSVData* pSVData = ImplGetSVData();
230 12167 : if ( !pSVData->maGDIData.mnAppFontX )
231 : {
232 0 : if( pSVData->maWinData.mpFirstFrame )
233 0 : vcl::Window::ImplInitAppFontData( pSVData->maWinData.mpFirstFrame );
234 : else
235 : {
236 0 : ScopedVclPtrInstance<WorkWindow> pWin( nullptr, 0 );
237 0 : vcl::Window::ImplInitAppFontData( pWin );
238 : }
239 : }
240 12167 : rMapRes.mnMapScNumX = pSVData->maGDIData.mnAppFontX;
241 12167 : rMapRes.mnMapScDenomX = nDPIX * 40;
242 12167 : rMapRes.mnMapScNumY = pSVData->maGDIData.mnAppFontY;
243 12167 : rMapRes.mnMapScDenomY = nDPIY * 80;
244 : }
245 12167 : break;
246 : default:
247 : OSL_FAIL( "unhandled MapUnit" );
248 0 : break;
249 : }
250 :
251 1805083 : Fraction aScaleX = rMapMode.GetScaleX();
252 3610166 : Fraction aScaleY = rMapMode.GetScaleY();
253 :
254 : // set offset according to MapMode
255 1805083 : Point aOrigin = rMapMode.GetOrigin();
256 1805083 : if ( rMapMode.GetMapUnit() != MAP_RELATIVE )
257 : {
258 1804522 : rMapRes.mnMapOfsX = aOrigin.X();
259 1804522 : rMapRes.mnMapOfsY = aOrigin.Y();
260 1804522 : rMapRes.mfOffsetX = aOrigin.X();
261 1804522 : rMapRes.mfOffsetY = aOrigin.Y();
262 : }
263 : else
264 : {
265 561 : if (!aScaleX.GetNumerator() || !aScaleY.GetNumerator())
266 0 : throw o3tl::divide_by_zero();
267 :
268 561 : rMapRes.mfOffsetX *= aScaleX.GetDenominator();
269 561 : rMapRes.mfOffsetX /= aScaleX.GetNumerator();
270 561 : rMapRes.mfOffsetX += aOrigin.X();
271 561 : rMapRes.mfOffsetY *= aScaleY.GetDenominator();
272 561 : rMapRes.mfOffsetY /= aScaleY.GetNumerator();
273 561 : rMapRes.mfOffsetY += aOrigin.Y();
274 :
275 561 : BigInt aX( rMapRes.mnMapOfsX );
276 561 : aX *= BigInt( aScaleX.GetDenominator() );
277 561 : if ( rMapRes.mnMapOfsX >= 0 )
278 : {
279 545 : if ( aScaleX.GetNumerator() >= 0 )
280 545 : aX += BigInt( aScaleX.GetNumerator()/2 );
281 : else
282 0 : aX -= BigInt( (aScaleX.GetNumerator()+1)/2 );
283 : }
284 : else
285 : {
286 16 : if ( aScaleX.GetNumerator() >= 0 )
287 16 : aX -= BigInt( (aScaleX.GetNumerator()-1)/2 );
288 : else
289 0 : aX += BigInt( aScaleX.GetNumerator()/2 );
290 : }
291 561 : aX /= BigInt( aScaleX.GetNumerator() );
292 561 : rMapRes.mnMapOfsX = (long)aX + aOrigin.X();
293 561 : BigInt aY( rMapRes.mnMapOfsY );
294 561 : aY *= BigInt( aScaleY.GetDenominator() );
295 561 : if( rMapRes.mnMapOfsY >= 0 )
296 : {
297 545 : if ( aScaleY.GetNumerator() >= 0 )
298 545 : aY += BigInt( aScaleY.GetNumerator()/2 );
299 : else
300 0 : aY -= BigInt( (aScaleY.GetNumerator()+1)/2 );
301 : }
302 : else
303 : {
304 16 : if ( aScaleY.GetNumerator() >= 0 )
305 16 : aY -= BigInt( (aScaleY.GetNumerator()-1)/2 );
306 : else
307 0 : aY += BigInt( aScaleY.GetNumerator()/2 );
308 : }
309 561 : aY /= BigInt( aScaleY.GetNumerator() );
310 561 : rMapRes.mnMapOfsY = (long)aY + aOrigin.Y();
311 : }
312 :
313 1805083 : rMapRes.mfScaleX *= (double)rMapRes.mnMapScNumX * (double)aScaleX.GetNumerator() /
314 1805083 : ((double)rMapRes.mnMapScDenomX * (double)aScaleX.GetDenominator());
315 1805083 : rMapRes.mfScaleY *= (double)rMapRes.mnMapScNumY * (double)aScaleY.GetNumerator() /
316 1805083 : ((double)rMapRes.mnMapScDenomY * (double)aScaleY.GetDenominator());
317 :
318 : // calculate scaling factor according to MapMode
319 : // aTemp? = rMapRes.mnMapSc? * aScale?
320 : Fraction aTempX = ImplMakeFraction( rMapRes.mnMapScNumX,
321 : aScaleX.GetNumerator(),
322 : rMapRes.mnMapScDenomX,
323 3610166 : aScaleX.GetDenominator() );
324 : Fraction aTempY = ImplMakeFraction( rMapRes.mnMapScNumY,
325 : aScaleY.GetNumerator(),
326 : rMapRes.mnMapScDenomY,
327 3610166 : aScaleY.GetDenominator() );
328 1805083 : rMapRes.mnMapScNumX = aTempX.GetNumerator();
329 1805083 : rMapRes.mnMapScDenomX = aTempX.GetDenominator();
330 1805083 : rMapRes.mnMapScNumY = aTempY.GetNumerator();
331 3610166 : rMapRes.mnMapScDenomY = aTempY.GetDenominator();
332 1805083 : }
333 :
334 1788559 : inline void ImplCalcMapResolution( const MapMode& rMapMode,
335 : long nDPIX, long nDPIY,
336 : ImplMapRes& rMapRes,
337 : ImplThresholdRes& rThresRes )
338 : {
339 1788559 : ImplCalcMapResolution( rMapMode, nDPIX, nDPIY, rMapRes );
340 1788559 : ImplCalcBigIntThreshold( nDPIX, nDPIY, rMapRes, rThresRes );
341 1788559 : }
342 :
343 : // #i75163#
344 749919 : void OutputDevice::ImplInvalidateViewTransform()
345 : {
346 749919 : if(!mpOutDevData)
347 749919 : return;
348 :
349 749919 : if(mpOutDevData->mpViewTransform)
350 : {
351 45518 : delete mpOutDevData->mpViewTransform;
352 45518 : mpOutDevData->mpViewTransform = NULL;
353 : }
354 :
355 749919 : if(mpOutDevData->mpInverseViewTransform)
356 : {
357 23912 : delete mpOutDevData->mpInverseViewTransform;
358 23912 : mpOutDevData->mpInverseViewTransform = NULL;
359 : }
360 : }
361 :
362 13111561 : static long ImplLogicToPixel( long n, long nDPI, long nMapNum, long nMapDenom,
363 : long nThres )
364 : {
365 : // To "use" it...
366 : (void) nThres;
367 : #if (SAL_TYPES_SIZEOFLONG < 8)
368 : if( (+n < nThres) && (-n < nThres) )
369 : {
370 : n *= nMapNum * nDPI;
371 : if( nMapDenom != 1 )
372 : {
373 : n = (2 * n) / nMapDenom;
374 : if( n < 0 ) --n; else ++n;
375 : n /= 2;
376 : }
377 : }
378 : else
379 : #else
380 : assert(nMapNum >= 0);
381 : assert(nDPI > 0);
382 : assert(nMapNum == 0 || std::abs(n) < std::numeric_limits<long>::max() / nMapNum / nDPI); //detect overflows
383 : #endif
384 : {
385 13111561 : sal_Int64 n64 = n;
386 13111561 : n64 *= nMapNum;
387 13111561 : n64 *= nDPI;
388 13111561 : if( nMapDenom == 1 )
389 2058 : n = (long)n64;
390 : else
391 : {
392 13109503 : n = (long)(2 * n64 / nMapDenom);
393 13109503 : if( n < 0 ) --n; else ++n;
394 13109503 : n /= 2;
395 : }
396 : }
397 13111561 : return n;
398 : }
399 :
400 13308842 : static long ImplPixelToLogic( long n, long nDPI, long nMapNum, long nMapDenom,
401 : long nThres )
402 : {
403 : // To "use" it...
404 : (void) nThres;
405 13308842 : if (nMapNum == 0 || nDPI == 0)
406 : {
407 0 : return 0;
408 : }
409 : #if (SAL_TYPES_SIZEOFLONG < 8)
410 : if( (+n < nThres) && (-n < nThres) )
411 : n = (2 * n * nMapDenom) / (nDPI * nMapNum);
412 : else
413 : #endif
414 : {
415 13308842 : sal_Int64 n64 = n;
416 13308842 : n64 *= nMapDenom;
417 13308842 : long nDenom = nDPI * nMapNum;
418 13308842 : n = (long)(2 * n64 / nDenom);
419 : }
420 13308842 : if( n < 0 ) --n; else ++n;
421 13308842 : return (n / 2);
422 : }
423 :
424 564123 : long OutputDevice::ImplLogicXToDevicePixel( long nX ) const
425 : {
426 564123 : if ( !mbMap )
427 549758 : return nX+mnOutOffX;
428 :
429 : return ImplLogicToPixel( nX + maMapRes.mnMapOfsX, mnDPIX,
430 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
431 14365 : maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX;
432 : }
433 :
434 567092 : long OutputDevice::ImplLogicYToDevicePixel( long nY ) const
435 : {
436 567092 : if ( !mbMap )
437 556824 : return nY+mnOutOffY;
438 :
439 : return ImplLogicToPixel( nY + maMapRes.mnMapOfsY, mnDPIY,
440 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
441 10268 : maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY;
442 : }
443 :
444 687772 : long OutputDevice::ImplLogicWidthToDevicePixel( long nWidth ) const
445 : {
446 687772 : if ( !mbMap )
447 684529 : return nWidth;
448 :
449 : return ImplLogicToPixel( nWidth, mnDPIX,
450 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
451 3243 : maThresRes.mnThresLogToPixX );
452 : }
453 :
454 546733 : long OutputDevice::ImplLogicHeightToDevicePixel( long nHeight ) const
455 : {
456 546733 : if ( !mbMap )
457 544965 : return nHeight;
458 :
459 : return ImplLogicToPixel( nHeight, mnDPIY,
460 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
461 1768 : maThresRes.mnThresLogToPixY );
462 : }
463 :
464 894561 : float OutputDevice::ImplFloatLogicHeightToDevicePixel( float fLogicHeight) const
465 : {
466 894561 : if( !mbMap)
467 182589 : return fLogicHeight;
468 711972 : float fPixelHeight = (fLogicHeight * mnDPIY * maMapRes.mnMapScNumY) / maMapRes.mnMapScDenomY;
469 711972 : return fPixelHeight;
470 : }
471 :
472 3756433 : long OutputDevice::ImplDevicePixelToLogicWidth( long nWidth ) const
473 : {
474 3756433 : if ( !mbMap )
475 1140 : return nWidth;
476 :
477 : return ImplPixelToLogic( nWidth, mnDPIX,
478 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
479 3755293 : maThresRes.mnThresPixToLogX );
480 : }
481 :
482 4037217 : long OutputDevice::ImplDevicePixelToLogicHeight( long nHeight ) const
483 : {
484 4037217 : if ( !mbMap )
485 216888 : return nHeight;
486 :
487 : return ImplPixelToLogic( nHeight, mnDPIY,
488 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
489 3820329 : maThresRes.mnThresPixToLogY );
490 : }
491 :
492 4200904 : Point OutputDevice::ImplLogicToDevicePixel( const Point& rLogicPt ) const
493 : {
494 4200904 : if ( !mbMap )
495 3620472 : return Point( rLogicPt.X()+mnOutOffX, rLogicPt.Y()+mnOutOffY );
496 :
497 580432 : return Point( ImplLogicToPixel( rLogicPt.X() + maMapRes.mnMapOfsX, mnDPIX,
498 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
499 1160864 : maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
500 580432 : ImplLogicToPixel( rLogicPt.Y() + maMapRes.mnMapOfsY, mnDPIY,
501 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
502 1741296 : maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY );
503 : }
504 :
505 951167 : Size OutputDevice::ImplLogicToDevicePixel( const Size& rLogicSize ) const
506 : {
507 951167 : if ( !mbMap )
508 238895 : return rLogicSize;
509 :
510 : return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
511 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
512 : maThresRes.mnThresLogToPixX ),
513 : ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
514 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
515 712272 : maThresRes.mnThresLogToPixY ) );
516 : }
517 :
518 1974859 : Rectangle OutputDevice::ImplLogicToDevicePixel( const Rectangle& rLogicRect ) const
519 : {
520 1974859 : if ( rLogicRect.IsEmpty() )
521 29151 : return rLogicRect;
522 :
523 1945708 : if ( !mbMap )
524 : {
525 3723608 : return Rectangle( rLogicRect.Left()+mnOutOffX, rLogicRect.Top()+mnOutOffY,
526 5585412 : rLogicRect.Right()+mnOutOffX, rLogicRect.Bottom()+mnOutOffY );
527 : }
528 :
529 83904 : return Rectangle( ImplLogicToPixel( rLogicRect.Left()+maMapRes.mnMapOfsX, mnDPIX,
530 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
531 167808 : maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
532 83904 : ImplLogicToPixel( rLogicRect.Top()+maMapRes.mnMapOfsY, mnDPIY,
533 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
534 167808 : maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY,
535 83904 : ImplLogicToPixel( rLogicRect.Right()+maMapRes.mnMapOfsX, mnDPIX,
536 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
537 167808 : maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX,
538 83904 : ImplLogicToPixel( rLogicRect.Bottom()+maMapRes.mnMapOfsY, mnDPIY,
539 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
540 419520 : maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY );
541 : }
542 :
543 696965 : Polygon OutputDevice::ImplLogicToDevicePixel( const Polygon& rLogicPoly ) const
544 : {
545 696965 : if ( !mbMap && !mnOutOffX && !mnOutOffY )
546 251395 : return rLogicPoly;
547 :
548 : sal_uInt16 i;
549 445570 : sal_uInt16 nPoints = rLogicPoly.GetSize();
550 445570 : Polygon aPoly( rLogicPoly );
551 :
552 : // get pointer to Point-array (copy data)
553 445570 : const Point* pPointAry = aPoly.GetConstPointAry();
554 :
555 445570 : if ( mbMap )
556 : {
557 1804460 : for ( i = 0; i < nPoints; i++ )
558 : {
559 1530228 : const Point* pPt = &(pPointAry[i]);
560 1530228 : Point aPt;
561 3060456 : aPt.X() = ImplLogicToPixel( pPt->X()+maMapRes.mnMapOfsX, mnDPIX,
562 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
563 3060456 : maThresRes.mnThresLogToPixX )+mnOutOffX+mnOutOffOrigX;
564 3060456 : aPt.Y() = ImplLogicToPixel( pPt->Y()+maMapRes.mnMapOfsY, mnDPIY,
565 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
566 3060456 : maThresRes.mnThresLogToPixY )+mnOutOffY+mnOutOffOrigY;
567 1530228 : aPoly[i] = aPt;
568 : }
569 : }
570 : else
571 : {
572 1016608 : for ( i = 0; i < nPoints; i++ )
573 : {
574 845270 : Point aPt = pPointAry[i];
575 845270 : aPt.X() += mnOutOffX;
576 845270 : aPt.Y() += mnOutOffY;
577 845270 : aPoly[i] = aPt;
578 : }
579 : }
580 :
581 445570 : return aPoly;
582 : }
583 :
584 208239 : tools::PolyPolygon OutputDevice::ImplLogicToDevicePixel( const tools::PolyPolygon& rLogicPolyPoly ) const
585 : {
586 208239 : if ( !mbMap && !mnOutOffX && !mnOutOffY )
587 5407 : return rLogicPolyPoly;
588 :
589 202832 : tools::PolyPolygon aPolyPoly( rLogicPolyPoly );
590 202832 : sal_uInt16 nPoly = aPolyPoly.Count();
591 406003 : for( sal_uInt16 i = 0; i < nPoly; i++ )
592 : {
593 203171 : Polygon& rPoly = aPolyPoly[i];
594 203171 : rPoly = ImplLogicToDevicePixel( rPoly );
595 : }
596 202832 : return aPolyPoly;
597 : }
598 :
599 139763 : LineInfo OutputDevice::ImplLogicToDevicePixel( const LineInfo& rLineInfo ) const
600 : {
601 139763 : LineInfo aInfo( rLineInfo );
602 :
603 139763 : if( aInfo.GetStyle() == LINE_DASH )
604 : {
605 3 : if( aInfo.GetDotCount() && aInfo.GetDotLen() )
606 3 : aInfo.SetDotLen( std::max( ImplLogicWidthToDevicePixel( aInfo.GetDotLen() ), 1L ) );
607 : else
608 0 : aInfo.SetDotCount( 0 );
609 :
610 3 : if( aInfo.GetDashCount() && aInfo.GetDashLen() )
611 0 : aInfo.SetDashLen( std::max( ImplLogicWidthToDevicePixel( aInfo.GetDashLen() ), 1L ) );
612 : else
613 3 : aInfo.SetDashCount( 0 );
614 :
615 3 : aInfo.SetDistance( ImplLogicWidthToDevicePixel( aInfo.GetDistance() ) );
616 :
617 3 : if( ( !aInfo.GetDashCount() && !aInfo.GetDotCount() ) || !aInfo.GetDistance() )
618 0 : aInfo.SetStyle( LINE_SOLID );
619 : }
620 :
621 139763 : aInfo.SetWidth( ImplLogicWidthToDevicePixel( aInfo.GetWidth() ) );
622 :
623 139763 : return aInfo;
624 : }
625 :
626 146296 : Rectangle OutputDevice::ImplDevicePixelToLogic( const Rectangle& rPixelRect ) const
627 : {
628 146296 : if ( rPixelRect.IsEmpty() )
629 0 : return rPixelRect;
630 :
631 146296 : if ( !mbMap )
632 : {
633 269914 : return Rectangle( rPixelRect.Left()-mnOutOffX, rPixelRect.Top()-mnOutOffY,
634 404871 : rPixelRect.Right()-mnOutOffX, rPixelRect.Bottom()-mnOutOffY );
635 : }
636 :
637 11339 : return Rectangle( ImplPixelToLogic( rPixelRect.Left()-mnOutOffX-mnOutOffOrigX, mnDPIX,
638 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
639 22678 : maThresRes.mnThresPixToLogX )-maMapRes.mnMapOfsX,
640 11339 : ImplPixelToLogic( rPixelRect.Top()-mnOutOffY-mnOutOffOrigY, mnDPIY,
641 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
642 22678 : maThresRes.mnThresPixToLogY )-maMapRes.mnMapOfsY,
643 11339 : ImplPixelToLogic( rPixelRect.Right()-mnOutOffX-mnOutOffOrigX, mnDPIX,
644 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
645 22678 : maThresRes.mnThresPixToLogX )-maMapRes.mnMapOfsX,
646 11339 : ImplPixelToLogic( rPixelRect.Bottom()-mnOutOffY-mnOutOffOrigY, mnDPIY,
647 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
648 56695 : maThresRes.mnThresPixToLogY )-maMapRes.mnMapOfsY );
649 : }
650 :
651 396005 : vcl::Region OutputDevice::ImplPixelToDevicePixel( const vcl::Region& rRegion ) const
652 : {
653 396005 : if ( !mnOutOffX && !mnOutOffY )
654 49357 : return rRegion;
655 :
656 346648 : vcl::Region aRegion( rRegion );
657 346648 : aRegion.Move( mnOutOffX+mnOutOffOrigX, mnOutOffY+mnOutOffOrigY );
658 346648 : return aRegion;
659 : }
660 :
661 1171179 : void OutputDevice::EnableMapMode( bool bEnable )
662 : {
663 1171179 : mbMap = bEnable;
664 :
665 1171179 : if( mpAlphaVDev )
666 10296 : mpAlphaVDev->EnableMapMode( bEnable );
667 1171179 : }
668 :
669 97717 : void OutputDevice::SetMapMode()
670 : {
671 :
672 97717 : if ( mpMetaFile )
673 0 : mpMetaFile->AddAction( new MetaMapModeAction( MapMode() ) );
674 :
675 97717 : if ( mbMap || !maMapMode.IsDefault() )
676 : {
677 93726 : mbMap = false;
678 93726 : maMapMode = MapMode();
679 :
680 : // create new objects (clip region are not re-scaled)
681 93726 : mbNewFont = true;
682 93726 : mbInitFont = true;
683 93726 : if ( GetOutDevType() == OUTDEV_WINDOW )
684 : {
685 43385 : if ( static_cast<vcl::Window*>(this)->mpWindowImpl->mpCursor )
686 43293 : static_cast<vcl::Window*>(this)->mpWindowImpl->mpCursor->ImplNew();
687 : }
688 :
689 : // #106426# Adapt logical offset when changing mapmode
690 93726 : mnOutOffLogicX = mnOutOffOrigX; // no mapping -> equal offsets
691 93726 : mnOutOffLogicY = mnOutOffOrigY;
692 :
693 : // #i75163#
694 93726 : ImplInvalidateViewTransform();
695 : }
696 :
697 97717 : if( mpAlphaVDev )
698 0 : mpAlphaVDev->SetMapMode();
699 97717 : }
700 :
701 422487 : void OutputDevice::SetMapMode( const MapMode& rNewMapMode )
702 : {
703 :
704 422487 : bool bRelMap = (rNewMapMode.GetMapUnit() == MAP_RELATIVE);
705 :
706 422487 : if ( mpMetaFile )
707 : {
708 863 : mpMetaFile->AddAction( new MetaMapModeAction( rNewMapMode ) );
709 : #ifdef DBG_UTIL
710 : if ( GetOutDevType() != OUTDEV_PRINTER )
711 : DBG_ASSERTWARNING( bRelMap, "Please record only relative MapModes!" );
712 : #endif
713 : }
714 :
715 : // do nothing if MapMode was not changed
716 422487 : if ( maMapMode == rNewMapMode )
717 185647 : return;
718 :
719 236840 : if( mpAlphaVDev )
720 874 : mpAlphaVDev->SetMapMode( rNewMapMode );
721 :
722 : // if default MapMode calculate nothing
723 236840 : bool bOldMap = mbMap;
724 236840 : mbMap = !rNewMapMode.IsDefault();
725 236840 : if ( mbMap )
726 : {
727 : // if only the origin is converted, do not scale new
728 452282 : if ( (rNewMapMode.GetMapUnit() == maMapMode.GetMapUnit()) &&
729 33956 : (rNewMapMode.GetScaleX() == maMapMode.GetScaleX()) &&
730 248613 : (rNewMapMode.GetScaleY() == maMapMode.GetScaleY()) &&
731 15723 : (bOldMap == mbMap) )
732 : {
733 : // set offset
734 2624 : Point aOrigin = rNewMapMode.GetOrigin();
735 2624 : maMapRes.mnMapOfsX = aOrigin.X();
736 2624 : maMapRes.mnMapOfsY = aOrigin.Y();
737 2624 : maMapRes.mfOffsetX = aOrigin.X();
738 2624 : maMapRes.mfOffsetY = aOrigin.Y();
739 2624 : maMapMode = rNewMapMode;
740 :
741 : // #i75163#
742 2624 : ImplInvalidateViewTransform();
743 :
744 2624 : return;
745 : }
746 214448 : if ( !bOldMap && bRelMap )
747 : {
748 40 : maMapRes.mnMapScNumX = 1;
749 40 : maMapRes.mnMapScNumY = 1;
750 40 : maMapRes.mnMapScDenomX = mnDPIX;
751 40 : maMapRes.mnMapScDenomY = mnDPIY;
752 40 : maMapRes.mnMapOfsX = 0;
753 40 : maMapRes.mnMapOfsY = 0;
754 40 : maMapRes.mfOffsetX = 0.0;
755 40 : maMapRes.mfOffsetY = 0.0;
756 40 : maMapRes.mfScaleX = (double)1/(double)mnDPIX;
757 40 : maMapRes.mfScaleY = (double)1/(double)mnDPIY;
758 : }
759 :
760 : // calculate new MapMode-resolution
761 214448 : ImplCalcMapResolution( rNewMapMode, mnDPIX, mnDPIY, maMapRes, maThresRes );
762 : }
763 :
764 : // set new MapMode
765 234216 : if ( bRelMap )
766 : {
767 561 : Point aOrigin( maMapRes.mnMapOfsX, maMapRes.mnMapOfsY );
768 : // aScale? = maMapMode.GetScale?() * rNewMapMode.GetScale?()
769 561 : Fraction aScaleX = ImplMakeFraction( maMapMode.GetScaleX().GetNumerator(),
770 561 : rNewMapMode.GetScaleX().GetNumerator(),
771 561 : maMapMode.GetScaleX().GetDenominator(),
772 2244 : rNewMapMode.GetScaleX().GetDenominator() );
773 561 : Fraction aScaleY = ImplMakeFraction( maMapMode.GetScaleY().GetNumerator(),
774 561 : rNewMapMode.GetScaleY().GetNumerator(),
775 561 : maMapMode.GetScaleY().GetDenominator(),
776 2805 : rNewMapMode.GetScaleY().GetDenominator() );
777 561 : maMapMode.SetOrigin( aOrigin );
778 561 : maMapMode.SetScaleX( aScaleX );
779 1122 : maMapMode.SetScaleY( aScaleY );
780 : }
781 : else
782 233655 : maMapMode = rNewMapMode;
783 :
784 : // create new objects (clip region are not re-scaled)
785 234216 : mbNewFont = true;
786 234216 : mbInitFont = true;
787 234216 : if ( GetOutDevType() == OUTDEV_WINDOW )
788 : {
789 51423 : if ( static_cast<vcl::Window*>(this)->mpWindowImpl->mpCursor )
790 44255 : static_cast<vcl::Window*>(this)->mpWindowImpl->mpCursor->ImplNew();
791 : }
792 :
793 : // #106426# Adapt logical offset when changing mapmode
794 : mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
795 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
796 234216 : maThresRes.mnThresPixToLogX );
797 : mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
798 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
799 234216 : maThresRes.mnThresPixToLogY );
800 :
801 : // #i75163#
802 234216 : ImplInvalidateViewTransform();
803 : }
804 :
805 5063 : void OutputDevice::SetRelativeMapMode( const MapMode& rNewMapMode )
806 : {
807 : // do nothing if MapMode did not change
808 5063 : if ( maMapMode == rNewMapMode )
809 9703 : return;
810 :
811 423 : MapUnit eOld = maMapMode.GetMapUnit();
812 423 : MapUnit eNew = rNewMapMode.GetMapUnit();
813 :
814 : // a?F = rNewMapMode.GetScale?() / maMapMode.GetScale?()
815 423 : Fraction aXF = ImplMakeFraction( rNewMapMode.GetScaleX().GetNumerator(),
816 423 : maMapMode.GetScaleX().GetDenominator(),
817 423 : rNewMapMode.GetScaleX().GetDenominator(),
818 1692 : maMapMode.GetScaleX().GetNumerator() );
819 423 : Fraction aYF = ImplMakeFraction( rNewMapMode.GetScaleY().GetNumerator(),
820 423 : maMapMode.GetScaleY().GetDenominator(),
821 423 : rNewMapMode.GetScaleY().GetDenominator(),
822 2115 : maMapMode.GetScaleY().GetNumerator() );
823 :
824 423 : Point aPt( LogicToLogic( Point(), NULL, &rNewMapMode ) );
825 423 : if ( eNew != eOld )
826 : {
827 48 : if ( eOld > MAP_PIXEL )
828 : {
829 : SAL_WARN( "vcl.gdi", "Not implemented MapUnit" );
830 : }
831 48 : else if ( eNew > MAP_PIXEL )
832 : {
833 : SAL_WARN( "vcl.gdi", "Not implemented MapUnit" );
834 : }
835 : else
836 : {
837 96 : Fraction aF( aImplNumeratorAry[eNew] * aImplDenominatorAry[eOld],
838 144 : aImplNumeratorAry[eOld] * aImplDenominatorAry[eNew] );
839 :
840 : // a?F = a?F * aF
841 96 : aXF = ImplMakeFraction( aXF.GetNumerator(), aF.GetNumerator(),
842 48 : aXF.GetDenominator(), aF.GetDenominator() );
843 96 : aYF = ImplMakeFraction( aYF.GetNumerator(), aF.GetNumerator(),
844 48 : aYF.GetDenominator(), aF.GetDenominator() );
845 48 : if ( eOld == MAP_PIXEL )
846 : {
847 0 : aXF *= Fraction( mnDPIX, 1 );
848 0 : aYF *= Fraction( mnDPIY, 1 );
849 : }
850 48 : else if ( eNew == MAP_PIXEL )
851 : {
852 0 : aXF *= Fraction( 1, mnDPIX );
853 0 : aYF *= Fraction( 1, mnDPIY );
854 48 : }
855 : }
856 : }
857 :
858 846 : MapMode aNewMapMode( MAP_RELATIVE, Point( -aPt.X(), -aPt.Y() ), aXF, aYF );
859 423 : SetMapMode( aNewMapMode );
860 :
861 423 : if ( eNew != eOld )
862 48 : maMapMode = rNewMapMode;
863 :
864 : // #106426# Adapt logical offset when changing MapMode
865 : mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
866 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
867 423 : maThresRes.mnThresPixToLogX );
868 : mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
869 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
870 423 : maThresRes.mnThresPixToLogY );
871 :
872 423 : if( mpAlphaVDev )
873 423 : mpAlphaVDev->SetRelativeMapMode( rNewMapMode );
874 : }
875 :
876 : // #i75163#
877 184421 : basegfx::B2DHomMatrix OutputDevice::GetViewTransformation() const
878 : {
879 184421 : if(mbMap)
880 : {
881 174441 : if(!mpOutDevData->mpViewTransform)
882 : {
883 45539 : mpOutDevData->mpViewTransform = new basegfx::B2DHomMatrix;
884 :
885 45539 : const double fScaleFactorX((double)mnDPIX * (double)maMapRes.mnMapScNumX / (double)maMapRes.mnMapScDenomX);
886 45539 : const double fScaleFactorY((double)mnDPIY * (double)maMapRes.mnMapScNumY / (double)maMapRes.mnMapScDenomY);
887 45539 : const double fZeroPointX(((double)maMapRes.mnMapOfsX * fScaleFactorX) + (double)mnOutOffOrigX);
888 45539 : const double fZeroPointY(((double)maMapRes.mnMapOfsY * fScaleFactorY) + (double)mnOutOffOrigY);
889 :
890 45539 : mpOutDevData->mpViewTransform->set(0, 0, fScaleFactorX);
891 45539 : mpOutDevData->mpViewTransform->set(1, 1, fScaleFactorY);
892 45539 : mpOutDevData->mpViewTransform->set(0, 2, fZeroPointX);
893 45539 : mpOutDevData->mpViewTransform->set(1, 2, fZeroPointY);
894 : }
895 :
896 174441 : return *mpOutDevData->mpViewTransform;
897 : }
898 : else
899 : {
900 9980 : return basegfx::B2DHomMatrix();
901 : }
902 : }
903 :
904 : // #i75163#
905 47217 : basegfx::B2DHomMatrix OutputDevice::GetInverseViewTransformation() const
906 : {
907 47217 : if(mbMap)
908 : {
909 47215 : if(!mpOutDevData->mpInverseViewTransform)
910 : {
911 23933 : GetViewTransformation();
912 23933 : mpOutDevData->mpInverseViewTransform = new basegfx::B2DHomMatrix(*mpOutDevData->mpViewTransform);
913 23933 : mpOutDevData->mpInverseViewTransform->invert();
914 : }
915 :
916 47215 : return *mpOutDevData->mpInverseViewTransform;
917 : }
918 : else
919 : {
920 2 : return basegfx::B2DHomMatrix();
921 : }
922 : }
923 :
924 : // #i75163#
925 0 : basegfx::B2DHomMatrix OutputDevice::GetViewTransformation( const MapMode& rMapMode ) const
926 : {
927 : // #i82615#
928 : ImplMapRes aMapRes;
929 : ImplThresholdRes aThresRes;
930 0 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
931 :
932 0 : basegfx::B2DHomMatrix aTransform;
933 :
934 0 : const double fScaleFactorX((double)mnDPIX * (double)aMapRes.mnMapScNumX / (double)aMapRes.mnMapScDenomX);
935 0 : const double fScaleFactorY((double)mnDPIY * (double)aMapRes.mnMapScNumY / (double)aMapRes.mnMapScDenomY);
936 0 : const double fZeroPointX(((double)aMapRes.mnMapOfsX * fScaleFactorX) + (double)mnOutOffOrigX);
937 0 : const double fZeroPointY(((double)aMapRes.mnMapOfsY * fScaleFactorY) + (double)mnOutOffOrigY);
938 :
939 0 : aTransform.set(0, 0, fScaleFactorX);
940 0 : aTransform.set(1, 1, fScaleFactorY);
941 0 : aTransform.set(0, 2, fZeroPointX);
942 0 : aTransform.set(1, 2, fZeroPointY);
943 :
944 0 : return aTransform;
945 : }
946 :
947 : // #i75163#
948 0 : basegfx::B2DHomMatrix OutputDevice::GetInverseViewTransformation( const MapMode& rMapMode ) const
949 : {
950 0 : basegfx::B2DHomMatrix aMatrix( GetViewTransformation( rMapMode ) );
951 0 : aMatrix.invert();
952 0 : return aMatrix;
953 : }
954 :
955 0 : basegfx::B2DHomMatrix OutputDevice::ImplGetDeviceTransformation() const
956 : {
957 0 : basegfx::B2DHomMatrix aTransformation = GetViewTransformation();
958 : // TODO: is it worth to cache the transformed result?
959 0 : if( mnOutOffX || mnOutOffY )
960 0 : aTransformation.translate( mnOutOffX, mnOutOffY );
961 0 : return aTransformation;
962 : }
963 :
964 322312 : Point OutputDevice::LogicToPixel( const Point& rLogicPt ) const
965 : {
966 :
967 322312 : if ( !mbMap )
968 126184 : return rLogicPt;
969 :
970 196128 : return Point( ImplLogicToPixel( rLogicPt.X() + maMapRes.mnMapOfsX, mnDPIX,
971 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
972 392256 : maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
973 196128 : ImplLogicToPixel( rLogicPt.Y() + maMapRes.mnMapOfsY, mnDPIY,
974 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
975 588384 : maThresRes.mnThresLogToPixY )+mnOutOffOrigY );
976 : }
977 :
978 342216 : Size OutputDevice::LogicToPixel( const Size& rLogicSize ) const
979 : {
980 :
981 342216 : if ( !mbMap )
982 116892 : return rLogicSize;
983 :
984 : return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
985 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
986 : maThresRes.mnThresLogToPixX ),
987 : ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
988 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
989 225324 : maThresRes.mnThresLogToPixY ) );
990 : }
991 :
992 851517 : Rectangle OutputDevice::LogicToPixel( const Rectangle& rLogicRect ) const
993 : {
994 :
995 851517 : if ( !mbMap || rLogicRect.IsEmpty() )
996 295949 : return rLogicRect;
997 :
998 555568 : return Rectangle( ImplLogicToPixel( rLogicRect.Left() + maMapRes.mnMapOfsX, mnDPIX,
999 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1000 1111136 : maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1001 555568 : ImplLogicToPixel( rLogicRect.Top() + maMapRes.mnMapOfsY, mnDPIY,
1002 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1003 1111136 : maThresRes.mnThresLogToPixY )+mnOutOffOrigY,
1004 555568 : ImplLogicToPixel( rLogicRect.Right() + maMapRes.mnMapOfsX, mnDPIX,
1005 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1006 1111136 : maThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1007 555568 : ImplLogicToPixel( rLogicRect.Bottom() + maMapRes.mnMapOfsY, mnDPIY,
1008 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1009 2777840 : maThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1010 : }
1011 :
1012 756 : Polygon OutputDevice::LogicToPixel( const Polygon& rLogicPoly ) const
1013 : {
1014 :
1015 756 : if ( !mbMap )
1016 0 : return rLogicPoly;
1017 :
1018 : sal_uInt16 i;
1019 756 : sal_uInt16 nPoints = rLogicPoly.GetSize();
1020 756 : Polygon aPoly( rLogicPoly );
1021 :
1022 : // get pointer to Point-array (copy data)
1023 756 : const Point* pPointAry = aPoly.GetConstPointAry();
1024 :
1025 9538 : for ( i = 0; i < nPoints; i++ )
1026 : {
1027 8782 : const Point* pPt = &(pPointAry[i]);
1028 8782 : Point aPt;
1029 17564 : aPt.X() = ImplLogicToPixel( pPt->X() + maMapRes.mnMapOfsX, mnDPIX,
1030 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1031 17564 : maThresRes.mnThresLogToPixX )+mnOutOffOrigX;
1032 17564 : aPt.Y() = ImplLogicToPixel( pPt->Y() + maMapRes.mnMapOfsY, mnDPIY,
1033 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1034 17564 : maThresRes.mnThresLogToPixY )+mnOutOffOrigY;
1035 8782 : aPoly[i] = aPt;
1036 : }
1037 :
1038 756 : return aPoly;
1039 : }
1040 :
1041 2407 : tools::PolyPolygon OutputDevice::LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly ) const
1042 : {
1043 :
1044 2407 : if ( !mbMap )
1045 1651 : return rLogicPolyPoly;
1046 :
1047 756 : tools::PolyPolygon aPolyPoly( rLogicPolyPoly );
1048 756 : sal_uInt16 nPoly = aPolyPoly.Count();
1049 1512 : for( sal_uInt16 i = 0; i < nPoly; i++ )
1050 : {
1051 756 : Polygon& rPoly = aPolyPoly[i];
1052 756 : rPoly = LogicToPixel( rPoly );
1053 : }
1054 756 : return aPolyPoly;
1055 : }
1056 :
1057 0 : basegfx::B2DPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolygon& rLogicPoly ) const
1058 : {
1059 0 : basegfx::B2DPolygon aTransformedPoly = rLogicPoly;
1060 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
1061 0 : aTransformedPoly.transform( rTransformationMatrix );
1062 0 : return aTransformedPoly;
1063 : }
1064 :
1065 85 : basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const
1066 : {
1067 85 : basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
1068 170 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
1069 85 : aTransformedPoly.transform( rTransformationMatrix );
1070 170 : return aTransformedPoly;
1071 : }
1072 :
1073 209703 : vcl::Region OutputDevice::LogicToPixel( const vcl::Region& rLogicRegion ) const
1074 : {
1075 :
1076 209703 : if(!mbMap || rLogicRegion.IsNull() || rLogicRegion.IsEmpty())
1077 : {
1078 132091 : return rLogicRegion;
1079 : }
1080 :
1081 77612 : vcl::Region aRegion;
1082 :
1083 77612 : if(rLogicRegion.getB2DPolyPolygon())
1084 : {
1085 85 : aRegion = vcl::Region(LogicToPixel(*rLogicRegion.getB2DPolyPolygon()));
1086 : }
1087 77527 : else if(rLogicRegion.getPolyPolygon())
1088 : {
1089 1 : aRegion = vcl::Region(LogicToPixel(*rLogicRegion.getPolyPolygon()));
1090 : }
1091 77526 : else if(rLogicRegion.getRegionBand())
1092 : {
1093 77526 : RectangleVector aRectangles;
1094 77526 : rLogicRegion.GetRegionRectangles(aRectangles);
1095 77526 : const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1096 :
1097 : // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1098 156958 : for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); ++aRectIter)
1099 : {
1100 79432 : aRegion.Union(LogicToPixel(*aRectIter));
1101 77526 : }
1102 : }
1103 :
1104 77612 : return aRegion;
1105 : }
1106 :
1107 11591 : Point OutputDevice::LogicToPixel( const Point& rLogicPt,
1108 : const MapMode& rMapMode ) const
1109 : {
1110 :
1111 11591 : if ( rMapMode.IsDefault() )
1112 20 : return rLogicPt;
1113 :
1114 : // convert MapMode resolution and convert
1115 : ImplMapRes aMapRes;
1116 : ImplThresholdRes aThresRes;
1117 11571 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1118 :
1119 11571 : return Point( ImplLogicToPixel( rLogicPt.X() + aMapRes.mnMapOfsX, mnDPIX,
1120 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1121 23142 : aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1122 11571 : ImplLogicToPixel( rLogicPt.Y() + aMapRes.mnMapOfsY, mnDPIY,
1123 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1124 34713 : aThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1125 : }
1126 :
1127 1504773 : Size OutputDevice::LogicToPixel( const Size& rLogicSize,
1128 : const MapMode& rMapMode ) const
1129 : {
1130 :
1131 1504773 : if ( rMapMode.IsDefault() )
1132 5 : return rLogicSize;
1133 :
1134 : // convert MapMode resolution and convert
1135 : ImplMapRes aMapRes;
1136 : ImplThresholdRes aThresRes;
1137 1504768 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1138 :
1139 : return Size( ImplLogicToPixel( rLogicSize.Width(), mnDPIX,
1140 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1141 : aThresRes.mnThresLogToPixX ),
1142 : ImplLogicToPixel( rLogicSize.Height(), mnDPIY,
1143 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1144 1504768 : aThresRes.mnThresLogToPixY ) );
1145 : }
1146 :
1147 3111 : Rectangle OutputDevice::LogicToPixel( const Rectangle& rLogicRect,
1148 : const MapMode& rMapMode ) const
1149 : {
1150 :
1151 3111 : if ( rMapMode.IsDefault() || rLogicRect.IsEmpty() )
1152 10 : return rLogicRect;
1153 :
1154 : // convert MapMode resolution and convert
1155 : ImplMapRes aMapRes;
1156 : ImplThresholdRes aThresRes;
1157 3101 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1158 :
1159 3101 : return Rectangle( ImplLogicToPixel( rLogicRect.Left() + aMapRes.mnMapOfsX, mnDPIX,
1160 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1161 6202 : aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1162 3101 : ImplLogicToPixel( rLogicRect.Top() + aMapRes.mnMapOfsY, mnDPIY,
1163 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1164 6202 : aThresRes.mnThresLogToPixY )+mnOutOffOrigY,
1165 3101 : ImplLogicToPixel( rLogicRect.Right() + aMapRes.mnMapOfsX, mnDPIX,
1166 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1167 6202 : aThresRes.mnThresLogToPixX )+mnOutOffOrigX,
1168 3101 : ImplLogicToPixel( rLogicRect.Bottom() + aMapRes.mnMapOfsY, mnDPIY,
1169 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1170 15505 : aThresRes.mnThresLogToPixY )+mnOutOffOrigY );
1171 : }
1172 :
1173 1 : Polygon OutputDevice::LogicToPixel( const Polygon& rLogicPoly,
1174 : const MapMode& rMapMode ) const
1175 : {
1176 :
1177 1 : if ( rMapMode.IsDefault() )
1178 0 : return rLogicPoly;
1179 :
1180 : // convert MapMode resolution and convert
1181 : ImplMapRes aMapRes;
1182 : ImplThresholdRes aThresRes;
1183 1 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1184 :
1185 : sal_uInt16 i;
1186 1 : sal_uInt16 nPoints = rLogicPoly.GetSize();
1187 1 : Polygon aPoly( rLogicPoly );
1188 :
1189 : // get pointer to Point-array (copy data)
1190 1 : const Point* pPointAry = aPoly.GetConstPointAry();
1191 :
1192 98 : for ( i = 0; i < nPoints; i++ )
1193 : {
1194 97 : const Point* pPt = &(pPointAry[i]);
1195 97 : Point aPt;
1196 194 : aPt.X() = ImplLogicToPixel( pPt->X() + aMapRes.mnMapOfsX, mnDPIX,
1197 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1198 194 : aThresRes.mnThresLogToPixX )+mnOutOffOrigX;
1199 194 : aPt.Y() = ImplLogicToPixel( pPt->Y() + aMapRes.mnMapOfsY, mnDPIY,
1200 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1201 194 : aThresRes.mnThresLogToPixY )+mnOutOffOrigY;
1202 97 : aPoly[i] = aPt;
1203 : }
1204 :
1205 1 : return aPoly;
1206 : }
1207 :
1208 0 : tools::PolyPolygon OutputDevice::LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly,
1209 : const MapMode& rMapMode ) const
1210 : {
1211 :
1212 0 : if ( rMapMode.IsDefault() )
1213 0 : return rLogicPolyPoly;
1214 :
1215 0 : tools::PolyPolygon aPolyPoly( rLogicPolyPoly );
1216 0 : sal_uInt16 nPoly = aPolyPoly.Count();
1217 0 : for( sal_uInt16 i = 0; i < nPoly; i++ )
1218 : {
1219 0 : Polygon& rPoly = aPolyPoly[i];
1220 0 : rPoly = LogicToPixel( rPoly, rMapMode );
1221 : }
1222 0 : return aPolyPoly;
1223 : }
1224 :
1225 0 : basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly,
1226 : const MapMode& rMapMode ) const
1227 : {
1228 0 : basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
1229 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
1230 0 : aTransformedPoly.transform( rTransformationMatrix );
1231 0 : return aTransformedPoly;
1232 : }
1233 :
1234 0 : basegfx::B2DPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolygon& rLogicPoly,
1235 : const MapMode& rMapMode ) const
1236 : {
1237 0 : basegfx::B2DPolygon aTransformedPoly = rLogicPoly;
1238 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
1239 0 : aTransformedPoly.transform( rTransformationMatrix );
1240 0 : return aTransformedPoly;
1241 : }
1242 :
1243 0 : vcl::Region OutputDevice::LogicToPixel( const vcl::Region& rLogicRegion, const MapMode& rMapMode ) const
1244 : {
1245 :
1246 0 : if(rMapMode.IsDefault() || rLogicRegion.IsNull() || rLogicRegion.IsEmpty())
1247 : {
1248 0 : return rLogicRegion;
1249 : }
1250 :
1251 0 : vcl::Region aRegion;
1252 :
1253 0 : if(rLogicRegion.getB2DPolyPolygon())
1254 : {
1255 0 : aRegion = vcl::Region(LogicToPixel(*rLogicRegion.getB2DPolyPolygon(), rMapMode));
1256 : }
1257 0 : else if(rLogicRegion.getPolyPolygon())
1258 : {
1259 0 : aRegion = vcl::Region(LogicToPixel(*rLogicRegion.getPolyPolygon(), rMapMode));
1260 : }
1261 0 : else if(rLogicRegion.getRegionBand())
1262 : {
1263 0 : RectangleVector aRectangles;
1264 0 : rLogicRegion.GetRegionRectangles(aRectangles);
1265 0 : const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1266 :
1267 : // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1268 0 : for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); ++aRectIter)
1269 : {
1270 0 : aRegion.Union(LogicToPixel(*aRectIter, rMapMode));
1271 0 : }
1272 : }
1273 :
1274 0 : return aRegion;
1275 : }
1276 :
1277 495050 : Point OutputDevice::PixelToLogic( const Point& rDevicePt ) const
1278 : {
1279 :
1280 495050 : if ( !mbMap )
1281 199931 : return rDevicePt;
1282 :
1283 : return Point( ImplPixelToLogic( rDevicePt.X(), mnDPIX,
1284 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1285 295119 : maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1286 : ImplPixelToLogic( rDevicePt.Y(), mnDPIY,
1287 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1288 590238 : maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY );
1289 : }
1290 :
1291 1476591 : Size OutputDevice::PixelToLogic( const Size& rDeviceSize ) const
1292 : {
1293 :
1294 1476591 : if ( !mbMap )
1295 539612 : return rDeviceSize;
1296 :
1297 : return Size( ImplPixelToLogic( rDeviceSize.Width(), mnDPIX,
1298 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1299 : maThresRes.mnThresPixToLogX ),
1300 : ImplPixelToLogic( rDeviceSize.Height(), mnDPIY,
1301 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1302 936979 : maThresRes.mnThresPixToLogY ) );
1303 : }
1304 :
1305 950453 : Rectangle OutputDevice::PixelToLogic( const Rectangle& rDeviceRect ) const
1306 : {
1307 :
1308 950453 : if ( !mbMap || rDeviceRect.IsEmpty() )
1309 293004 : return rDeviceRect;
1310 :
1311 : return Rectangle( ImplPixelToLogic( rDeviceRect.Left(), mnDPIX,
1312 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1313 657449 : maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1314 : ImplPixelToLogic( rDeviceRect.Top(), mnDPIY,
1315 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1316 657449 : maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY,
1317 : ImplPixelToLogic( rDeviceRect.Right(), mnDPIX,
1318 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1319 657449 : maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX,
1320 : ImplPixelToLogic( rDeviceRect.Bottom(), mnDPIY,
1321 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1322 2629796 : maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY );
1323 : }
1324 :
1325 0 : Polygon OutputDevice::PixelToLogic( const Polygon& rDevicePoly ) const
1326 : {
1327 :
1328 0 : if ( !mbMap )
1329 0 : return rDevicePoly;
1330 :
1331 : sal_uInt16 i;
1332 0 : sal_uInt16 nPoints = rDevicePoly.GetSize();
1333 0 : Polygon aPoly( rDevicePoly );
1334 :
1335 : // get pointer to Point-array (copy data)
1336 0 : const Point* pPointAry = aPoly.GetConstPointAry();
1337 :
1338 0 : for ( i = 0; i < nPoints; i++ )
1339 : {
1340 0 : const Point* pPt = &(pPointAry[i]);
1341 0 : Point aPt;
1342 0 : aPt.X() = ImplPixelToLogic( pPt->X(), mnDPIX,
1343 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
1344 0 : maThresRes.mnThresPixToLogX ) - maMapRes.mnMapOfsX - mnOutOffLogicX;
1345 0 : aPt.Y() = ImplPixelToLogic( pPt->Y(), mnDPIY,
1346 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
1347 0 : maThresRes.mnThresPixToLogY ) - maMapRes.mnMapOfsY - mnOutOffLogicY;
1348 0 : aPoly[i] = aPt;
1349 : }
1350 :
1351 0 : return aPoly;
1352 : }
1353 :
1354 0 : tools::PolyPolygon OutputDevice::PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly ) const
1355 : {
1356 :
1357 0 : if ( !mbMap )
1358 0 : return rDevicePolyPoly;
1359 :
1360 0 : tools::PolyPolygon aPolyPoly( rDevicePolyPoly );
1361 0 : sal_uInt16 nPoly = aPolyPoly.Count();
1362 0 : for( sal_uInt16 i = 0; i < nPoly; i++ )
1363 : {
1364 0 : Polygon& rPoly = aPolyPoly[i];
1365 0 : rPoly = PixelToLogic( rPoly );
1366 : }
1367 0 : return aPolyPoly;
1368 : }
1369 :
1370 0 : basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygon& rPixelPolyPoly ) const
1371 : {
1372 0 : basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
1373 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation();
1374 0 : aTransformedPoly.transform( rTransformationMatrix );
1375 0 : return aTransformedPoly;
1376 : }
1377 :
1378 221093 : vcl::Region OutputDevice::PixelToLogic( const vcl::Region& rDeviceRegion ) const
1379 : {
1380 :
1381 221093 : if(!mbMap || rDeviceRegion.IsNull() || rDeviceRegion.IsEmpty())
1382 : {
1383 167716 : return rDeviceRegion;
1384 : }
1385 :
1386 53377 : vcl::Region aRegion;
1387 :
1388 53377 : if(rDeviceRegion.getB2DPolyPolygon())
1389 : {
1390 0 : aRegion = vcl::Region(PixelToLogic(*rDeviceRegion.getB2DPolyPolygon()));
1391 : }
1392 53377 : else if(rDeviceRegion.getPolyPolygon())
1393 : {
1394 0 : aRegion = vcl::Region(PixelToLogic(*rDeviceRegion.getPolyPolygon()));
1395 : }
1396 53377 : else if(rDeviceRegion.getRegionBand())
1397 : {
1398 53377 : RectangleVector aRectangles;
1399 53377 : rDeviceRegion.GetRegionRectangles(aRectangles);
1400 53377 : const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1401 :
1402 : // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1403 108115 : for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); ++aRectIter)
1404 : {
1405 54738 : aRegion.Union(PixelToLogic(*aRectIter));
1406 53377 : }
1407 : }
1408 :
1409 53377 : return aRegion;
1410 : }
1411 :
1412 30756 : Point OutputDevice::PixelToLogic( const Point& rDevicePt,
1413 : const MapMode& rMapMode ) const
1414 : {
1415 :
1416 : // calculate nothing if default-MapMode
1417 30756 : if ( rMapMode.IsDefault() )
1418 4 : return rDevicePt;
1419 :
1420 : // calculate MapMode-resolution and convert
1421 : ImplMapRes aMapRes;
1422 : ImplThresholdRes aThresRes;
1423 30752 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1424 :
1425 : return Point( ImplPixelToLogic( rDevicePt.X(), mnDPIX,
1426 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1427 30752 : aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1428 : ImplPixelToLogic( rDevicePt.Y(), mnDPIY,
1429 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1430 61504 : aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY );
1431 : }
1432 :
1433 16768 : Size OutputDevice::PixelToLogic( const Size& rDeviceSize,
1434 : const MapMode& rMapMode ) const
1435 : {
1436 :
1437 : // calculate nothing if default-MapMode
1438 16768 : if ( rMapMode.IsDefault() )
1439 1 : return rDeviceSize;
1440 :
1441 : // calculate MapMode-resolution and convert
1442 : ImplMapRes aMapRes;
1443 : ImplThresholdRes aThresRes;
1444 16767 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1445 :
1446 : return Size( ImplPixelToLogic( rDeviceSize.Width(), mnDPIX,
1447 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1448 : aThresRes.mnThresPixToLogX ),
1449 : ImplPixelToLogic( rDeviceSize.Height(), mnDPIY,
1450 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1451 16767 : aThresRes.mnThresPixToLogY ) );
1452 : }
1453 :
1454 7151 : Rectangle OutputDevice::PixelToLogic( const Rectangle& rDeviceRect,
1455 : const MapMode& rMapMode ) const
1456 : {
1457 :
1458 : // calculate nothing if default-MapMode
1459 7151 : if ( rMapMode.IsDefault() || rDeviceRect.IsEmpty() )
1460 0 : return rDeviceRect;
1461 :
1462 : // calculate MapMode-resolution and convert
1463 : ImplMapRes aMapRes;
1464 : ImplThresholdRes aThresRes;
1465 7151 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1466 :
1467 : return Rectangle( ImplPixelToLogic( rDeviceRect.Left(), mnDPIX,
1468 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1469 7151 : aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1470 : ImplPixelToLogic( rDeviceRect.Top(), mnDPIY,
1471 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1472 7151 : aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY,
1473 : ImplPixelToLogic( rDeviceRect.Right(), mnDPIX,
1474 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1475 7151 : aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX,
1476 : ImplPixelToLogic( rDeviceRect.Bottom(), mnDPIY,
1477 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1478 28604 : aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY );
1479 : }
1480 :
1481 0 : Polygon OutputDevice::PixelToLogic( const Polygon& rDevicePoly,
1482 : const MapMode& rMapMode ) const
1483 : {
1484 :
1485 : // calculate nothing if default-MapMode
1486 0 : if ( rMapMode.IsDefault() )
1487 0 : return rDevicePoly;
1488 :
1489 : // calculate MapMode-resolution and convert
1490 : ImplMapRes aMapRes;
1491 : ImplThresholdRes aThresRes;
1492 0 : ImplCalcMapResolution( rMapMode, mnDPIX, mnDPIY, aMapRes, aThresRes );
1493 :
1494 : sal_uInt16 i;
1495 0 : sal_uInt16 nPoints = rDevicePoly.GetSize();
1496 0 : Polygon aPoly( rDevicePoly );
1497 :
1498 : // get pointer to Point-array (copy data)
1499 0 : const Point* pPointAry = aPoly.GetConstPointAry();
1500 :
1501 0 : for ( i = 0; i < nPoints; i++ )
1502 : {
1503 0 : const Point* pPt = &(pPointAry[i]);
1504 0 : Point aPt;
1505 0 : aPt.X() = ImplPixelToLogic( pPt->X(), mnDPIX,
1506 : aMapRes.mnMapScNumX, aMapRes.mnMapScDenomX,
1507 0 : aThresRes.mnThresPixToLogX ) - aMapRes.mnMapOfsX - mnOutOffLogicX;
1508 0 : aPt.Y() = ImplPixelToLogic( pPt->Y(), mnDPIY,
1509 : aMapRes.mnMapScNumY, aMapRes.mnMapScDenomY,
1510 0 : aThresRes.mnThresPixToLogY ) - aMapRes.mnMapOfsY - mnOutOffLogicY;
1511 0 : aPoly[i] = aPt;
1512 : }
1513 :
1514 0 : return aPoly;
1515 : }
1516 :
1517 0 : tools::PolyPolygon OutputDevice::PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly,
1518 : const MapMode& rMapMode ) const
1519 : {
1520 :
1521 0 : if ( rMapMode.IsDefault() )
1522 0 : return rDevicePolyPoly;
1523 :
1524 0 : tools::PolyPolygon aPolyPoly( rDevicePolyPoly );
1525 0 : sal_uInt16 nPoly = aPolyPoly.Count();
1526 0 : for( sal_uInt16 i = 0; i < nPoly; i++ )
1527 : {
1528 0 : Polygon& rPoly = aPolyPoly[i];
1529 0 : rPoly = PixelToLogic( rPoly, rMapMode );
1530 : }
1531 0 : return aPolyPoly;
1532 : }
1533 :
1534 0 : basegfx::B2DPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolygon& rPixelPoly,
1535 : const MapMode& rMapMode ) const
1536 : {
1537 0 : basegfx::B2DPolygon aTransformedPoly = rPixelPoly;
1538 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
1539 0 : aTransformedPoly.transform( rTransformationMatrix );
1540 0 : return aTransformedPoly;
1541 : }
1542 :
1543 0 : basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygon& rPixelPolyPoly,
1544 : const MapMode& rMapMode ) const
1545 : {
1546 0 : basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
1547 0 : const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
1548 0 : aTransformedPoly.transform( rTransformationMatrix );
1549 0 : return aTransformedPoly;
1550 : }
1551 :
1552 0 : vcl::Region OutputDevice::PixelToLogic( const vcl::Region& rDeviceRegion, const MapMode& rMapMode ) const
1553 : {
1554 :
1555 0 : if(rMapMode.IsDefault() || rDeviceRegion.IsNull() || rDeviceRegion.IsEmpty())
1556 : {
1557 0 : return rDeviceRegion;
1558 : }
1559 :
1560 0 : vcl::Region aRegion;
1561 :
1562 0 : if(rDeviceRegion.getB2DPolyPolygon())
1563 : {
1564 0 : aRegion = vcl::Region(PixelToLogic(*rDeviceRegion.getB2DPolyPolygon(), rMapMode));
1565 : }
1566 0 : else if(rDeviceRegion.getPolyPolygon())
1567 : {
1568 0 : aRegion = vcl::Region(PixelToLogic(*rDeviceRegion.getPolyPolygon(), rMapMode));
1569 : }
1570 0 : else if(rDeviceRegion.getRegionBand())
1571 : {
1572 0 : RectangleVector aRectangles;
1573 0 : rDeviceRegion.GetRegionRectangles(aRectangles);
1574 0 : const RectangleVector& rRectangles(aRectangles); // needed to make the '!=' work
1575 :
1576 : // make reverse run to fill new region bottom-up, this will speed it up due to the used data structuring
1577 0 : for(RectangleVector::const_reverse_iterator aRectIter(rRectangles.rbegin()); aRectIter != rRectangles.rend(); ++aRectIter)
1578 : {
1579 0 : aRegion.Union(PixelToLogic(*aRectIter, rMapMode));
1580 0 : }
1581 : }
1582 :
1583 0 : return aRegion;
1584 : }
1585 :
1586 : #define ENTER1( rSource, pMapModeSource, pMapModeDest ) \
1587 : if ( !pMapModeSource ) \
1588 : pMapModeSource = &maMapMode; \
1589 : if ( !pMapModeDest ) \
1590 : pMapModeDest = &maMapMode; \
1591 : if ( *pMapModeSource == *pMapModeDest ) \
1592 : return rSource; \
1593 : \
1594 : ImplMapRes aMapResSource; \
1595 : aMapResSource.mnMapOfsX = 0; \
1596 : aMapResSource.mnMapOfsY = 0; \
1597 : aMapResSource.mnMapScNumX = 1; \
1598 : aMapResSource.mnMapScNumY = 1; \
1599 : aMapResSource.mnMapScDenomX = 1; \
1600 : aMapResSource.mnMapScDenomY = 1; \
1601 : aMapResSource.mfOffsetX = 0.0; \
1602 : aMapResSource.mfOffsetY = 0.0; \
1603 : aMapResSource.mfScaleX = 1.0; \
1604 : aMapResSource.mfScaleY = 1.0; \
1605 : ImplMapRes aMapResDest(aMapResSource); \
1606 : \
1607 : if ( !mbMap || pMapModeSource != &maMapMode ) \
1608 : { \
1609 : if ( pMapModeSource->GetMapUnit() == MAP_RELATIVE ) \
1610 : aMapResSource = maMapRes; \
1611 : ImplCalcMapResolution( *pMapModeSource, \
1612 : mnDPIX, mnDPIY, aMapResSource ); \
1613 : } \
1614 : else \
1615 : aMapResSource = maMapRes; \
1616 : if ( !mbMap || pMapModeDest != &maMapMode ) \
1617 : { \
1618 : if ( pMapModeDest->GetMapUnit() == MAP_RELATIVE ) \
1619 : aMapResDest = maMapRes; \
1620 : ImplCalcMapResolution( *pMapModeDest, \
1621 : mnDPIX, mnDPIY, aMapResDest ); \
1622 : } \
1623 : else \
1624 : aMapResDest = maMapRes
1625 :
1626 107762 : static void verifyUnitSourceDest( MapUnit eUnitSource, MapUnit eUnitDest )
1627 : {
1628 : (void) eUnitSource;
1629 : (void) eUnitDest;
1630 : DBG_ASSERT( eUnitSource != MAP_SYSFONT
1631 : && eUnitSource != MAP_APPFONT
1632 : && eUnitSource != MAP_RELATIVE,
1633 : "Source MapUnit nicht erlaubt" );
1634 : DBG_ASSERT( eUnitDest != MAP_SYSFONT
1635 : && eUnitDest != MAP_APPFONT
1636 : && eUnitDest != MAP_RELATIVE,
1637 : "Destination MapUnit nicht erlaubt" );
1638 : DBG_ASSERTWARNING( eUnitSource != MAP_PIXEL,
1639 : "MAP_PIXEL mit 72dpi angenaehert" );
1640 : DBG_ASSERTWARNING( eUnitDest != MAP_PIXEL,
1641 : "MAP_PIXEL mit 72dpi angenaehert" );
1642 107762 : }
1643 :
1644 : #define ENTER3( eUnitSource, eUnitDest ) \
1645 : long nNumerator = 1; \
1646 : long nDenominator = 1; \
1647 : DBG_ASSERT( eUnitSource < s_ImplArySize, "Invalid source map unit"); \
1648 : DBG_ASSERT( eUnitDest < s_ImplArySize, "Invalid destination map unit"); \
1649 : if( (eUnitSource < s_ImplArySize) && (eUnitDest < s_ImplArySize) ) \
1650 : { \
1651 : nNumerator = aImplNumeratorAry[eUnitSource] * \
1652 : aImplDenominatorAry[eUnitDest]; \
1653 : nDenominator = aImplNumeratorAry[eUnitDest] * \
1654 : aImplDenominatorAry[eUnitSource]; \
1655 : } \
1656 : if ( eUnitSource == MAP_PIXEL ) \
1657 : nDenominator *= 72; \
1658 : else if( eUnitDest == MAP_PIXEL ) \
1659 : nNumerator *= 72
1660 :
1661 : #define ENTER4( rMapModeSource, rMapModeDest ) \
1662 : ImplMapRes aMapResSource; \
1663 : aMapResSource.mnMapOfsX = 0; \
1664 : aMapResSource.mnMapOfsY = 0; \
1665 : aMapResSource.mnMapScNumX = 1; \
1666 : aMapResSource.mnMapScNumY = 1; \
1667 : aMapResSource.mnMapScDenomX = 1; \
1668 : aMapResSource.mnMapScDenomY = 1; \
1669 : aMapResSource.mfOffsetX = 0.0; \
1670 : aMapResSource.mfOffsetY = 0.0; \
1671 : aMapResSource.mfScaleX = 1.0; \
1672 : aMapResSource.mfScaleY = 1.0; \
1673 : ImplMapRes aMapResDest(aMapResSource); \
1674 : \
1675 : ImplCalcMapResolution( rMapModeSource, 72, 72, aMapResSource ); \
1676 : ImplCalcMapResolution( rMapModeDest, 72, 72, aMapResDest )
1677 :
1678 : // return (n1 * n2 * n3) / (n4 * n5)
1679 14824 : static long fn5( const long n1,
1680 : const long n2,
1681 : const long n3,
1682 : const long n4,
1683 : const long n5 )
1684 : {
1685 14824 : if ( n1 == 0 || n2 == 0 || n3 == 0 || n4 == 0 || n5 == 0 )
1686 3001 : return 0;
1687 11823 : if ( LONG_MAX / std::abs(n2) < std::abs(n3) )
1688 : {
1689 : // a6 is skipped
1690 0 : BigInt a7 = n2;
1691 0 : a7 *= n3;
1692 0 : a7 *= n1;
1693 :
1694 0 : if ( LONG_MAX / std::abs(n4) < std::abs(n5) )
1695 : {
1696 0 : BigInt a8 = n4;
1697 0 : a8 *= n5;
1698 :
1699 0 : BigInt a9 = a8;
1700 0 : a9 /= 2;
1701 0 : if ( a7.IsNeg() )
1702 0 : a7 -= a9;
1703 : else
1704 0 : a7 += a9;
1705 :
1706 0 : a7 /= a8;
1707 : } // of if
1708 : else
1709 : {
1710 0 : long n8 = n4 * n5;
1711 :
1712 0 : if ( a7.IsNeg() )
1713 0 : a7 -= n8 / 2;
1714 : else
1715 0 : a7 += n8 / 2;
1716 :
1717 0 : a7 /= n8;
1718 : } // of else
1719 0 : return (long)a7;
1720 : } // of if
1721 : else
1722 : {
1723 11823 : long n6 = n2 * n3;
1724 :
1725 11823 : if ( LONG_MAX / std::abs(n1) < std::abs(n6) )
1726 : {
1727 0 : BigInt a7 = n1;
1728 0 : a7 *= n6;
1729 :
1730 0 : if ( LONG_MAX / std::abs(n4) < std::abs(n5) )
1731 : {
1732 0 : BigInt a8 = n4;
1733 0 : a8 *= n5;
1734 :
1735 0 : BigInt a9 = a8;
1736 0 : a9 /= 2;
1737 0 : if ( a7.IsNeg() )
1738 0 : a7 -= a9;
1739 : else
1740 0 : a7 += a9;
1741 :
1742 0 : a7 /= a8;
1743 : } // of if
1744 : else
1745 : {
1746 0 : long n8 = n4 * n5;
1747 :
1748 0 : if ( a7.IsNeg() )
1749 0 : a7 -= n8 / 2;
1750 : else
1751 0 : a7 += n8 / 2;
1752 :
1753 0 : a7 /= n8;
1754 : } // of else
1755 0 : return (long)a7;
1756 : } // of if
1757 : else
1758 : {
1759 11823 : long n7 = n1 * n6;
1760 :
1761 11823 : if ( LONG_MAX / std::abs(n4) < std::abs(n5) )
1762 : {
1763 0 : BigInt a7 = n7;
1764 0 : BigInt a8 = n4;
1765 0 : a8 *= n5;
1766 :
1767 0 : BigInt a9 = a8;
1768 0 : a9 /= 2;
1769 0 : if ( a7.IsNeg() )
1770 0 : a7 -= a9;
1771 : else
1772 0 : a7 += a9;
1773 :
1774 0 : a7 /= a8;
1775 0 : return (long)a7;
1776 : } // of if
1777 : else
1778 : {
1779 11823 : const long n8 = n4 * n5;
1780 11823 : const long n8_2 = n8 / 2;
1781 :
1782 11823 : if( n7 < 0 )
1783 : {
1784 302 : if( ( n7 - LONG_MIN ) >= n8_2 )
1785 302 : n7 -= n8_2;
1786 : }
1787 11521 : else if( ( LONG_MAX - n7 ) >= n8_2 )
1788 11521 : n7 += n8_2;
1789 :
1790 11823 : return n7 / n8;
1791 : } // of else
1792 : } // of else
1793 : } // of else
1794 : }
1795 :
1796 : // return (n1 * n2) / n3
1797 236588 : static long fn3( const long n1, const long n2, const long n3 )
1798 : {
1799 236588 : if ( n1 == 0 || n2 == 0 || n3 == 0 )
1800 33004 : return 0;
1801 203584 : if ( LONG_MAX / std::abs(n1) < std::abs(n2) )
1802 : {
1803 0 : BigInt a4 = n1;
1804 0 : a4 *= n2;
1805 :
1806 0 : if ( a4.IsNeg() )
1807 0 : a4 -= n3 / 2;
1808 : else
1809 0 : a4 += n3 / 2;
1810 :
1811 0 : a4 /= n3;
1812 0 : return (long)a4;
1813 : } // of if
1814 : else
1815 : {
1816 203584 : long n4 = n1 * n2;
1817 203584 : const long n3_2 = n3 / 2;
1818 :
1819 203584 : if( n4 < 0 )
1820 : {
1821 17237 : if( ( n4 - LONG_MIN ) >= n3_2 )
1822 17237 : n4 -= n3_2;
1823 : }
1824 186347 : else if( ( LONG_MAX - n4 ) >= n3_2 )
1825 186347 : n4 += n3_2;
1826 :
1827 203584 : return n4 / n3;
1828 : } // of else
1829 : }
1830 :
1831 5404 : Point OutputDevice::LogicToLogic( const Point& rPtSource,
1832 : const MapMode* pMapModeSource,
1833 : const MapMode* pMapModeDest ) const
1834 : {
1835 5404 : ENTER1( rPtSource, pMapModeSource, pMapModeDest );
1836 :
1837 423 : return Point( fn5( rPtSource.X() + aMapResSource.mnMapOfsX,
1838 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1839 846 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
1840 : aMapResDest.mnMapOfsX,
1841 423 : fn5( rPtSource.Y() + aMapResSource.mnMapOfsY,
1842 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1843 846 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
1844 846 : aMapResDest.mnMapOfsY );
1845 : }
1846 :
1847 5020 : Size OutputDevice::LogicToLogic( const Size& rSzSource,
1848 : const MapMode* pMapModeSource,
1849 : const MapMode* pMapModeDest ) const
1850 : {
1851 5020 : ENTER1( rSzSource, pMapModeSource, pMapModeDest );
1852 :
1853 : return Size( fn5( rSzSource.Width(),
1854 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1855 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ),
1856 : fn5( rSzSource.Height(),
1857 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1858 11 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) );
1859 : }
1860 :
1861 0 : Rectangle OutputDevice::LogicToLogic( const Rectangle& rRectSource,
1862 : const MapMode* pMapModeSource,
1863 : const MapMode* pMapModeDest ) const
1864 : {
1865 0 : ENTER1( rRectSource, pMapModeSource, pMapModeDest );
1866 :
1867 0 : return Rectangle( fn5( rRectSource.Left() + aMapResSource.mnMapOfsX,
1868 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1869 0 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
1870 : aMapResDest.mnMapOfsX,
1871 0 : fn5( rRectSource.Top() + aMapResSource.mnMapOfsY,
1872 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1873 0 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
1874 : aMapResDest.mnMapOfsY,
1875 0 : fn5( rRectSource.Right() + aMapResSource.mnMapOfsX,
1876 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1877 0 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
1878 : aMapResDest.mnMapOfsX,
1879 0 : fn5( rRectSource.Bottom() + aMapResSource.mnMapOfsY,
1880 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1881 0 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
1882 0 : aMapResDest.mnMapOfsY );
1883 : }
1884 :
1885 10007 : Point OutputDevice::LogicToLogic( const Point& rPtSource,
1886 : const MapMode& rMapModeSource,
1887 : const MapMode& rMapModeDest )
1888 : {
1889 10007 : if ( rMapModeSource == rMapModeDest )
1890 7033 : return rPtSource;
1891 :
1892 2974 : MapUnit eUnitSource = rMapModeSource.GetMapUnit();
1893 2974 : MapUnit eUnitDest = rMapModeDest.GetMapUnit();
1894 2974 : verifyUnitSourceDest( eUnitSource, eUnitDest );
1895 :
1896 2974 : if (rMapModeSource.IsSimple() && rMapModeDest.IsSimple())
1897 : {
1898 146 : ENTER3( eUnitSource, eUnitDest );
1899 :
1900 : return Point( fn3( rPtSource.X(), nNumerator, nDenominator ),
1901 146 : fn3( rPtSource.Y(), nNumerator, nDenominator ) );
1902 : }
1903 : else
1904 : {
1905 2828 : ENTER4( rMapModeSource, rMapModeDest );
1906 :
1907 2828 : return Point( fn5( rPtSource.X() + aMapResSource.mnMapOfsX,
1908 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1909 5656 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
1910 : aMapResDest.mnMapOfsX,
1911 2828 : fn5( rPtSource.Y() + aMapResSource.mnMapOfsY,
1912 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1913 5656 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
1914 5656 : aMapResDest.mnMapOfsY );
1915 : }
1916 : }
1917 :
1918 81284 : Size OutputDevice::LogicToLogic( const Size& rSzSource,
1919 : const MapMode& rMapModeSource,
1920 : const MapMode& rMapModeDest )
1921 : {
1922 81284 : if ( rMapModeSource == rMapModeDest )
1923 3047 : return rSzSource;
1924 :
1925 78237 : MapUnit eUnitSource = rMapModeSource.GetMapUnit();
1926 78237 : MapUnit eUnitDest = rMapModeDest.GetMapUnit();
1927 78237 : verifyUnitSourceDest( eUnitSource, eUnitDest );
1928 :
1929 78237 : if (rMapModeSource.IsSimple() && rMapModeDest.IsSimple())
1930 : {
1931 74573 : ENTER3( eUnitSource, eUnitDest );
1932 :
1933 : return Size( fn3( rSzSource.Width(), nNumerator, nDenominator ),
1934 74573 : fn3( rSzSource.Height(), nNumerator, nDenominator ) );
1935 : }
1936 : else
1937 : {
1938 3664 : ENTER4( rMapModeSource, rMapModeDest );
1939 :
1940 : return Size( fn5( rSzSource.Width(),
1941 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
1942 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ),
1943 : fn5( rSzSource.Height(),
1944 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
1945 3664 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) );
1946 : }
1947 : }
1948 :
1949 0 : basegfx::B2DPolygon OutputDevice::LogicToLogic( const basegfx::B2DPolygon& rPolySource,
1950 : const MapMode& rMapModeSource,
1951 : const MapMode& rMapModeDest )
1952 : {
1953 0 : if(rMapModeSource == rMapModeDest)
1954 : {
1955 0 : return rPolySource;
1956 : }
1957 :
1958 0 : const basegfx::B2DHomMatrix aTransform(LogicToLogic(rMapModeSource, rMapModeDest));
1959 0 : basegfx::B2DPolygon aPoly(rPolySource);
1960 :
1961 0 : aPoly.transform(aTransform);
1962 0 : return aPoly;
1963 : }
1964 :
1965 0 : basegfx::B2DPolyPolygon OutputDevice::LogicToLogic( const basegfx::B2DPolyPolygon& rPolySource,
1966 : const MapMode& rMapModeSource,
1967 : const MapMode& rMapModeDest )
1968 : {
1969 0 : if(rMapModeSource == rMapModeDest)
1970 : {
1971 0 : return rPolySource;
1972 : }
1973 :
1974 0 : const basegfx::B2DHomMatrix aTransform(LogicToLogic(rMapModeSource, rMapModeDest));
1975 0 : basegfx::B2DPolyPolygon aPoly(rPolySource);
1976 :
1977 0 : aPoly.transform(aTransform);
1978 0 : return aPoly;
1979 : }
1980 :
1981 10 : basegfx::B2DHomMatrix OutputDevice::LogicToLogic(const MapMode& rMapModeSource, const MapMode& rMapModeDest)
1982 : {
1983 10 : basegfx::B2DHomMatrix aTransform;
1984 :
1985 10 : if(rMapModeSource == rMapModeDest)
1986 : {
1987 0 : return aTransform;
1988 : }
1989 :
1990 10 : MapUnit eUnitSource = rMapModeSource.GetMapUnit();
1991 10 : MapUnit eUnitDest = rMapModeDest.GetMapUnit();
1992 10 : verifyUnitSourceDest(eUnitSource, eUnitDest);
1993 :
1994 10 : if (rMapModeSource.IsSimple() && rMapModeDest.IsSimple())
1995 : {
1996 10 : ENTER3(eUnitSource, eUnitDest);
1997 :
1998 10 : const double fScaleFactor((double)nNumerator / (double)nDenominator);
1999 10 : aTransform.set(0, 0, fScaleFactor);
2000 10 : aTransform.set(1, 1, fScaleFactor);
2001 : }
2002 : else
2003 : {
2004 0 : ENTER4(rMapModeSource, rMapModeDest);
2005 :
2006 0 : const double fScaleFactorX((double(aMapResSource.mnMapScNumX) * double(aMapResDest.mnMapScDenomX)) / (double(aMapResSource.mnMapScDenomX) * double(aMapResDest.mnMapScNumX)));
2007 0 : const double fScaleFactorY((double(aMapResSource.mnMapScNumY) * double(aMapResDest.mnMapScDenomY)) / (double(aMapResSource.mnMapScDenomY) * double(aMapResDest.mnMapScNumY)));
2008 0 : const double fZeroPointX(double(aMapResSource.mnMapOfsX) * fScaleFactorX - double(aMapResDest.mnMapOfsX));
2009 0 : const double fZeroPointY(double(aMapResSource.mnMapOfsY) * fScaleFactorY - double(aMapResDest.mnMapOfsY));
2010 :
2011 0 : aTransform.set(0, 0, fScaleFactorX);
2012 0 : aTransform.set(1, 1, fScaleFactorY);
2013 0 : aTransform.set(0, 2, fZeroPointX);
2014 0 : aTransform.set(1, 2, fZeroPointY);
2015 : }
2016 :
2017 10 : return aTransform;
2018 : }
2019 :
2020 28282 : Rectangle OutputDevice::LogicToLogic( const Rectangle& rRectSource,
2021 : const MapMode& rMapModeSource,
2022 : const MapMode& rMapModeDest )
2023 : {
2024 28282 : if ( rMapModeSource == rMapModeDest )
2025 7755 : return rRectSource;
2026 :
2027 20527 : MapUnit eUnitSource = rMapModeSource.GetMapUnit();
2028 20527 : MapUnit eUnitDest = rMapModeDest.GetMapUnit();
2029 20527 : verifyUnitSourceDest( eUnitSource, eUnitDest );
2030 :
2031 20527 : if (rMapModeSource.IsSimple() && rMapModeDest.IsSimple())
2032 : {
2033 20284 : ENTER3( eUnitSource, eUnitDest );
2034 :
2035 : return Rectangle( fn3( rRectSource.Left(), nNumerator, nDenominator ),
2036 : fn3( rRectSource.Top(), nNumerator, nDenominator ),
2037 : fn3( rRectSource.Right(), nNumerator, nDenominator ),
2038 20284 : fn3( rRectSource.Bottom(), nNumerator, nDenominator ) );
2039 : }
2040 : else
2041 : {
2042 243 : ENTER4( rMapModeSource, rMapModeDest );
2043 :
2044 243 : return Rectangle( fn5( rRectSource.Left() + aMapResSource.mnMapOfsX,
2045 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2046 486 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2047 : aMapResDest.mnMapOfsX,
2048 243 : fn5( rRectSource.Top() + aMapResSource.mnMapOfsY,
2049 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2050 486 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2051 : aMapResDest.mnMapOfsY,
2052 243 : fn5( rRectSource.Right() + aMapResSource.mnMapOfsX,
2053 : aMapResSource.mnMapScNumX, aMapResDest.mnMapScDenomX,
2054 486 : aMapResSource.mnMapScDenomX, aMapResDest.mnMapScNumX ) -
2055 : aMapResDest.mnMapOfsX,
2056 243 : fn5( rRectSource.Bottom() + aMapResSource.mnMapOfsY,
2057 : aMapResSource.mnMapScNumY, aMapResDest.mnMapScDenomY,
2058 486 : aMapResSource.mnMapScDenomY, aMapResDest.mnMapScNumY ) -
2059 972 : aMapResDest.mnMapOfsY );
2060 : }
2061 : }
2062 :
2063 6021 : long OutputDevice::LogicToLogic( long nLongSource,
2064 : MapUnit eUnitSource, MapUnit eUnitDest )
2065 : {
2066 6021 : if ( eUnitSource == eUnitDest )
2067 7 : return nLongSource;
2068 :
2069 6014 : verifyUnitSourceDest( eUnitSource, eUnitDest );
2070 6014 : ENTER3( eUnitSource, eUnitDest );
2071 :
2072 6014 : return fn3( nLongSource, nNumerator, nDenominator );
2073 : }
2074 :
2075 476 : void OutputDevice::SetPixelOffset( const Size& rOffset )
2076 : {
2077 476 : mnOutOffOrigX = rOffset.Width();
2078 476 : mnOutOffOrigY = rOffset.Height();
2079 :
2080 : mnOutOffLogicX = ImplPixelToLogic( mnOutOffOrigX, mnDPIX,
2081 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
2082 476 : maThresRes.mnThresPixToLogX );
2083 : mnOutOffLogicY = ImplPixelToLogic( mnOutOffOrigY, mnDPIY,
2084 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
2085 476 : maThresRes.mnThresPixToLogY );
2086 :
2087 476 : if( mpAlphaVDev )
2088 0 : mpAlphaVDev->SetPixelOffset( rOffset );
2089 476 : }
2090 :
2091 :
2092 : namespace vcl {
2093 :
2094 5848 : long Window::ImplLogicUnitToPixelX( long nX, MapUnit eUnit )
2095 : {
2096 5848 : if ( eUnit != MAP_PIXEL )
2097 : {
2098 5752 : ImplFrameData* pFrameData = mpWindowImpl->mpFrameData;
2099 :
2100 : // shift map unit, then re-calculate
2101 5752 : if ( pFrameData->meMapUnit != eUnit )
2102 : {
2103 2620 : pFrameData->meMapUnit = eUnit;
2104 : ImplCalcMapResolution( MapMode( eUnit ), mnDPIX, mnDPIY,
2105 2620 : pFrameData->maMapUnitRes );
2106 : }
2107 :
2108 : // BigInt is not required, as this function is only used to
2109 : // convert the window position
2110 5752 : nX = nX * mnDPIX * pFrameData->maMapUnitRes.mnMapScNumX;
2111 5752 : nX += nX >= 0 ? (pFrameData->maMapUnitRes.mnMapScDenomX/2) :
2112 11504 : -((pFrameData->maMapUnitRes.mnMapScDenomX-1)/2);
2113 5752 : nX /= pFrameData->maMapUnitRes.mnMapScDenomX;
2114 : }
2115 :
2116 5848 : return nX;
2117 : }
2118 :
2119 5848 : long Window::ImplLogicUnitToPixelY( long nY, MapUnit eUnit )
2120 : {
2121 5848 : if ( eUnit != MAP_PIXEL )
2122 : {
2123 5752 : ImplFrameData* pFrameData = mpWindowImpl->mpFrameData;
2124 :
2125 : // shift map unit, then re-calculate
2126 5752 : if ( pFrameData->meMapUnit != eUnit )
2127 : {
2128 0 : pFrameData->meMapUnit = eUnit;
2129 : ImplCalcMapResolution( MapMode( eUnit ), mnDPIX, mnDPIY,
2130 0 : pFrameData->maMapUnitRes );
2131 : }
2132 :
2133 : // BigInt is not required, as this function is only used to
2134 : // convert the window position
2135 5752 : nY = nY * mnDPIY * pFrameData->maMapUnitRes.mnMapScNumY;
2136 5752 : nY += nY >= 0 ? (pFrameData->maMapUnitRes.mnMapScDenomY/2) :
2137 11504 : -((pFrameData->maMapUnitRes.mnMapScDenomY-1)/2);
2138 5752 : nY /= pFrameData->maMapUnitRes.mnMapScDenomY;
2139 : }
2140 :
2141 5848 : return nY;
2142 : }
2143 :
2144 : } /* namespace vcl */
2145 :
2146 983801 : DeviceCoordinate OutputDevice::LogicWidthToDeviceCoordinate( long nWidth ) const
2147 : {
2148 983801 : if ( !mbMap )
2149 11380 : return (DeviceCoordinate)nWidth;
2150 :
2151 : #if VCL_FLOAT_DEVICE_PIXEL
2152 : return (double)nWidth * maMapRes.mfScaleX * mnDPIX;
2153 : #else
2154 :
2155 : return ImplLogicToPixel( nWidth, mnDPIX,
2156 : maMapRes.mnMapScNumX, maMapRes.mnMapScDenomX,
2157 972421 : maThresRes.mnThresLogToPixX );
2158 : #endif
2159 : }
2160 :
2161 0 : DeviceCoordinate OutputDevice::LogicHeightToDeviceCoordinate( long nHeight ) const
2162 : {
2163 0 : if ( !mbMap )
2164 0 : return (DeviceCoordinate)nHeight;
2165 : #if VCL_FLOAT_DEVICE_PIXEL
2166 : return (double)nHeight * maMapRes.mfScaleY * mnDPIY;
2167 : #else
2168 :
2169 : return ImplLogicToPixel( nHeight, mnDPIY,
2170 : maMapRes.mnMapScNumY, maMapRes.mnMapScDenomY,
2171 0 : maThresRes.mnThresLogToPixY );
2172 : #endif
2173 : }
2174 :
2175 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
