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