win32ss/gdi/gdi32/objects/coord.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS System Libraries
   4  * FILE:            win32ss/gdi/gdi32/objects/coord.c
   5  * PURPOSE:         Functions for coordinate transformation
   6  * PROGRAMMER:
   7  */
   8 #include <precomp.h>
   9
  10 /* Currently we use a MATRIX inside the DC_ATTR containing the
  11    coordinate transformations, while we deal with XFORM structures
  12    internally. If we move all coordinate transformation to gdi32,
  13    we might as well have an XFORM structure in the DC_ATTR. */
  14 void
  15 MatrixToXForm(XFORM *pxform, const MATRIX *pmx)
  16 {
  17     XFORML *pxforml = (XFORML*)pxform;
  18     pxforml->eM11 = FOtoF(&pmx->efM11);
  19     pxforml->eM12 = FOtoF(&pmx->efM12);
  20     pxforml->eM21 = FOtoF(&pmx->efM21);
  21     pxforml->eM22 = FOtoF(&pmx->efM22);
  22     pxforml->eDx = FOtoF(&pmx->efDx);
  23     pxforml->eDy = FOtoF(&pmx->efDy);
  24 }
  25
  26 void
  27 GdiTransformPoints2(
  28     _In_ XFORM *pxform,
  29     _Out_writes_(nCount) PPOINT pptOut,
  30     _In_reads_(nCount) PPOINT pptIn,
  31     _In_ ULONG nCount)
  32 {
  33     ULONG i;
  34     FLOAT x, y;
  35
  36     for (i = 0; i < nCount; i++)
  37     {
  38         x = pptIn[i].x * pxform->eM11 + pptIn[i].y * pxform->eM12 + pxform->eDx;
  39         pptOut[i].x = _lrintf(x);
  40         y = pptIn[i].x * pxform->eM21 + pptIn[i].y * pxform->eM22 + pxform->eDy;
  41         pptOut[i].y = _lrintf(y);
  42     }
  43 }
  44
  45 FORCEINLINE
  46 void
  47 GdiTransformPoints(
  48     _In_ MATRIX *pmx,
  49     _Out_writes_(nCount) PPOINT pptOut,
  50     _In_reads_(nCount) PPOINT pptIn,
  51     _In_ ULONG nCount)
  52 {
  53     XFORM xform;
  54
  55     MatrixToXForm(&xform, pmx);
  56     GdiTransformPoints2(&xform, pptOut, pptIn, nCount);
  57 }
  58
  59 #define MAX_OFFSET 4294967041.0
  60 #define _fmul(x,y) (((x) == 0) ? 0 : (x) * (y))
  61
  62 BOOL
  63 WINAPI
  64 CombineTransform(
  65     _Out_ LPXFORM pxfResult,
  66     _In_ const XFORM *pxf1,
  67     _In_ const XFORM *pxf2)
  68 {
  69     XFORM xformTmp;
  70
  71     /* Check paramters */
  72     if (!pxfResult || !pxf1 || !pxf2) return FALSE;
  73
  74     /* Do matrix multiplication, start with scaling elements */
  75     xformTmp.eM11 = (pxf1->eM11 * pxf2->eM11) + (pxf1->eM12 * pxf2->eM21);
  76     xformTmp.eM22 = (pxf1->eM21 * pxf2->eM12) + (pxf1->eM22 * pxf2->eM22);
  77
  78     /* Calculate shear/rotate elements only of they are present */
  79     if ((pxf1->eM12 != 0.) || (pxf1->eM21 != 0.) ||
  80         (pxf2->eM12 != 0.) || (pxf2->eM21 != 0.))
  81     {
  82         xformTmp.eM12 = (pxf1->eM11 * pxf2->eM12) + (pxf1->eM12 * pxf2->eM22);
  83         xformTmp.eM21 = (pxf1->eM21 * pxf2->eM11) + (pxf1->eM22 * pxf2->eM21);
  84     }
  85     else
  86     {
  87         xformTmp.eM12 = 0.;
  88         xformTmp.eM21 = 0.;
  89     }
  90
  91     /* Calculate the offset */
  92     xformTmp.eDx = _fmul(pxf1->eDx, pxf2->eM11) + _fmul(pxf1->eDy, pxf2->eM21) + pxf2->eDx;
  93     xformTmp.eDy = _fmul(pxf1->eDx, pxf2->eM12) + _fmul(pxf1->eDy, pxf2->eM22) + pxf2->eDy;
  94
  95     /* Check for invalid offset ranges */
  96     if ((xformTmp.eDx > MAX_OFFSET) || (xformTmp.eDx < -MAX_OFFSET) ||
  97         (xformTmp.eDy > MAX_OFFSET) || (xformTmp.eDy < -MAX_OFFSET))
  98     {
  99         return FALSE;
 100     }
 101
 102     /* All is ok, return the calculated values */
 103     *pxfResult = xformTmp;
 104     return TRUE;
 105 }
 106
 107
 108 /*
 109  * @implemented
 110  *
 111  */
 112 int
 113 WINAPI
 114 GetMapMode(
 115     _In_ HDC hdc)
 116 {
 117     PDC_ATTR pdcattr;
 118
 119     /* Get the DC attribute */
 120     pdcattr = GdiGetDcAttr(hdc);
 121     if (pdcattr == NULL)
 122     {
 123         SetLastError(ERROR_INVALID_PARAMETER);
 124         return 0;
 125     }
 126
 127     /* Return the map mode */
 128     return pdcattr->iMapMode;
 129 }
 130
 131 /*
 132  * @implemented
 133  */
 134 INT
 135 WINAPI
 136 SetMapMode(
 137     _In_ HDC hdc,
 138     _In_ INT iMode)
 139 {
 140     PDC_ATTR pdcattr;
 141
 142     /* Handle METADC16 here, since we don't have a DCATTR. */
 143     if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE) \
 144     {
 145         return GetAndSetDCDWord(hdc, GdiGetSetMapMode, iMode, 0, 0, 0 );
 146     }
 147
 148     /* Get the DC attribute */
 149     pdcattr = GdiGetDcAttr(hdc);
 150     if (pdcattr == NULL)
 151     {
 152         SetLastError(ERROR_INVALID_PARAMETER);
 153         return 0;
 154     }
 155
 156     /* Force change if Isotropic is set for recompute. */
 157     if ((iMode != pdcattr->iMapMode) || (iMode == MM_ISOTROPIC))
 158     {
 159         pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
 160         return GetAndSetDCDWord(hdc, GdiGetSetMapMode, iMode, 0, 0, 0 );
 161     }
 162
 163     return pdcattr->iMapMode;
 164 }
 165
 166
 167 BOOL
 168 WINAPI
 169 DPtoLP(
 170     _In_ HDC hdc,
 171     _Inout_updates_(nCount) LPPOINT lpPoints,
 172     _In_ INT nCount)
 173 {
 174     PDC_ATTR pdcattr;
 175     SIZEL sizlView;
 176
 177     if (nCount <= 0)
 178         return TRUE;
 179
 180     if (hdc == NULL)
 181     {
 182         SetLastError(ERROR_INVALID_PARAMETER);
 183         return FALSE;
 184     }
 185     if (lpPoints == NULL)
 186     {
 187         return TRUE;
 188     }
 189
 190     pdcattr = GdiGetDcAttr(hdc);
 191     if (pdcattr == NULL)
 192         return FALSE;
 193
 194     if (pdcattr->iMapMode == MM_ISOTROPIC)
 195     {
 196         if (NtGdiGetDCPoint(hdc, GdiGetViewPortExt, (PPOINTL)&sizlView))
 197         {
 198             if (sizlView.cx == 0 || sizlView.cy == 0)
 199                 return FALSE;
 200         }
 201     }
 202
 203     return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiDpToLp);
 204 }
 205
 206 BOOL
 207 WINAPI
 208 LPtoDP(
 209     _In_ HDC hdc,
 210     _Inout_updates_(nCount) LPPOINT lpPoints,
 211     _In_ INT nCount)
 212 {
 213     PDC_ATTR pdcattr;
 214
 215     if (nCount <= 0)
 216         return TRUE;
 217
 218     if (hdc == NULL)
 219     {
 220         SetLastError(ERROR_INVALID_PARAMETER);
 221         return FALSE;
 222     }
 223     if (lpPoints == NULL)
 224     {
 225         return TRUE;
 226     }
 227
 228     pdcattr = GdiGetDcAttr(hdc);
 229     if (pdcattr == NULL)
 230         return FALSE;
 231
 232     return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiLpToDp);
 233 }
 234
 235 /*
 236  * @implemented
 237  *
 238  */
 239 BOOL
 240 WINAPI
 241 GetCurrentPositionEx(
 242     _In_ HDC hdc,
 243     _Out_ LPPOINT lpPoint)
 244 {
 245     PDC_ATTR pdcattr;
 246
 247     /* Get the DC attribute */
 248     pdcattr = GdiGetDcAttr(hdc);
 249     if ((pdcattr == NULL) || (lpPoint == NULL))
 250     {
 251         SetLastError(ERROR_INVALID_PARAMETER);
 252         return FALSE;
 253     }
 254
 255     if (pdcattr->ulDirty_ & DIRTY_PTLCURRENT) // have a hit!
 256     {
 257         lpPoint->x = pdcattr->ptfxCurrent.x;
 258         lpPoint->y = pdcattr->ptfxCurrent.y;
 259         DPtoLP(hdc, lpPoint, 1);          // reconvert back.
 260         pdcattr->ptlCurrent.x = lpPoint->x; // save it
 261         pdcattr->ptlCurrent.y = lpPoint->y;
 262         pdcattr->ulDirty_ &= ~DIRTY_PTLCURRENT; // clear bit
 263     }
 264     else
 265     {
 266         lpPoint->x = pdcattr->ptlCurrent.x;
 267         lpPoint->y = pdcattr->ptlCurrent.y;
 268     }
 269
 270     return TRUE;
 271 }
 272
 273 /*
 274  * @implemented
 275  */
 276 BOOL
 277 WINAPI
 278 GetWorldTransform(
 279     _In_ HDC hdc,
 280     _Out_ LPXFORM pxform)
 281 {
 282     PDC_ATTR pdcattr;
 283
 284     pdcattr = GdiGetDcAttr(hdc);
 285     if (!pdcattr)
 286     {
 287         SetLastError(ERROR_INVALID_HANDLE);
 288         return FALSE;
 289     }
 290 #if 0
 291     if (pdcattr->flXform & ANY_XFORM_INVALID)
 292     {
 293         GdiFixupTransforms(pdcattr);
 294     }
 295
 296     MatrixToXForm(pxform, &pdcattr->mxWorldToDevice);
 297 #endif
 298     return NtGdiGetTransform(hdc, GdiWorldSpaceToPageSpace, pxform);
 299 }
 300
 301
 302 BOOL
 303 WINAPI
 304 SetWorldTransform(
 305     _In_ HDC hdc,
 306     _Out_ CONST XFORM *pxform)
 307 {
 308     return ModifyWorldTransform(hdc, pxform, MWT_SET);
 309 }
 310
 311
 312 BOOL
 313 WINAPI
 314 ModifyWorldTransform(
 315     _In_ HDC hdc,
 316     _In_opt_ CONST XFORM *pxform,
 317     _In_ DWORD dwMode)
 318 {
 319     PDC_ATTR pdcattr;
 320
 321     if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE)
 322         return FALSE;
 323
 324     if (dwMode == MWT_SET)
 325     {
 326        HANDLE_METADC(BOOL, SetWorldTransform, FALSE, hdc, pxform);
 327     }
 328     else
 329     {
 330        HANDLE_METADC(BOOL, ModifyWorldTransform, FALSE, hdc, pxform, dwMode);
 331     }
 332
 333     /* Get the DC attribute */
 334     pdcattr = GdiGetDcAttr(hdc);
 335     if (pdcattr == NULL)
 336     {
 337         SetLastError(ERROR_INVALID_PARAMETER);
 338         return FALSE;
 339     }
 340
 341     /* Check that graphics mode is GM_ADVANCED */
 342     if (pdcattr->iGraphicsMode != GM_ADVANCED)
 343         return FALSE;
 344
 345     /* Call win32k to do the work */
 346     return NtGdiModifyWorldTransform(hdc, (LPXFORM)pxform, dwMode);
 347 }
 348
 349 BOOL
 350 WINAPI
 351 GetViewportExtEx(
 352     _In_ HDC hdc,
 353     _Out_ LPSIZE lpSize)
 354 {
 355     PDC_ATTR pdcattr;
 356
 357     /* Get the DC attribute */
 358     pdcattr = GdiGetDcAttr(hdc);
 359     if (pdcattr == NULL)
 360     {
 361         /* Do not set LastError here! */
 362         return FALSE;
 363     }
 364
 365     /* Check if we need to update values */
 366     if ((pdcattr->flXform & PAGE_EXTENTS_CHANGED) &&
 367         (pdcattr->iMapMode == MM_ISOTROPIC))
 368     {
 369         /* Call win32k to do the work */
 370         return NtGdiGetDCPoint(hdc, GdiGetViewPortExt, (PPOINTL)lpSize);
 371     }
 372
 373     /* Nothing to calculate, return the current extension */
 374     lpSize->cx = pdcattr->szlViewportExt.cx;
 375     lpSize->cy = pdcattr->szlViewportExt.cy;
 376
 377     return TRUE;
 378 }
 379
 380
 381 BOOL
 382 WINAPI
 383 GetViewportOrgEx(
 384     _In_ HDC hdc,
 385     _Out_ LPPOINT lpPoint)
 386 {
 387     PDC_ATTR pdcattr;
 388
 389     /* Get the DC attribute */
 390     pdcattr = GdiGetDcAttr(hdc);
 391     if (pdcattr == NULL)
 392     {
 393         /* Do not set LastError here! */
 394         return FALSE;
 395     }
 396
 397     /* Get the current viewport org */
 398     lpPoint->x = pdcattr->ptlViewportOrg.x;
 399     lpPoint->y = pdcattr->ptlViewportOrg.y;
 400
 401     /* Handle right-to-left layout */
 402     if (pdcattr->dwLayout & LAYOUT_RTL)
 403         lpPoint->x = -lpPoint->x;
 404
 405     return TRUE;
 406 }
 407
 408
 409 BOOL
 410 WINAPI
 411 GetWindowExtEx(
 412     _In_ HDC hdc,
 413     _Out_ LPSIZE lpSize)
 414 {
 415     PDC_ATTR pdcattr;
 416
 417     /* Get the DC attribute */
 418     pdcattr = GdiGetDcAttr(hdc);
 419     if (pdcattr == NULL)
 420     {
 421         /* Do not set LastError here! */
 422         return FALSE;
 423     }
 424
 425     /* Get the current window extension */
 426     lpSize->cx = pdcattr->szlWindowExt.cx;
 427     lpSize->cy = pdcattr->szlWindowExt.cy;
 428
 429     /* Handle right-to-left layout */
 430     if (pdcattr->dwLayout & LAYOUT_RTL)
 431         lpSize->cx = -lpSize->cx;
 432
 433     return TRUE;
 434 }
 435
 436
 437 BOOL
 438 WINAPI
 439 GetWindowOrgEx(
 440     _In_ HDC hdc,
 441     _Out_ LPPOINT lpPoint)
 442 {
 443     PDC_ATTR pdcattr;
 444
 445     /* Get the DC attribute */
 446     pdcattr = GdiGetDcAttr(hdc);
 447     if (pdcattr == NULL)
 448     {
 449         /* Do not set LastError here! */
 450         return FALSE;
 451     }
 452
 453     /* Get the current window origin */
 454     lpPoint->x = pdcattr->ptlWindowOrg.x;
 455     lpPoint->y = pdcattr->ptlWindowOrg.y;
 456
 457     return TRUE;
 458 }
 459
 460 /*
 461  * @implemented
 462  */
 463 BOOL
 464 WINAPI
 465 SetViewportExtEx(
 466     _In_ HDC hdc,
 467     _In_ int nXExtent,
 468     _In_ int nYExtent,
 469     _Out_opt_ LPSIZE lpSize)
 470 {
 471     PDC_ATTR pdcattr;
 472
 473     HANDLE_METADC(BOOL, SetViewportExtEx, FALSE, hdc, nXExtent, nYExtent, lpSize);
 474
 475     /* Get the DC attribute */
 476     pdcattr = GdiGetDcAttr(hdc);
 477     if (pdcattr == NULL)
 478     {
 479         SetLastError(ERROR_INVALID_PARAMETER);
 480         return FALSE;
 481     }
 482
 483     /* Check if the caller wants the old extension */
 484     if (lpSize)
 485     {
 486         /* Return the current viewport extension */
 487         lpSize->cx = pdcattr->szlViewportExt.cx;
 488         lpSize->cy = pdcattr->szlViewportExt.cy;
 489     }
 490
 491     /* Check for trivial case */
 492     if ((pdcattr->szlViewportExt.cx == nXExtent) &&
 493         (pdcattr->szlViewportExt.cy == nYExtent))
 494         return TRUE;
 495
 496     if (nXExtent == 0 || nYExtent == 0)
 497         return TRUE;
 498
 499     /* Only change viewport extension if we are in iso or aniso mode */
 500     if ((pdcattr->iMapMode == MM_ISOTROPIC) ||
 501         (pdcattr->iMapMode == MM_ANISOTROPIC))
 502     {
 503         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 504         {
 505             if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 506             {
 507                 NtGdiFlush(); // Sync up pdcattr from Kernel space.
 508                 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 509             }
 510         }
 511
 512         /* Set the new viewport extension */
 513         pdcattr->szlViewportExt.cx = nXExtent;
 514         pdcattr->szlViewportExt.cy = nYExtent;
 515
 516         /* Handle right-to-left layout */
 517         if (pdcattr->dwLayout & LAYOUT_RTL)
 518             NtGdiMirrorWindowOrg(hdc);
 519
 520         /* Update xform flags */
 521         pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 522     }
 523
 524     return TRUE;
 525 }
 526
 527 /*
 528  * @implemented
 529  */
 530 BOOL
 531 WINAPI
 532 SetWindowOrgEx(
 533     _In_ HDC hdc,
 534     _In_ int X,
 535     _In_ int Y,
 536     _Out_opt_ LPPOINT lpPoint)
 537 {
 538     PDC_ATTR pdcattr;
 539
 540     HANDLE_METADC(BOOL, SetWindowOrgEx, FALSE, hdc, X, Y, lpPoint);
 541
 542     /* Get the DC attribute */
 543     pdcattr = GdiGetDcAttr(hdc);
 544     if (pdcattr == NULL)
 545     {
 546         /* Do not set LastError here! */
 547         return FALSE;
 548     }
 549
 550     if (lpPoint)
 551     {
 552         lpPoint->x = pdcattr->ptlWindowOrg.x;
 553         lpPoint->y = pdcattr->ptlWindowOrg.y;
 554     }
 555
 556     if ((pdcattr->ptlWindowOrg.x == X) && (pdcattr->ptlWindowOrg.y == Y))
 557         return TRUE;
 558
 559     if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 560     {
 561         if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 562         {
 563             NtGdiFlush(); // Sync up pdcattr from Kernel space.
 564             pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 565         }
 566     }
 567
 568     pdcattr->ptlWindowOrg.x = X;
 569     pdcattr->ptlWindowOrg.y = Y;
 570
 571     pdcattr->lWindowOrgx    = X;
 572     if (pdcattr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc);
 573     pdcattr->flXform |= (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
 574     return TRUE;
 575
 576 //    return NtGdiSetWindowOrgEx(hdc, X, Y, lpPoint);
 577 }
 578
 579 /*
 580  * @implemented
 581  */
 582 BOOL
 583 WINAPI
 584 SetWindowExtEx(
 585     _In_ HDC hdc,
 586     _In_ INT nXExtent,
 587     _In_ INT nYExtent,
 588     _Out_opt_ LPSIZE lpSize)
 589 {
 590     PDC_ATTR pdcattr;
 591
 592     HANDLE_METADC(BOOL, SetWindowExtEx, FALSE, hdc, nXExtent, nYExtent, lpSize);
 593
 594     /* Get the DC attr */
 595     pdcattr = GdiGetDcAttr(hdc);
 596     if (!pdcattr)
 597     {
 598         /* Set the error value and return failure */
 599         SetLastError(ERROR_INVALID_PARAMETER);
 600         return FALSE;
 601     }
 602
 603     /* Check if the caller wants the old extension */
 604     if (lpSize)
 605     {
 606         /* Return the current window extension */
 607         lpSize->cx = pdcattr->szlWindowExt.cx;
 608         lpSize->cy = pdcattr->szlWindowExt.cy;
 609
 610         /* Handle right-to-left layout */
 611         if (pdcattr->dwLayout & LAYOUT_RTL)
 612             lpSize->cx = -lpSize->cx;
 613     }
 614
 615     if (pdcattr->dwLayout & LAYOUT_RTL)
 616     {
 617         NtGdiMirrorWindowOrg(hdc);
 618         pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 619     }
 620     else if ((pdcattr->iMapMode == MM_ISOTROPIC) ||
 621              (pdcattr->iMapMode == MM_ANISOTROPIC))
 622     {
 623         if ((pdcattr->szlWindowExt.cx == nXExtent) &&
 624             (pdcattr->szlWindowExt.cy == nYExtent))
 625             return TRUE;
 626
 627         if ((!nXExtent) || (!nYExtent))
 628             return FALSE;
 629
 630         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 631         {
 632             if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 633             {
 634                 NtGdiFlush(); // Sync up Dc_Attr from Kernel space.
 635                 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 636             }
 637         }
 638
 639         pdcattr->szlWindowExt.cx = nXExtent;
 640         pdcattr->szlWindowExt.cy = nYExtent;
 641         if (pdcattr->dwLayout & LAYOUT_RTL)
 642             NtGdiMirrorWindowOrg(hdc);
 643
 644         pdcattr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 645     }
 646
 647     return TRUE;
 648 }
 649
 650 /*
 651  * @implemented
 652  */
 653 BOOL
 654 WINAPI
 655 SetViewportOrgEx(
 656     _In_ HDC hdc,
 657     _In_ int X,
 658     _In_ int Y,
 659     _Out_opt_ LPPOINT lpPoint)
 660 {
 661     PDC_ATTR pdcattr;
 662
 663     HANDLE_METADC(BOOL, SetViewportOrgEx, FALSE, hdc, X, Y, lpPoint);
 664
 665     /* Get the DC attribute */
 666     pdcattr = GdiGetDcAttr(hdc);
 667     if (!pdcattr)
 668     {
 669         /* Do not set LastError here! */
 670         return FALSE;
 671     }
 672     //// HACK : XP+ doesn't do this. See CORE-16656 & CORE-16644.
 673     if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 674     {
 675         if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 676         {
 677             NtGdiFlush();
 678             pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 679         }
 680     }
 681     ////
 682     if (lpPoint)
 683     {
 684         lpPoint->x = pdcattr->ptlViewportOrg.x;
 685         lpPoint->y = pdcattr->ptlViewportOrg.y;
 686         if (pdcattr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
 687     }
 688     pdcattr->flXform |= (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
 689     if (pdcattr->dwLayout & LAYOUT_RTL) X = -X;
 690     pdcattr->ptlViewportOrg.x = X;
 691     pdcattr->ptlViewportOrg.y = Y;
 692     return TRUE;
 693
 694 //    return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint);
 695 }
 696
 697 /*
 698  * @implemented
 699  */
 700 BOOL
 701 WINAPI
 702 ScaleViewportExtEx(
 703     _In_ HDC hdc,
 704     _In_ INT xNum,
 705     _In_ INT xDenom,
 706     _In_ INT yNum,
 707     _In_ INT yDenom,
 708     _Out_ LPSIZE lpSize)
 709 {
 710     HANDLE_METADC(BOOL, ScaleViewportExtEx, FALSE, hdc, xNum, xDenom, yNum, yDenom, lpSize);
 711
 712     if (!GdiGetDcAttr(hdc))
 713     {
 714         SetLastError(ERROR_INVALID_PARAMETER);
 715         return FALSE;
 716     }
 717
 718     return NtGdiScaleViewportExtEx(hdc, xNum, xDenom, yNum, yDenom, lpSize);
 719 }
 720
 721 /*
 722  * @implemented
 723  */
 724 BOOL
 725 WINAPI
 726 ScaleWindowExtEx(
 727     _In_ HDC hdc,
 728     _In_ INT xNum,
 729     _In_ INT xDenom,
 730     _In_ INT yNum,
 731     _In_ INT yDenom,
 732     _Out_ LPSIZE lpSize)
 733 {
 734     HANDLE_METADC(BOOL, ScaleWindowExtEx, FALSE, hdc, xNum, xDenom, yNum, yDenom, lpSize);
 735
 736     if (!GdiGetDcAttr(hdc))
 737     {
 738         SetLastError(ERROR_INVALID_PARAMETER);
 739         return FALSE;
 740     }
 741
 742     return NtGdiScaleWindowExtEx(hdc, xNum, xDenom, yNum, yDenom, lpSize);
 743 }
 744
 745 /*
 746  * @implemented
 747  */
 748 DWORD
 749 WINAPI
 750 GetLayout(
 751     _In_ HDC hdc)
 752 {
 753     PDC_ATTR pdcattr;
 754
 755     /* METADC16 is not supported in this API */
 756     if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE)
 757     {
 758         return GDI_ERROR;
 759     }
 760
 761     /* Get the DC attribute */
 762     pdcattr = GdiGetDcAttr(hdc);
 763     if (!pdcattr)
 764     {
 765         /* Set the error value and return failure */
 766         SetLastError(ERROR_INVALID_PARAMETER);
 767         return GDI_ERROR;
 768     }
 769
 770     /* Return the layout */
 771     return pdcattr->dwLayout;
 772 }
 773
 774
 775 /*
 776  * @implemented
 777  */
 778 DWORD
 779 WINAPI
 780 SetLayout(
 781     _In_ HDC hdc,
 782     _In_ DWORD dwLayout)
 783 {
 784     HANDLE_METADC(DWORD, SetLayout, GDI_ERROR, hdc, dwLayout);
 785
 786     if (!GdiGetDcAttr(hdc))
 787     {
 788         SetLastError(ERROR_INVALID_PARAMETER);
 789         return GDI_ERROR;
 790     }
 791
 792     return NtGdiSetLayout(hdc, -1, dwLayout);
 793 }
 794
 795 /*
 796  * @implemented
 797  */
 798 DWORD
 799 WINAPI
 800 SetLayoutWidth(
 801     _In_ HDC hdc,
 802     _In_ LONG wox,
 803     _In_ DWORD dwLayout)
 804 {
 805     /* Only normal DCs are handled here */
 806     if (GDI_HANDLE_GET_TYPE(hdc) != GDILoObjType_LO_DC_TYPE)
 807     {
 808         return GDI_ERROR;
 809     }
 810
 811     if (!GdiGetDcAttr(hdc))
 812     {
 813         SetLastError(ERROR_INVALID_PARAMETER);
 814         return GDI_ERROR;
 815     }
 816
 817     return NtGdiSetLayout(hdc, wox, dwLayout);
 818 }
 819
 820 /*
 821  * @implemented
 822  */
 823 BOOL
 824 WINAPI
 825 GetDCOrgEx(
 826     _In_ HDC hdc,
 827     _Out_ LPPOINT lpPoint)
 828 {
 829     return NtGdiGetDCPoint(hdc, GdiGetDCOrg, (PPOINTL)lpPoint);
 830 }
 831
 832
 833 /*
 834  * @implemented
 835  */
 836 LONG
 837 WINAPI
 838 GetDCOrg(
 839     _In_ HDC hdc)
 840 {
 841     POINT pt;
 842
 843     /* Call the new API */
 844     if (!GetDCOrgEx(hdc, &pt))
 845         return 0;
 846
 847     /* Return the point in the old way */
 848     return(MAKELONG(pt.x, pt.y));
 849 }
 850
 851
 852 /*
 853  * @implemented
 854  *
 855  */
 856 BOOL
 857 WINAPI
 858 OffsetViewportOrgEx(
 859     _In_ HDC hdc,
 860     _In_ int nXOffset,
 861     _In_ int nYOffset,
 862     _Out_opt_ LPPOINT lpPoint)
 863 {
 864     PDC_ATTR pdcattr;
 865
 866     HANDLE_METADC(BOOL, OffsetViewportOrgEx, FALSE, hdc, nXOffset, nYOffset, lpPoint);
 867
 868     /* Get the DC attribute */
 869     pdcattr = GdiGetDcAttr(hdc);
 870     if (!pdcattr)
 871     {
 872         /* Do not set LastError here! */
 873         return FALSE;
 874     }
 875
 876     if (lpPoint)
 877     {
 878         *lpPoint = pdcattr->ptlViewportOrg;
 879         if ( pdcattr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
 880     }
 881
 882     if ( nXOffset || nYOffset != nXOffset )
 883     {
 884         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 885         {
 886             if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 887             {
 888                 NtGdiFlush();
 889                 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 890             }
 891         }
 892
 893         pdcattr->flXform |= (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
 894         if (pdcattr->dwLayout & LAYOUT_RTL) nXOffset = -nXOffset;
 895         pdcattr->ptlViewportOrg.x += nXOffset;
 896         pdcattr->ptlViewportOrg.y += nYOffset;
 897     }
 898     return TRUE;
 899
 900 //    return  NtGdiOffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 901 }
 902
 903 /*
 904  * @implemented
 905  *
 906  */
 907 BOOL
 908 WINAPI
 909 OffsetWindowOrgEx(
 910     _In_ HDC hdc,
 911     _In_ int nXOffset,
 912     _In_ int nYOffset,
 913     _Out_opt_ LPPOINT lpPoint)
 914 {
 915     PDC_ATTR pdcattr;
 916
 917     HANDLE_METADC(BOOL, OffsetWindowOrgEx, FALSE, hdc, nXOffset, nYOffset, lpPoint);
 918
 919     /* Get the DC attribute */
 920     pdcattr = GdiGetDcAttr(hdc);
 921     if (!pdcattr)
 922     {
 923         /* Do not set LastError here! */
 924         return FALSE;
 925     }
 926
 927     if ( lpPoint )
 928     {
 929         *lpPoint   = pdcattr->ptlWindowOrg;
 930         //lpPoint->x = pdcattr->lWindowOrgx;
 931     }
 932
 933     if ( nXOffset || nYOffset != nXOffset )
 934     {
 935         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 936         {
 937             if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
 938             {
 939                 NtGdiFlush();
 940                 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
 941             }
 942         }
 943
 944         pdcattr->flXform |= (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
 945         pdcattr->ptlWindowOrg.x += nXOffset;
 946         pdcattr->ptlWindowOrg.y += nYOffset;
 947         pdcattr->lWindowOrgx += nXOffset;
 948     }
 949     return TRUE;
 950
 951 //    return NtGdiOffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 952 }
 953