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