reactos/win32ss/gdi/gdi32/objects/coord.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS System Libraries
   4  * FILE:            dll/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     XFORM *pxform,
  29     PPOINT pptOut,
  30     PPOINT pptIn,
  31     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     MATRIX *pmx,
  49     PPOINT pptOut,
  50     PPOINT pptIn,
  51     ULONG nCount)
  52 {
  53     XFORM xform;
  54
  55     MatrixToXForm(&xform, pmx);
  56     GdiTransformPoints2(&xform, pptOut, pptIn, nCount);
  57 }
  58
  59 #define MAX_OFFSET 4294967040.0
  60
  61 BOOL
  62 WINAPI
  63 CombineTransform(
  64     LPXFORM pxfResult,
  65     const XFORM *pxf1,
  66     const XFORM *pxf2)
  67 {
  68     XFORM xformTmp;
  69
  70     /* Check paramters */
  71     if (!pxfResult || !pxf1 || !pxf2) return FALSE;
  72
  73     /* Do matrix multiplication */
  74     xformTmp.eM11 = pxf1->eM11 * pxf2->eM11 + pxf1->eM12 * pxf2->eM21;
  75     xformTmp.eM12 = pxf1->eM11 * pxf2->eM12 + pxf1->eM12 * pxf2->eM22;
  76     xformTmp.eM21 = pxf1->eM21 * pxf2->eM11 + pxf1->eM22 * pxf2->eM21;
  77     xformTmp.eM22 = pxf1->eM21 * pxf2->eM12 + pxf1->eM22 * pxf2->eM22;
  78     xformTmp.eDx = pxf1->eDx * pxf2->eM11 + pxf1->eDy * pxf2->eM21 + pxf2->eDx;
  79     xformTmp.eDy = pxf1->eDx * pxf2->eM12 + pxf1->eDy * pxf2->eM22 + pxf2->eDy;
  80
  81     *pxfResult = xformTmp;
  82 #if 0
  83     /* windows compatibility fixups (needs more work) */
  84     if (_isnan(xformTmp.eM12))
  85     {
  86         if (pxf1->eM11 == 0 || pxf2->eM12 == 0) pxfResult->eM12 = 0.;
  87     }
  88 #endif
  89     /* Check for invalid offset ranges */
  90     if (xformTmp.eDx > MAX_OFFSET || xformTmp.eDx < -MAX_OFFSET ||
  91         xformTmp.eDy > MAX_OFFSET || xformTmp.eDy < -MAX_OFFSET)
  92     {
  93         return FALSE;
  94     }
  95
  96     return TRUE;
  97 }
  98
  99 BOOL
 100 WINAPI
 101 DPtoLP(HDC hdc, LPPOINT lpPoints, INT nCount)
 102 {
 103 #if 0
 104     INT i;
 105     PDC_ATTR pdcattr;
 106
 107     pdcattr = GdiGetDcAttr(hdc);
 108     if (!pdcattr)
 109     {
 110         SetLastError(ERROR_INVALID_HANDLE);
 111         return FALSE;
 112     }
 113
 114     if (pdcattr->flXform & ANY_XFORM_CHANGES)
 115     {
 116         GdiFixupTransforms(pdcattr);
 117     }
 118
 119     // FIXME: can this fail on Windows?
 120     GdiTransformPoints(&pdcattr->mxDeviceToWorld, lpPoints, lpPoints, nCount);
 121
 122     return TRUE;
 123 #endif
 124     return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiDpToLp);
 125 }
 126
 127 BOOL
 128 WINAPI
 129 LPtoDP(HDC hdc, LPPOINT lpPoints, INT nCount)
 130 {
 131 #if 0
 132     INT i;
 133     PDC_ATTR pdcattr;
 134
 135     pdcattr = GdiGetDcAttr(hdc);
 136     if (!pdcattr)
 137     {
 138         SetLastError(ERROR_INVALID_HANDLE);
 139         return FALSE;
 140     }
 141
 142     if (pdcattr->flXform & ANY_XFORM_CHANGES)
 143     {
 144         GdiFixupTransforms(pdcattr);
 145     }
 146
 147     // FIXME: can this fail on Windows?
 148     GdiTransformPoints(&pdcattr->mxWorldToDevice, lpPoints, lpPoints, nCount);
 149
 150     return TRUE;
 151 #endif
 152     return NtGdiTransformPoints(hdc, lpPoints, lpPoints, nCount, GdiLpToDp);
 153 }
 154
 155 /*
 156  * @implemented
 157  *
 158  */
 159 BOOL
 160 WINAPI
 161 GetCurrentPositionEx(HDC hdc,
 162                      LPPOINT lpPoint)
 163 {
 164     PDC_ATTR Dc_Attr;
 165
 166     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 167
 168     if ( lpPoint )
 169     {
 170         if ( Dc_Attr->ulDirty_ & DIRTY_PTLCURRENT ) // have a hit!
 171         {
 172             lpPoint->x = Dc_Attr->ptfxCurrent.x;
 173             lpPoint->y = Dc_Attr->ptfxCurrent.y;
 174             DPtoLP ( hdc, lpPoint, 1);          // reconvert back.
 175             Dc_Attr->ptlCurrent.x = lpPoint->x; // save it
 176             Dc_Attr->ptlCurrent.y = lpPoint->y;
 177             Dc_Attr->ulDirty_ &= ~DIRTY_PTLCURRENT; // clear bit
 178         }
 179         else
 180         {
 181             lpPoint->x = Dc_Attr->ptlCurrent.x;
 182             lpPoint->y = Dc_Attr->ptlCurrent.y;
 183         }
 184     }
 185     else
 186     {
 187         SetLastError(ERROR_INVALID_PARAMETER);
 188         return FALSE;
 189     }
 190     return TRUE;
 191 }
 192
 193 /*
 194  * @implemented
 195  */
 196 BOOL
 197 WINAPI
 198 GetWorldTransform(HDC hDC, LPXFORM lpXform)
 199 {
 200 #if 0
 201     PDC_ATTR pdcattr;
 202
 203     pdcattr = GdiGetDcAttr(hdc);
 204     if (!pdcattr)
 205     {
 206         SetLastError(ERROR_INVALID_HANDLE);
 207         return FALSE;
 208     }
 209
 210     if (pdcattr->flXform & ANY_XFORM_INVALID)
 211     {
 212         GdiFixupTransforms(pdcattr);
 213     }
 214
 215     MatrixToXForm(lpXform, &pdcattr->mxWorldToDevice);
 216 #endif
 217     return NtGdiGetTransform(hDC, GdiWorldSpaceToPageSpace, lpXform);
 218 }
 219
 220
 221 BOOL
 222 WINAPI
 223 SetWorldTransform( HDC hDC, CONST XFORM *Xform )
 224 {
 225     /* FIXME  shall we add undoc #define MWT_SETXFORM 4 ?? */
 226     return ModifyWorldTransform( hDC, Xform, MWT_MAX+1);
 227 }
 228
 229
 230 BOOL
 231 WINAPI
 232 ModifyWorldTransform(
 233     HDC hDC,
 234     CONST XFORM *Xform,
 235     DWORD iMode
 236 )
 237 {
 238 #if 0
 239 // Handle something other than a normal dc object.
 240     if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
 241     {
 242         if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
 243             return FALSE;
 244         else
 245         {
 246             PLDC pLDC = GdiGetLDC(hDC);
 247             if ( !pLDC )
 248             {
 249                 SetLastError(ERROR_INVALID_HANDLE);
 250                 return FALSE;
 251             }
 252             if (pLDC->iType == LDC_EMFLDC)
 253             {
 254                 if (iMode ==  MWT_MAX+1)
 255                     if (!EMFDRV_SetWorldTransform( hDC, Xform) ) return FALSE;
 256                 return EMFDRV_ModifyWorldTransform( hDC, Xform, iMode); // Ported from wine.
 257             }
 258             return FALSE;
 259         }
 260     }
 261 #endif
 262     PDC_ATTR Dc_Attr;
 263
 264     if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 265
 266     /* Check that graphics mode is GM_ADVANCED */
 267     if ( Dc_Attr->iGraphicsMode != GM_ADVANCED ) return FALSE;
 268
 269     return NtGdiModifyWorldTransform(hDC, (CONST LPXFORM) Xform, iMode);
 270 }
 271
 272 BOOL
 273 WINAPI
 274 GetViewportExtEx(
 275     HDC hdc,
 276     LPSIZE lpSize
 277 )
 278 {
 279     PDC_ATTR Dc_Attr;
 280
 281     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 282
 283     if ((Dc_Attr->flXform & PAGE_EXTENTS_CHANGED) && (Dc_Attr->iMapMode == MM_ISOTROPIC))
 284         // Something was updated, go to kernel.
 285         return NtGdiGetDCPoint( hdc, GdiGetViewPortExt, (PPOINTL) lpSize );
 286     else
 287     {
 288         lpSize->cx = Dc_Attr->szlViewportExt.cx;
 289         lpSize->cy = Dc_Attr->szlViewportExt.cy;
 290     }
 291     return TRUE;
 292 }
 293
 294
 295 BOOL
 296 WINAPI
 297 GetViewportOrgEx(
 298     HDC hdc,
 299     LPPOINT lpPoint
 300 )
 301 {
 302     PDC_ATTR Dc_Attr;
 303
 304     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 305     lpPoint->x = Dc_Attr->ptlViewportOrg.x;
 306     lpPoint->y = Dc_Attr->ptlViewportOrg.y;
 307     if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
 308     return TRUE;
 309     // return NtGdiGetDCPoint( hdc, GdiGetViewPortOrg, lpPoint );
 310 }
 311
 312
 313 BOOL
 314 WINAPI
 315 GetWindowExtEx(
 316     HDC hdc,
 317     LPSIZE lpSize
 318 )
 319 {
 320     PDC_ATTR Dc_Attr;
 321
 322     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 323     lpSize->cx = Dc_Attr->szlWindowExt.cx;
 324     lpSize->cy = Dc_Attr->szlWindowExt.cy;
 325     if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx;
 326     return TRUE;
 327     // return NtGdiGetDCPoint( hdc, GdiGetWindowExt, (LPPOINT) lpSize );
 328 }
 329
 330
 331 BOOL
 332 WINAPI
 333 GetWindowOrgEx(
 334     HDC hdc,
 335     LPPOINT lpPoint
 336 )
 337 {
 338     PDC_ATTR Dc_Attr;
 339
 340     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 341     lpPoint->x = Dc_Attr->ptlWindowOrg.x;
 342     lpPoint->y = Dc_Attr->ptlWindowOrg.y;
 343     return TRUE;
 344     //return NtGdiGetDCPoint( hdc, GdiGetWindowOrg, lpPoint );
 345 }
 346
 347 /*
 348  * @unimplemented
 349  */
 350 BOOL
 351 WINAPI
 352 SetViewportExtEx(HDC hdc,
 353                  int nXExtent,
 354                  int nYExtent,
 355                  LPSIZE lpSize)
 356 {
 357     PDC_ATTR Dc_Attr;
 358 #if 0
 359     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 360     {
 361         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 362             return MFDRV_SetViewportExtEx();
 363         else
 364         {
 365             PLDC pLDC = GdiGetLDC(hdc);
 366             if ( !pLDC )
 367             {
 368                 SetLastError(ERROR_INVALID_HANDLE);
 369                 return FALSE;
 370             }
 371             if (pLDC->iType == LDC_EMFLDC)
 372             {
 373                 return EMFDRV_SetViewportExtEx();
 374             }
 375         }
 376     }
 377 #endif
 378     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr))
 379     {
 380         return FALSE;
 381     }
 382
 383     if (lpSize)
 384     {
 385         lpSize->cx = Dc_Attr->szlViewportExt.cx;
 386         lpSize->cy = Dc_Attr->szlViewportExt.cy;
 387     }
 388
 389     if ((Dc_Attr->szlViewportExt.cx == nXExtent) && (Dc_Attr->szlViewportExt.cy == nYExtent))
 390         return TRUE;
 391
 392     if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC))
 393     {
 394         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 395         {
 396             if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
 397             {
 398                 NtGdiFlush(); // Sync up Dc_Attr from Kernel space.
 399                 Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
 400             }
 401         }
 402         Dc_Attr->szlViewportExt.cx = nXExtent;
 403         Dc_Attr->szlViewportExt.cy = nYExtent;
 404         if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc);
 405         Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 406     }
 407     return TRUE;
 408 }
 409
 410 /*
 411  * @unimplemented
 412  */
 413 BOOL
 414 WINAPI
 415 SetWindowOrgEx(HDC hdc,
 416                int X,
 417                int Y,
 418                LPPOINT lpPoint)
 419 {
 420 #if 0
 421     PDC_ATTR Dc_Attr;
 422 #if 0
 423     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 424     {
 425         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 426             return MFDRV_SetWindowOrgEx();
 427         else
 428         {
 429             PLDC pLDC = GdiGetLDC(hdc);
 430             if ( !pLDC )
 431             {
 432                 SetLastError(ERROR_INVALID_HANDLE);
 433                 return FALSE;
 434             }
 435             if (pLDC->iType == LDC_EMFLDC)
 436             {
 437                 return EMFDRV_SetWindowOrgEx();
 438             }
 439         }
 440     }
 441 #endif
 442     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 443
 444     if (lpPoint)
 445     {
 446         lpPoint->x = Dc_Attr->ptlWindowOrg.x;
 447         lpPoint->y = Dc_Attr->ptlWindowOrg.y;
 448     }
 449
 450     if ((Dc_Attr->ptlWindowOrg.x == X) && (Dc_Attr->ptlWindowOrg.y == Y))
 451         return TRUE;
 452
 453     if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
 454     {
 455         if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
 456         {
 457             NtGdiFlush(); // Sync up Dc_Attr from Kernel space.
 458             Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
 459         }
 460     }
 461
 462     Dc_Attr->ptlWindowOrg.x = X;
 463     Dc_Attr->lWindowOrgx    = X;
 464     Dc_Attr->ptlWindowOrg.y = Y;
 465     if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc);
 466     Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
 467     return TRUE;
 468 #endif
 469     return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint);
 470 }
 471
 472 /*
 473  * @unimplemented
 474  */
 475 BOOL
 476 WINAPI
 477 SetWindowExtEx(HDC hdc,
 478                int nXExtent,
 479                int nYExtent,
 480                LPSIZE lpSize)
 481 {
 482     PDC_ATTR Dc_Attr;
 483 #if 0
 484     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 485     {
 486         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 487             return MFDRV_SetWindowExtEx();
 488         else
 489         {
 490             PLDC pLDC = GdiGetLDC(hdc);
 491             if ( !pLDC )
 492             {
 493                 SetLastError(ERROR_INVALID_HANDLE);
 494                 return FALSE;
 495             }
 496             if (pLDC->iType == LDC_EMFLDC)
 497             {
 498                 return EMFDRV_SetWindowExtEx();
 499             }
 500         }
 501     }
 502 #endif
 503     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 504
 505     if (lpSize)
 506     {
 507         lpSize->cx = Dc_Attr->szlWindowExt.cx;
 508         lpSize->cy = Dc_Attr->szlWindowExt.cy;
 509         if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx;
 510     }
 511
 512     if (Dc_Attr->dwLayout & LAYOUT_RTL)
 513     {
 514         NtGdiMirrorWindowOrg(hdc);
 515         Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 516     }
 517     else if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC))
 518     {
 519         if ((Dc_Attr->szlWindowExt.cx == nXExtent) && (Dc_Attr->szlWindowExt.cy == nYExtent))
 520             return TRUE;
 521
 522         if ((!nXExtent) || (!nYExtent)) return FALSE;
 523
 524         if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
 525         {
 526             if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
 527             {
 528                 NtGdiFlush(); // Sync up Dc_Attr from Kernel space.
 529                 Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
 530             }
 531         }
 532         Dc_Attr->szlWindowExt.cx = nXExtent;
 533         Dc_Attr->szlWindowExt.cy = nYExtent;
 534         if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc);
 535         Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID);
 536     }
 537     return TRUE; // Return TRUE.
 538 }
 539
 540 /*
 541  * @unimplemented
 542  */
 543 BOOL
 544 WINAPI
 545 SetViewportOrgEx(HDC hdc,
 546                  int X,
 547                  int Y,
 548                  LPPOINT lpPoint)
 549 {
 550 #if 0
 551     PDC_ATTR Dc_Attr;
 552 #if 0
 553     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 554     {
 555         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 556             return MFDRV_SetViewportOrgEx();
 557         else
 558         {
 559             PLDC pLDC = GdiGetLDC(hdc);
 560             if ( !pLDC )
 561             {
 562                 SetLastError(ERROR_INVALID_HANDLE);
 563                 return FALSE;
 564             }
 565             if (pLDC->iType == LDC_EMFLDC)
 566             {
 567                 return EMFDRV_SetViewportOrgEx();
 568             }
 569         }
 570     }
 571 #endif
 572     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 573
 574     if (lpPoint)
 575     {
 576         lpPoint->x = Dc_Attr->ptlViewportOrg.x;
 577         lpPoint->y = Dc_Attr->ptlViewportOrg.y;
 578         if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
 579     }
 580     Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
 581     if (Dc_Attr->dwLayout & LAYOUT_RTL) X = -X;
 582     Dc_Attr->ptlViewportOrg.x = X;
 583     Dc_Attr->ptlViewportOrg.y = Y;
 584     return TRUE;
 585 #endif
 586     return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint);
 587 }
 588
 589 /*
 590  * @implemented
 591  */
 592 BOOL
 593 WINAPI
 594 ScaleViewportExtEx(
 595     HDC a0,
 596     int a1,
 597     int a2,
 598     int a3,
 599     int a4,
 600     LPSIZE      a5
 601 )
 602 {
 603 #if 0
 604     if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)
 605     {
 606         if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC)
 607             return MFDRV_;
 608         else
 609         {
 610             PLDC pLDC = GdiGetLDC(a0);
 611             if ( !pLDC )
 612             {
 613                 SetLastError(ERROR_INVALID_HANDLE);
 614                 return FALSE;
 615             }
 616             if (pLDC->iType == LDC_EMFLDC)
 617             {
 618                 return EMFDRV_;
 619             }
 620         }
 621     }
 622 #endif
 623     if (!GdiIsHandleValid((HGDIOBJ) a0) ||
 624             (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE;
 625
 626     return NtGdiScaleViewportExtEx(a0, a1, a2, a3, a4, a5);
 627 }
 628
 629 /*
 630  * @implemented
 631  */
 632 BOOL
 633 WINAPI
 634 ScaleWindowExtEx(
 635     HDC a0,
 636     int a1,
 637     int a2,
 638     int a3,
 639     int a4,
 640     LPSIZE      a5
 641 )
 642 {
 643 #if 0
 644     if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)
 645     {
 646         if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC)
 647             return MFDRV_;
 648         else
 649         {
 650             PLDC pLDC = GdiGetLDC(a0);
 651             if ( !pLDC )
 652             {
 653                 SetLastError(ERROR_INVALID_HANDLE);
 654                 return FALSE;
 655             }
 656             if (pLDC->iType == LDC_EMFLDC)
 657             {
 658                 return EMFDRV_;
 659             }
 660         }
 661     }
 662 #endif
 663     if (!GdiIsHandleValid((HGDIOBJ) a0) ||
 664             (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE;
 665
 666     return NtGdiScaleWindowExtEx(a0, a1, a2, a3, a4, a5);
 667 }
 668
 669 /*
 670  * @implemented
 671  */
 672 DWORD
 673 WINAPI
 674 GetLayout(HDC hdc
 675          )
 676 {
 677     PDC_ATTR Dc_Attr;
 678     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR;
 679     return Dc_Attr->dwLayout;
 680 }
 681
 682
 683 /*
 684  * @implemented
 685  */
 686 DWORD
 687 WINAPI
 688 SetLayout(HDC hdc,
 689           DWORD dwLayout)
 690 {
 691 #if 0
 692     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 693     {
 694         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 695             return MFDRV_SetLayout( hdc, dwLayout);
 696         else
 697         {
 698             PLDC pLDC = GdiGetLDC(hdc);
 699             if ( !pLDC )
 700             {
 701                 SetLastError(ERROR_INVALID_HANDLE);
 702                 return 0;
 703             }
 704             if (pLDC->iType == LDC_EMFLDC)
 705             {
 706                 return EMFDRV_SetLayout( hdc, dwLayout);
 707             }
 708         }
 709     }
 710 #endif
 711     if (!GdiIsHandleValid((HGDIOBJ) hdc) ||
 712             (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR;
 713     return NtGdiSetLayout( hdc, -1, dwLayout);
 714 }
 715
 716 /*
 717  * @implemented
 718  */
 719 DWORD
 720 WINAPI
 721 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
 722 {
 723     if (!GdiIsHandleValid((HGDIOBJ) hdc) ||
 724             (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR;
 725     return NtGdiSetLayout( hdc, wox, dwLayout);
 726 }
 727
 728 /*
 729  * @implemented
 730  *
 731  */
 732 BOOL
 733 WINAPI
 734 OffsetViewportOrgEx(HDC hdc,
 735                     int nXOffset,
 736                     int nYOffset,
 737                     LPPOINT lpPoint)
 738 {
 739 #if 0
 740     PDC_ATTR Dc_Attr;
 741 #if 0
 742     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 743     {
 744         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 745             return MFDRV_OffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 746         else
 747         {
 748             PLDC pLDC = GdiGetLDC(hdc);
 749             if ( !pLDC )
 750             {
 751                 SetLastError(ERROR_INVALID_HANDLE);
 752                 return FALSE;
 753             }
 754             if (pLDC->iType == LDC_EMFLDC)
 755             {
 756                 return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 757             }
 758         }
 759     }
 760 #endif
 761     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 762
 763     if ( lpPoint )
 764     {
 765         *lpPoint = (POINT)Dc_Attr->ptlViewportOrg;
 766         if ( Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x;
 767     }
 768
 769     if ( nXOffset || nYOffset != nXOffset )
 770     {
 771         if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
 772         {
 773             if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY)
 774             {
 775                 NtGdiFlush();
 776                 Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY;
 777             }
 778         }
 779         Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
 780         if ( Dc_Attr->dwLayout & LAYOUT_RTL) nXOffset = -nXOffset;
 781         Dc_Attr->ptlViewportOrg.x += nXOffset;
 782         Dc_Attr->ptlViewportOrg.y += nYOffset;
 783     }
 784     return TRUE;
 785 #endif
 786     return  NtGdiOffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 787 }
 788
 789 /*
 790  * @implemented
 791  *
 792  */
 793 BOOL
 794 WINAPI
 795 OffsetWindowOrgEx(HDC hdc,
 796                   int nXOffset,
 797                   int nYOffset,
 798                   LPPOINT lpPoint)
 799 {
 800 #if 0
 801     PDC_ATTR Dc_Attr;
 802 #if 0
 803     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 804     {
 805         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 806             return MFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 807         else
 808         {
 809             PLDC pLDC = GdiGetLDC(hdc);
 810             if ( !pLDC )
 811             {
 812                 SetLastError(ERROR_INVALID_HANDLE);
 813                 return FALSE;
 814             }
 815             if (pLDC->iType == LDC_EMFLDC)
 816             {
 817                 return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 818             }
 819         }
 820     }
 821 #endif
 822     if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
 823
 824     if ( lpPoint )
 825     {
 826         *lpPoint   = (POINT)Dc_Attr->ptlWindowOrg;
 827         lpPoint->x = Dc_Attr->lWindowOrgx;
 828     }
 829
 830     if ( nXOffset || nYOffset != nXOffset )
 831     {
 832         if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc)
 833         {
 834             if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY)
 835             {
 836                 NtGdiFlush();
 837                 Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY;
 838             }
 839         }
 840         Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID);
 841         Dc_Attr->ptlWindowOrg.x += nXOffset;
 842         Dc_Attr->ptlWindowOrg.y += nYOffset;
 843         Dc_Attr->lWindowOrgx += nXOffset;
 844     }
 845     return TRUE;
 846 #endif
 847     return NtGdiOffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 848 }
 849