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