reactos/lib/gdi32/objects/dc.c

   1 #include "precomp.h"
   2 #include <win32k/kapi.h>
   3 #include <rosrtl/logfont.h>
   4
   5 #define NDEBUG
   6 #include <debug.h>
   7
   8 #define NtUserGetDCBrushColor(hbr) \
   9   (COLORREF)NtUserCallTwoParam((DWORD)(hbr), OBJ_BRUSH, TWOPARAM_ROUTINE_GETDCCOLOR)
  10
  11 #define NtUserGetDCPenColor(hbr) \
  12   (COLORREF)NtUserCallTwoParam((DWORD)(hbr), OBJ_PEN, TWOPARAM_ROUTINE_GETDCCOLOR)
  13
  14 #define NtUserSetDCBrushColor(hbr, crColor) \
  15   (COLORREF)NtUserCallTwoParam((DWORD)(hbr), (DWORD)crColor, TWOPARAM_ROUTINE_SETDCBRUSHCOLOR)
  16
  17 #define NtUserSetDCPenColor(hbr, crColor) \
  18   (COLORREF)NtUserCallTwoParam((DWORD)(hbr), (DWORD)crColor, TWOPARAM_ROUTINE_SETDCPENCOLOR)
  19
  20 /*
  21  * @implemented
  22  */
  23 DWORD
  24 STDCALL
  25 GetObjectType(
  26         HGDIOBJ         h
  27         )
  28 {
  29   return NtGdiGetObjectType(h);
  30 }
  31
  32
  33
  34 /*
  35  * @implemented
  36  */
  37 BOOL
  38 STDCALL
  39 DPtoLP(
  40         HDC     hdc,
  41         LPPOINT lpPoints,
  42         int     nCount
  43         )
  44 {
  45   return NtGdiDPtoLP(hdc, lpPoints, nCount);
  46 }
  47
  48
  49 /*
  50  * @implemented
  51  */
  52 COLORREF
  53 STDCALL
  54 SetBkColor(
  55         HDC             hdc,
  56         COLORREF        crColor
  57         )
  58 {
  59   return NtGdiSetBkColor(hdc, crColor);
  60 }
  61
  62
  63 /*
  64  * @implemented
  65  */
  66 int
  67 STDCALL
  68 GetGraphicsMode(
  69         HDC     hdc
  70         )
  71 {
  72   return NtGdiGetGraphicsMode(hdc);
  73 }
  74
  75
  76 /*
  77  * @implemented
  78  */
  79 int
  80 STDCALL
  81 SetGraphicsMode(
  82         HDC     hdc,
  83         int     iMode
  84         )
  85 {
  86   return NtGdiSetGraphicsMode(hdc, iMode);
  87 }
  88
  89
  90 /*
  91  * @implemented
  92  */
  93 int
  94 STDCALL
  95 GetMapMode(
  96         HDC     hdc
  97         )
  98 {
  99   return NtGdiGetMapMode(hdc);
 100 }
 101
 102 /*
 103  * @implemented
 104  */
 105 BOOL
 106 STDCALL
 107 GetCurrentPositionEx(
 108         HDC     hdc,
 109         LPPOINT lpPoint
 110         )
 111 {
 112   return NtGdiGetCurrentPositionEx(hdc, lpPoint);
 113 }
 114
 115
 116 /*
 117  * @implemented
 118  */
 119 COLORREF
 120 STDCALL
 121 GetBkColor(
 122         HDC     hdc
 123         )
 124 {
 125   return NtGdiGetBkColor(hdc);
 126 }
 127
 128
 129 /*
 130  * @implemented
 131  */
 132 int
 133 STDCALL
 134 GetBkMode(
 135         HDC     hdc
 136         )
 137 {
 138   return NtGdiGetBkMode(hdc);
 139 }
 140
 141 /*
 142  * @implemented
 143  */
 144 BOOL
 145 STDCALL
 146 GetBrushOrgEx(
 147         HDC     hdc,
 148         LPPOINT lppt
 149         )
 150 {
 151   return NtGdiGetBrushOrgEx(hdc, lppt);
 152 }
 153
 154
 155 /*
 156  * @implemented
 157  */
 158 int
 159 STDCALL
 160 GetROP2(
 161         HDC     hdc
 162         )
 163 {
 164   return NtGdiGetROP2(hdc);
 165 }
 166
 167
 168 /*
 169  * @implemented
 170  */
 171 int
 172 STDCALL
 173 GetStretchBltMode(
 174         HDC     hdc
 175         )
 176 {
 177   return NtGdiGetStretchBltMode(hdc);
 178 }
 179
 180
 181
 182 /*
 183  * @implemented
 184  */
 185 UINT
 186 STDCALL
 187 GetTextAlign(
 188         HDC     hdc
 189         )
 190 {
 191   return NtGdiGetTextAlign(hdc);
 192 }
 193
 194
 195 /*
 196  * @implemented
 197  */
 198 COLORREF
 199 STDCALL
 200 GetTextColor(
 201         HDC     hdc
 202         )
 203 {
 204   return NtGdiGetTextColor(hdc);
 205 }
 206
 207
 208 /*
 209  * @implemented
 210  */
 211 BOOL
 212 STDCALL
 213 GetViewportExtEx(
 214         HDC     hdc,
 215         LPSIZE  lpSize
 216         )
 217 {
 218   return NtGdiGetViewportExtEx(hdc, lpSize);
 219 }
 220
 221
 222 /*
 223  * @implemented
 224  */
 225 BOOL
 226 STDCALL
 227 GetViewportOrgEx(
 228         HDC             hdc,
 229         LPPOINT         lpPoint
 230         )
 231 {
 232   return NtGdiGetViewportOrgEx(hdc, lpPoint);
 233 }
 234
 235
 236 /*
 237  * @implemented
 238  */
 239 BOOL
 240 STDCALL
 241 GetWindowExtEx(
 242         HDC             hdc,
 243         LPSIZE          lpSize
 244         )
 245 {
 246   return NtGdiGetWindowExtEx(hdc, lpSize);
 247 }
 248
 249
 250 /*
 251  * @implemented
 252  */
 253 BOOL
 254 STDCALL
 255 GetWindowOrgEx(
 256         HDC             hdc,
 257         LPPOINT         lpPoint
 258         )
 259 {
 260   return NtGdiGetWindowOrgEx(hdc, lpPoint);
 261 }
 262
 263
 264 /*
 265  * @implemented
 266  */
 267 int
 268 STDCALL
 269 SetBkMode(
 270         HDC     hdc,
 271         int     iBkMode
 272         )
 273 {
 274   return NtGdiSetBkMode(hdc, iBkMode);
 275 }
 276
 277
 278 /*
 279  * @implemented
 280  */
 281 int
 282 STDCALL
 283 SetROP2(
 284         HDC     hdc,
 285         int     fnDrawMode
 286         )
 287 {
 288   return NtGdiSetROP2(hdc, fnDrawMode);
 289 }
 290
 291
 292 /*
 293  * @implemented
 294  */
 295 int
 296 STDCALL
 297 SetStretchBltMode(
 298         HDC     hdc,
 299         int     iStretchMode
 300         )
 301 {
 302   return NtGdiSetStretchBltMode(hdc, iStretchMode);
 303 }
 304
 305
 306 /*
 307  * @implemented
 308  */
 309 DWORD
 310 STDCALL
 311 GetRelAbs(
 312          HDC  hdc,
 313          DWORD dwIgnore
 314            )
 315 {
 316   return NtGdiGetRelAbs(hdc);
 317 }
 318
 319
 320 /*
 321  * @implemented
 322  */
 323 HGDIOBJ STDCALL
 324 GetStockObject(int fnObject)
 325 {
 326   return NtGdiGetStockObject(fnObject);
 327 }
 328
 329
 330 /*
 331  * @implemented
 332  */
 333 int STDCALL
 334 GetClipBox(
 335         HDC hdc,
 336         LPRECT lprc)
 337 {
 338   return NtGdiGetClipBox(hdc, lprc);
 339 }
 340
 341
 342 /*
 343  * @implemented
 344  */
 345 int
 346 STDCALL
 347 GetPolyFillMode(
 348         HDC     hdc
 349         )
 350 {
 351   return NtGdiGetPolyFillMode(hdc);
 352 }
 353
 354
 355 /*
 356  * @implemented
 357  */
 358 HDC
 359 STDCALL
 360 CreateDCA (
 361         LPCSTR          lpszDriver,
 362         LPCSTR          lpszDevice,
 363         LPCSTR          lpszOutput,
 364         CONST DEVMODEA  * lpInitData
 365         )
 366 {
 367         ANSI_STRING DriverA, DeviceA, OutputA;
 368         UNICODE_STRING DriverU, DeviceU, OutputU;
 369         HDC     hDC;
 370         DEVMODEW *lpInitDataW;
 371
 372         /*
 373          * If needed, convert to Unicode
 374          * any string parameter.
 375          */
 376
 377         if (NULL != lpszDriver)
 378         {
 379                 RtlInitAnsiString(&DriverA, (LPSTR)lpszDriver);
 380                 RtlAnsiStringToUnicodeString(&DriverU, &DriverA, TRUE);
 381         } else
 382                 DriverU.Buffer = NULL;
 383         if (NULL != lpszDevice)
 384         {
 385                 RtlInitAnsiString(&DeviceA, (LPSTR)lpszDevice);
 386                 RtlAnsiStringToUnicodeString(&DeviceU, &DeviceA, TRUE);
 387         } else
 388                 DeviceU.Buffer = NULL;
 389         if (NULL != lpszOutput)
 390         {
 391                 RtlInitAnsiString(&OutputA, (LPSTR)lpszOutput);
 392                 RtlAnsiStringToUnicodeString(&OutputU, &OutputA, TRUE);
 393         } else
 394                 OutputU.Buffer = NULL;
 395
 396         if (NULL != lpInitData)
 397         {
 398 //              lpInitDataW = HeapAllocMem(
 399         } else
 400                 lpInitDataW = NULL;
 401
 402         /*
 403          * Call the Unicode version
 404          * of CreateDC.
 405          */
 406
 407         hDC = CreateDCW (
 408                 DriverU.Buffer,
 409                 DeviceU.Buffer,
 410                 OutputU.Buffer,
 411                 NULL);
 412 //              lpInitDataW);
 413         /*
 414          * Free Unicode parameters.
 415          */
 416         RtlFreeUnicodeString(&DriverU);
 417         RtlFreeUnicodeString(&DeviceU);
 418         RtlFreeUnicodeString(&OutputU);
 419
 420         /*
 421          * Return the possible DC handle.
 422          */
 423
 424         return hDC;
 425 }
 426
 427
 428 /*
 429  * @implemented
 430  */
 431 HDC
 432 STDCALL
 433 CreateDCW (
 434         LPCWSTR         lpwszDriver,
 435         LPCWSTR         lpwszDevice,
 436         LPCWSTR         lpwszOutput,
 437         CONST DEVMODEW  * lpInitData
 438         )
 439 {
 440         UNICODE_STRING Driver, Device, Output;
 441
 442         if(lpwszDriver)
 443                 RtlInitUnicodeString(&Driver, lpwszDriver);
 444         if(lpwszDevice)
 445                 RtlInitUnicodeString(&Driver, lpwszDevice);
 446         if(lpwszOutput)
 447                 RtlInitUnicodeString(&Driver, lpwszOutput);
 448
 449         return NtGdiCreateDC((lpwszDriver ? &Driver : NULL),
 450                                                  (lpwszDevice ? &Device : NULL),
 451                                                  (lpwszOutput ? &Output : NULL),
 452                                                  (PDEVMODEW)lpInitData);
 453 }
 454
 455
 456 /*
 457  * @implemented
 458  */
 459 BOOL STDCALL DeleteDC( HDC hdc )
 460 {
 461   return NtGdiDeleteDC(hdc);
 462 }
 463
 464
 465 /*
 466  * @implemented
 467  */
 468 HDC
 469 STDCALL
 470 CreateCompatibleDC(
 471         HDC  hdc
 472         )
 473 {
 474   return NtGdiCreateCompatableDC(hdc);
 475 }
 476
 477
 478 /*
 479  * @implemented
 480  */
 481 HGDIOBJ
 482 STDCALL
 483 SelectObject(
 484         HDC     hdc,
 485         HGDIOBJ hgdiobj
 486         )
 487 {
 488   return NtGdiSelectObject(hdc, hgdiobj);
 489 }
 490
 491
 492 /*
 493  * @implemented
 494  */
 495 int
 496 STDCALL
 497 SetMapMode(
 498         HDC     hdc,
 499         int     fnMapMode
 500         )
 501 {
 502   return NtGdiSetMapMode(hdc, fnMapMode);
 503 }
 504
 505
 506 /*
 507  * @implemented
 508  */
 509 BOOL
 510 STDCALL
 511 SetViewportOrgEx(
 512         HDC     hdc,
 513         int     X,
 514         int     Y,
 515         LPPOINT lpPoint
 516         )
 517 {
 518   return NtGdiSetViewportOrgEx(hdc, X, Y, lpPoint);
 519 }
 520
 521
 522 /*
 523  * @implemented
 524  */
 525 BOOL
 526 STDCALL
 527 OffsetViewportOrgEx(
 528         HDC     hdc,
 529         int     nXOffset,
 530         int     nYOffset,
 531         LPPOINT lpPoint
 532         )
 533 {
 534   return NtGdiOffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 535 }
 536
 537
 538 /*
 539  * @implemented
 540  */
 541 BOOL
 542 STDCALL
 543 SetWindowOrgEx(
 544         HDC     hdc,
 545         int     X,
 546         int     Y,
 547         LPPOINT lpPoint
 548         )
 549 {
 550   return NtGdiSetWindowOrgEx(hdc, X, Y, lpPoint);
 551 }
 552
 553
 554 /*
 555  * @implemented
 556  */
 557 BOOL
 558 STDCALL
 559 DeleteObject(HGDIOBJ hObject)
 560 {
 561   if (0 != ((DWORD) hObject & 0x00800000))
 562     {
 563       DPRINT1("Trying to delete system object 0x%x\n", hObject);
 564       return FALSE;
 565     }
 566
 567   return NtGdiDeleteObject(hObject);
 568 }
 569
 570
 571 /*
 572  * @implemented
 573  */
 574 HPALETTE
 575 STDCALL
 576 SelectPalette(
 577         HDC             hdc,
 578         HPALETTE        hpal,
 579         BOOL            bForceBackground
 580         )
 581 {
 582   return NtGdiSelectPalette(hdc, hpal, bForceBackground);
 583 }
 584
 585
 586 /*
 587  * @implemented
 588  */
 589 UINT
 590 STDCALL
 591 RealizePalette(
 592         HDC     hdc
 593         )
 594 {
 595   return NtGdiRealizePalette(hdc);
 596 }
 597
 598
 599 /*
 600  * @implemented
 601  */
 602 BOOL
 603 STDCALL
 604 LPtoDP(
 605         HDC     hdc,
 606         LPPOINT lpPoints,
 607         int     nCount
 608         )
 609 {
 610   return NtGdiLPtoDP(hdc, lpPoints, nCount);
 611 }
 612
 613
 614 /*
 615  * @implemented
 616  */
 617 int
 618 STDCALL
 619 SetPolyFillMode(
 620         HDC     hdc,
 621         int     iPolyFillMode
 622         )
 623 {
 624   return NtGdiSetPolyFillMode(hdc, iPolyFillMode);
 625 }
 626
 627
 628 /*
 629  * @implemented
 630  */
 631 int
 632 STDCALL
 633 GetDeviceCaps(
 634         HDC     hdc,
 635         int     nIndex
 636         )
 637 {
 638   return NtGdiGetDeviceCaps(hdc, nIndex);
 639 }
 640
 641 /*
 642  * @implemented
 643  */
 644 HPALETTE
 645 STDCALL
 646 CreatePalette(
 647         CONST LOGPALETTE        *lplgpl
 648         )
 649 {
 650   return NtGdiCreatePalette((CONST PLOGPALETTE)lplgpl);
 651 }
 652
 653 /*
 654  * @implemented
 655  */
 656 COLORREF
 657 STDCALL
 658 GetNearestColor(
 659         HDC             hdc,
 660         COLORREF        crColor
 661         )
 662 {
 663   return NtGdiGetNearestColor(hdc, crColor);
 664 }
 665
 666 /*
 667  * @implemented
 668  */
 669 UINT
 670 STDCALL
 671 GetNearestPaletteIndex(
 672         HPALETTE        hpal,
 673         COLORREF        crColor
 674         )
 675 {
 676   return NtGdiGetNearestPaletteIndex(hpal, crColor);
 677 }
 678
 679 /*
 680  * @implemented
 681  */
 682 UINT
 683 STDCALL
 684 GetPaletteEntries(
 685         HPALETTE        hpal,
 686         UINT            iStartIndex,
 687         UINT            nEntries,
 688         LPPALETTEENTRY  lppe
 689         )
 690 {
 691   return NtGdiGetPaletteEntries(hpal, iStartIndex, nEntries, lppe);
 692 }
 693
 694 /*
 695  * @implemented
 696  */
 697 UINT
 698 STDCALL
 699 GetSystemPaletteEntries(
 700         HDC             hdc,
 701         UINT            iStartIndex,
 702         UINT            nEntries,
 703         LPPALETTEENTRY  lppe
 704         )
 705 {
 706   return NtGdiGetSystemPaletteEntries(hdc, iStartIndex, nEntries, lppe);
 707 }
 708
 709 /*
 710  * @implemented
 711  */
 712 BOOL
 713 STDCALL
 714 RestoreDC(
 715         HDC     hdc,
 716         int     nSavedDC
 717         )
 718 {
 719   return NtGdiRestoreDC(hdc, nSavedDC);
 720 }
 721
 722
 723 /*
 724  * @implemented
 725  */
 726 int
 727 STDCALL
 728 SaveDC(
 729         HDC     hdc
 730         )
 731 {
 732   return NtGdiSaveDC(hdc);
 733 }
 734
 735 /*
 736  * @implemented
 737  */
 738 UINT
 739 STDCALL
 740 SetPaletteEntries(
 741         HPALETTE                hpal,
 742         UINT                    iStart,
 743         UINT                    cEntries,
 744         CONST PALETTEENTRY      *lppe
 745         )
 746 {
 747   return NtGdiSetPaletteEntries(hpal, iStart, cEntries, (CONST PPALETTEENTRY)lppe);
 748 }
 749
 750 /*
 751  * @implemented
 752  */
 753 BOOL
 754 STDCALL
 755 GetWorldTransform(
 756         HDC             hdc,
 757         LPXFORM         lpXform
 758         )
 759 {
 760   return NtGdiGetWorldTransform(hdc, lpXform);
 761 }
 762
 763 /*
 764  * @implemented
 765  */
 766 BOOL
 767 STDCALL
 768 SetWorldTransform(
 769         HDC             hdc,
 770         CONST XFORM     *lpXform
 771         )
 772 {
 773   return NtGdiSetWorldTransform(hdc, (CONST PXFORM)lpXform);
 774 }
 775
 776 /*
 777  * @implemented
 778  */
 779 BOOL
 780 STDCALL
 781 ModifyWorldTransform(
 782         HDC             hdc,
 783         CONST XFORM     *lpXform,
 784         DWORD           iMode
 785         )
 786 {
 787   return NtGdiModifyWorldTransform(hdc, (CONST PXFORM)lpXform, iMode);
 788 }
 789
 790 /*
 791  * @implemented
 792  */
 793 BOOL
 794 STDCALL
 795 CombineTransform(
 796         LPXFORM         lpxformResult,
 797         CONST XFORM     *lpxform1,
 798         CONST XFORM     *lpxform2
 799         )
 800 {
 801   return NtGdiCombineTransform(lpxformResult, (CONST PXFORM)lpxform1, (CONST PXFORM)lpxform2);
 802 }
 803
 804 /*
 805  * @implemented
 806  */
 807 UINT
 808 STDCALL
 809 GetDIBColorTable(
 810         HDC             hdc,
 811         UINT            uStartIndex,
 812         UINT            cEntries,
 813         RGBQUAD         *pColors
 814         )
 815 {
 816   DbgPrint("GetDIBColorTable\n");
 817   return NtGdiGetDIBColorTable(hdc, uStartIndex, cEntries, pColors);
 818 }
 819
 820 /*
 821  * @implemented
 822  */
 823 UINT
 824 STDCALL
 825 SetDIBColorTable(
 826         HDC             hdc,
 827         UINT            uStartIndex,
 828         UINT            cEntries,
 829         CONST RGBQUAD   *pColors
 830         )
 831 {
 832   return NtGdiSetDIBColorTable(hdc, uStartIndex, cEntries, (RGBQUAD*)pColors);
 833 }
 834
 835 /*
 836  * @implemented
 837  */
 838 HPALETTE
 839 STDCALL
 840 CreateHalftonePalette(
 841         HDC     hdc
 842         )
 843 {
 844   return NtGdiCreateHalftonePalette(hdc);
 845 }
 846
 847 /*
 848  * @implemented
 849  */
 850 BOOL
 851 STDCALL
 852 SetViewportExtEx(
 853         HDC     hdc,
 854         int     nXExtent,
 855         int     nYExtent,
 856         LPSIZE  lpSize
 857         )
 858 {
 859   return NtGdiSetViewportExtEx(hdc, nXExtent, nYExtent, lpSize);
 860 }
 861
 862 /*
 863  * @implemented
 864  */
 865 BOOL
 866 STDCALL
 867 SetWindowExtEx(
 868         HDC     hdc,
 869         int     nXExtent,
 870         int     nYExtent,
 871         LPSIZE  lpSize
 872         )
 873 {
 874   return NtGdiSetWindowExtEx(hdc, nXExtent, nYExtent, lpSize);
 875 }
 876
 877 /*
 878  * @implemented
 879  */
 880 BOOL
 881 STDCALL
 882 OffsetWindowOrgEx(
 883         HDC     hdc,
 884         int     nXOffset,
 885         int     nYOffset,
 886         LPPOINT lpPoint
 887         )
 888 {
 889   return NtGdiOffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint);
 890 }
 891
 892 /*
 893  * @implemented
 894  */
 895 BOOL
 896 STDCALL
 897 SetBitmapDimensionEx(
 898         HBITMAP hBitmap,
 899         int     nWidth,
 900         int     nHeight,
 901         LPSIZE  lpSize
 902         )
 903 {
 904  return NtGdiSetBitmapDimensionEx(hBitmap, nWidth, nHeight, lpSize);
 905 }
 906
 907 /*
 908  * @implemented
 909  */
 910 BOOL
 911 STDCALL
 912 GetDCOrgEx(
 913         HDC     hdc,
 914         LPPOINT lpPoint
 915         )
 916 {
 917   return NtGdiGetDCOrgEx(hdc, lpPoint);
 918 }
 919
 920 /*
 921  * @implemented
 922 */
 923 LONG
 924 STDCALL
 925 GetDCOrg(
 926     HDC hdc
 927     )
 928 {
 929   // Officially obsolete by Microsoft
 930   POINT Pt;
 931   if (!NtGdiGetDCOrgEx(hdc, &Pt))
 932     return 0;
 933   return(MAKELONG(Pt.x, Pt.y));
 934 }
 935
 936 /*
 937  * @implemented
 938  */
 939 BOOL
 940 STDCALL
 941 RectVisible(
 942         HDC             hdc,
 943         CONST RECT      *lprc
 944         )
 945 {
 946         return NtGdiRectVisible(hdc, (RECT *)lprc);
 947 }
 948
 949 /*
 950  * @implemented
 951  */
 952 int
 953 STDCALL
 954 ExtEscape(
 955         HDC             hdc,
 956         int             nEscape,
 957         int             cbInput,
 958         LPCSTR          lpszInData,
 959         int             cbOutput,
 960         LPSTR           lpszOutData
 961         )
 962 {
 963   return NtGdiExtEscape(hdc, nEscape, cbInput, lpszInData, cbOutput, lpszOutData);
 964 }
 965
 966
 967 /*
 968  * @unimplemented
 969  */
 970 int
 971 STDCALL
 972 GetObjectA(HGDIOBJ Handle, int Size, LPVOID Buffer)
 973 {
 974   LOGFONTW LogFontW;
 975   DWORD Type;
 976   int Result;
 977
 978   Type = GetObjectType(Handle);
 979   if (0 == Type)
 980     {
 981       return 0;
 982     }
 983
 984   if (OBJ_FONT == Type)
 985     {
 986       if (Size < sizeof(LOGFONTA))
 987         {
 988           SetLastError(ERROR_BUFFER_OVERFLOW);
 989           return 0;
 990         }
 991       Result = NtGdiGetObject(Handle, sizeof(LOGFONTW), &LogFontW);
 992       if (0 == Result)
 993         {
 994           return 0;
 995         }
 996       RosRtlLogFontW2A((LPLOGFONTA) Buffer, &LogFontW);
 997       Result = sizeof(LOGFONTA);
 998     }
 999   else
1000     {
1001       Result = NtGdiGetObject(Handle, Size, Buffer);
1002     }
1003
1004   return Result;
1005 }
1006
1007
1008 /*
1009  * @unimplemented
1010  */
1011 int
1012 STDCALL
1013 GetObjectW(HGDIOBJ Handle, int Size, LPVOID Buffer)
1014 {
1015   return NtGdiGetObject(Handle, Size, Buffer);
1016 }
1017
1018
1019 /*
1020  * @implemented
1021  */
1022 BOOL
1023 STDCALL
1024 SetBrushOrgEx(
1025         HDC     hdc,
1026         int     nXOrg,
1027         int     nYOrg,
1028         LPPOINT lppt
1029         )
1030 {
1031   return NtGdiSetBrushOrgEx(hdc, nXOrg, nYOrg, lppt);
1032 }
1033
1034
1035 /*
1036  * @implemented
1037  */
1038 BOOL
1039 STDCALL
1040 FixBrushOrgEx(
1041         HDC     hdc,
1042         int     nXOrg,
1043         int     nYOrg,
1044         LPPOINT lppt
1045         )
1046 {
1047   #if 0
1048   /* FIXME - Check if we're emulating win95, if so, forward to SetBrushOrgEx() */
1049   return SetBrushOrgEx(hdc, nXOrg, nYOrg, lppt);
1050   #endif
1051
1052   return FALSE;
1053 }
1054
1055
1056 /*
1057  * @implemented
1058  */
1059 HGDIOBJ
1060 STDCALL
1061 GetCurrentObject(
1062         HDC     hdc,
1063         UINT    uObjectType
1064         )
1065 {
1066   return NtGdiGetCurrentObject(hdc, uObjectType);
1067 }
1068
1069
1070 /*
1071  * @implemented
1072  */
1073 BOOL
1074 STDCALL
1075 PtVisible(
1076         HDC     hdc,
1077         int     X,
1078         int     Y
1079         )
1080 {
1081   return NtGdiPtVisible(hdc, X, Y);
1082 }
1083
1084 /*
1085  * @implemented
1086  */
1087 COLORREF
1088 STDCALL
1089 GetDCBrushColor(
1090         HDC hdc
1091 )
1092 {
1093   return NtUserGetDCBrushColor(hdc);
1094 }
1095
1096 /*
1097  * @implemented
1098  */
1099 COLORREF
1100 STDCALL
1101 GetDCPenColor(
1102         HDC hdc
1103 )
1104 {
1105   return NtUserGetDCPenColor(hdc);
1106 }
1107
1108 /*
1109  * @implemented
1110  */
1111 COLORREF
1112 STDCALL
1113 SetDCBrushColor(
1114         HDC hdc,
1115         COLORREF crColor
1116 )
1117 {
1118   return NtUserSetDCBrushColor(hdc, crColor);
1119 }
1120
1121 /*
1122  * @implemented
1123  */
1124 COLORREF
1125 STDCALL
1126 SetDCPenColor(
1127         HDC hdc,
1128         COLORREF crColor
1129 )
1130 {
1131   return NtUserSetDCPenColor(hdc, crColor);
1132 }