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