lib/gdi32/misc/stubsw.c

   1 /* $Id$
   2  *
   3  * reactos/lib/gdi32/misc/stubs.c
   4  *
   5  * GDI32.DLL Stubs for Unicode functions
   6  *
   7  * When you implement one of these functions,
   8  * remove its stub from this file.
   9  *
  10  */
  11 #ifndef UNICODE
  12 #define UNICODE
  13 #endif//UNICODE
  14 #include <windows.h>
  15 #include <win32k/kapi.h>
  16
  17 /*
  18  * @implemented
  19  */
  20 int
  21 STDCALL
  22 AddFontResourceExW ( LPCWSTR lpszFilename, DWORD fl, PVOID pvReserved )
  23 {
  24   /* FIXME handle fl parameter */
  25   return NtGdiAddFontResource ( lpszFilename );
  26 }
  27
  28 /*
  29  * @implemented
  30  */
  31 int
  32 STDCALL
  33 AddFontResourceW ( LPCWSTR lpszFilename )
  34 {
  35         return AddFontResourceExW ( lpszFilename, 0, 0 );
  36 }
  37
  38
  39 /*
  40  * @implemented
  41  */
  42 HMETAFILE
  43 STDCALL
  44 CopyMetaFileW(
  45         HMETAFILE       Src,
  46         LPCWSTR         File
  47         )
  48 {
  49         return NtGdiCopyMetaFile ( Src, File );
  50 }
  51
  52
  53 /*
  54  * @implemented
  55  */
  56 HDC
  57 STDCALL
  58 CreateICW(
  59         LPCWSTR                 lpszDriver,
  60         LPCWSTR                 lpszDevice,
  61         LPCWSTR                 lpszOutput,
  62         CONST DEVMODEW *        lpdvmInit
  63         )
  64 {
  65   return NtGdiCreateIC ( lpszDriver,
  66                       lpszDevice,
  67                       lpszOutput,
  68                       (CONST PDEVMODEW)lpdvmInit );
  69 }
  70
  71
  72 /*
  73  * @implemented
  74  */
  75 HDC
  76 STDCALL
  77 CreateMetaFileW(
  78         LPCWSTR         lpszFile
  79         )
  80 {
  81         return NtGdiCreateMetaFile ( lpszFile );
  82 }
  83
  84
  85 /*
  86  * @implemented
  87  */
  88 BOOL
  89 STDCALL
  90 CreateScalableFontResourceW(
  91         DWORD           fdwHidden,
  92         LPCWSTR         lpszFontRes,
  93         LPCWSTR         lpszFontFile,
  94         LPCWSTR         lpszCurrentPath
  95         )
  96 {
  97   return NtGdiCreateScalableFontResource ( fdwHidden,
  98                                           lpszFontRes,
  99                                           lpszFontFile,
 100                                           lpszCurrentPath );
 101 }
 102
 103
 104 /*
 105  * @unimplemented
 106  */
 107 int
 108 STDCALL
 109 DeviceCapabilitiesExW(
 110         LPCWSTR         pDevice,
 111         LPCWSTR         pPort,
 112         WORD            fwCapability,
 113         LPWSTR          pOutput,
 114         CONST DEVMODEW  *pDevMode
 115         )
 116 {
 117 #if 0
 118   /* FIXME no NtGdiDeviceCapabilities???? */
 119   return NtGdiDeviceCapabilities ( pDevice,
 120                                   pPort,
 121                                   fwCapability,
 122                                   pOutput,
 123                                   pDevMode );
 124 #else
 125   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 126   return 0;
 127 #endif
 128 }
 129
 130
 131 /*
 132  * @unimplemented
 133  */
 134 int
 135 STDCALL
 136 EnumFontFamiliesExW(
 137         HDC             hdc,
 138         LPLOGFONTW      lpLogFont,
 139         FONTENUMEXPROCW lpEnumFontFamProc,
 140         LPARAM          lParam,
 141         DWORD           dwFlags
 142         )
 143 {
 144 #if 0
 145   return NtGdiEnumFontFamiliesEx ( hdc, lpLogFont, lpEnumFontFamProc, lParam, dwFlags );
 146 #else
 147   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 148   return 0;
 149 #endif
 150 }
 151
 152
 153 /*
 154  * @unimplemented
 155  */
 156 int
 157 STDCALL
 158 EnumFontFamiliesW(
 159         HDC             hdc,
 160         LPCWSTR         lpszFamily,
 161         FONTENUMPROCW   lpEnumFontFamProc,
 162         LPARAM          lParam
 163         )
 164 {
 165 #if 0
 166   return NtGdiEnumFontFamilies ( hdc, lpszFamily, lpEnumFontFamProc, lParam );
 167 #else
 168   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 169   return 0;
 170 #endif
 171 }
 172
 173
 174 /*
 175  * @unimplemented
 176  */
 177 int
 178 STDCALL
 179 EnumFontsW(
 180         HDC  hDC,
 181         LPCWSTR lpFaceName,
 182         FONTENUMPROCW  FontFunc,
 183         LPARAM  lParam
 184         )
 185 {
 186 #if 0
 187   return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam );
 188 #else
 189   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 190   return 0;
 191 #endif
 192 }
 193
 194
 195 /*
 196  * @implemented
 197  */
 198 BOOL
 199 STDCALL
 200 GetCharWidthW (
 201         HDC     hdc,
 202         UINT    iFirstChar,
 203         UINT    iLastChar,
 204         LPINT   lpBuffer
 205         )
 206 {
 207   return NtGdiGetCharWidth ( hdc, iFirstChar, iLastChar, lpBuffer );
 208 }
 209
 210
 211 /*
 212  * @implemented
 213  */
 214 BOOL
 215 STDCALL
 216 GetCharWidth32W(
 217         HDC     hdc,
 218         UINT    iFirstChar,
 219         UINT    iLastChar,
 220         LPINT   lpBuffer
 221         )
 222 {
 223   return NtGdiGetCharWidth32 ( hdc, iFirstChar, iLastChar, lpBuffer );
 224 }
 225
 226
 227 /*
 228  * @implemented
 229  */
 230 BOOL
 231 APIENTRY
 232 GetCharWidthFloatW(
 233         HDC     hdc,
 234         UINT    iFirstChar,
 235         UINT    iLastChar,
 236         PFLOAT  pxBuffer
 237         )
 238 {
 239   return NtGdiGetCharWidthFloat ( hdc, iFirstChar, iLastChar, pxBuffer );
 240 }
 241
 242
 243 /*
 244  * @implemented
 245  */
 246 BOOL
 247 APIENTRY
 248 GetCharABCWidthsW(
 249         HDC     hdc,
 250         UINT    uFirstChar,
 251         UINT    uLastChar,
 252         LPABC   lpabc
 253         )
 254 {
 255   return NtGdiGetCharABCWidths ( hdc, uFirstChar, uLastChar, lpabc );
 256 }
 257
 258
 259 /*
 260  * @implemented
 261  */
 262 BOOL
 263 APIENTRY
 264 GetCharABCWidthsFloatW(
 265         HDC             hdc,
 266         UINT            iFirstChar,
 267         UINT            iLastChar,
 268         LPABCFLOAT      lpABCF
 269         )
 270 {
 271   return NtGdiGetCharABCWidthsFloat ( hdc, iFirstChar, iLastChar, lpABCF );
 272 }
 273
 274
 275 /*
 276  * @implemented
 277  */
 278 DWORD
 279 STDCALL
 280 GetGlyphOutlineW(
 281         HDC             hdc,
 282         UINT            uChar,
 283         UINT            uFormat,
 284         LPGLYPHMETRICS  lpgm,
 285         DWORD           cbBuffer,
 286         LPVOID          lpvBuffer,
 287         CONST MAT2      *lpmat2
 288         )
 289 {
 290   return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2 );
 291 }
 292
 293
 294 /*
 295  * @implemented
 296  */
 297 HMETAFILE
 298 STDCALL
 299 GetMetaFileW(
 300         LPCWSTR lpszMetaFile
 301         )
 302 {
 303   return NtGdiGetMetaFile ( lpszMetaFile );
 304 }
 305
 306
 307 /*
 308  * @unimplemented
 309  */
 310 UINT
 311 APIENTRY
 312 GetOutlineTextMetricsW(
 313         HDC                     hdc,
 314         UINT                    cbData,
 315         LPOUTLINETEXTMETRICW    lpOTM
 316         )
 317 {
 318   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 319   return 0;
 320 }
 321
 322
 323 /*
 324  * @implemented
 325  */
 326 BOOL
 327 APIENTRY
 328 GetTextExtentExPointW(
 329         HDC             hdc,
 330         LPCWSTR         lpszStr,
 331         int             cchString,
 332         int             nMaxExtent,
 333         LPINT           lpnFit,
 334         LPINT           alpDx,
 335         LPSIZE          lpSize
 336         )
 337 {
 338   return NtGdiGetTextExtentExPoint (
 339     hdc, lpszStr, cchString, nMaxExtent, lpnFit, alpDx, lpSize );
 340 }
 341
 342
 343 /*
 344  * @unimplemented
 345  */
 346 DWORD
 347 STDCALL
 348 GetCharacterPlacementW(
 349         HDC             hDc,
 350         LPCWSTR         a1,
 351         int             a2,
 352         int             a3,
 353         LPGCP_RESULTSW  a4,
 354         DWORD           a5
 355         )
 356 {
 357         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 358         return 0;
 359 }
 360
 361
 362 /*
 363  * @implemented
 364  */
 365 HDC
 366 STDCALL
 367 ResetDCW(
 368         HDC             hdc,
 369         CONST DEVMODEW  *lpInitData
 370         )
 371 {
 372   return NtGdiResetDC ( hdc, lpInitData );
 373 }
 374
 375
 376 /*
 377  * @implemented
 378  */
 379 BOOL
 380 STDCALL
 381 RemoveFontResourceW(
 382         LPCWSTR lpFileName
 383         )
 384 {
 385   return NtGdiRemoveFontResource ( lpFileName );
 386 }
 387
 388
 389 /*
 390  * @implemented
 391  */
 392 HENHMETAFILE
 393 STDCALL
 394 CopyEnhMetaFileW(
 395         HENHMETAFILE    hemfSrc,
 396         LPCWSTR         lpszFile
 397         )
 398 {
 399   return NtGdiCopyEnhMetaFile ( hemfSrc, lpszFile );
 400 }
 401
 402
 403 /*
 404  * @implemented
 405  */
 406 HDC
 407 STDCALL
 408 CreateEnhMetaFileW(
 409         HDC             hdc,
 410         LPCWSTR         lpFileName,
 411         CONST RECT      *lpRect,
 412         LPCWSTR         lpDescription
 413         )
 414 {
 415   return NtGdiCreateEnhMetaFile ( hdc, lpFileName, (CONST LPRECT)lpRect, lpDescription );
 416 }
 417
 418
 419 /*
 420  * @implemented
 421  */
 422 HENHMETAFILE
 423 STDCALL
 424 GetEnhMetaFileW(
 425         LPCWSTR lpszMetaFile
 426         )
 427 {
 428   return NtGdiGetEnhMetaFile ( lpszMetaFile );
 429 }
 430
 431
 432 /*
 433  * @implemented
 434  */
 435 UINT
 436 STDCALL
 437 GetEnhMetaFileDescriptionW(
 438         HENHMETAFILE    hemf,
 439         UINT            cchBuffer,
 440         LPWSTR          lpszDescription
 441         )
 442 {
 443   return NtGdiGetEnhMetaFileDescription ( hemf, cchBuffer, lpszDescription );
 444 }
 445
 446
 447 /*
 448  * @implemented
 449  */
 450 int
 451 STDCALL
 452 StartDocW(
 453         HDC             hdc,
 454         CONST DOCINFOW  *a1
 455         )
 456 {
 457         return NtGdiStartDoc ( hdc, (CONST PDOCINFOW)a1 );
 458 }
 459
 460
 461 /*
 462  * @unimplemented
 463  */
 464 int
 465 STDCALL
 466 GetObjectW(
 467         HGDIOBJ         a0,
 468         int             a1,
 469         LPVOID          a2
 470         )
 471 {
 472         return NtGdiGetObject ( a0, a1, a2 );
 473 }
 474
 475
 476 /*
 477  * @unimplemented
 478  */
 479 BOOL
 480 STDCALL
 481 PolyTextOutW(
 482         HDC                     hdc,
 483         CONST POLYTEXTW         *a1,
 484         int                     a2
 485         )
 486 {
 487         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 488         return FALSE;
 489 }
 490
 491
 492 /*
 493  * @unimplemented
 494  */
 495 int
 496 STDCALL
 497 GetTextFaceW(
 498         HDC     a0,
 499         int     a1,
 500         LPWSTR  a2
 501         )
 502 {
 503         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 504         return 0;
 505 }
 506
 507
 508 /*
 509  * @unimplemented
 510  */
 511 DWORD
 512 STDCALL
 513 GetKerningPairsW(
 514         HDC             a0,
 515         DWORD           a1,
 516         LPKERNINGPAIR   a2
 517         )
 518 {
 519         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 520         return 0;
 521 }
 522
 523
 524 /*
 525  * @unimplemented
 526  */
 527 BOOL
 528 STDCALL
 529 GetLogColorSpaceW(
 530         HCOLORSPACE             a0,
 531         LPLOGCOLORSPACEW        a1,
 532         DWORD                   a2
 533         )
 534 {
 535         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 536         return FALSE;
 537 }
 538
 539 /*
 540  * @unimplemented
 541  */
 542 HCOLORSPACE
 543 STDCALL
 544 CreateColorSpaceW(
 545         LPLOGCOLORSPACEW        a0
 546         )
 547 {
 548         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 549         return 0;
 550 }
 551
 552
 553 /*
 554  * @unimplemented
 555  */
 556 WINBOOL
 557 STDCALL
 558 GetICMProfileW(
 559         HDC             a0,
 560         DWORD           a1,     /* MS says LPDWORD! */
 561         LPWSTR          a2
 562         )
 563 {
 564         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 565         return FALSE;
 566 }
 567
 568
 569 /*
 570  * @unimplemented
 571  */
 572 BOOL
 573 STDCALL
 574 SetICMProfileW(
 575         HDC     a0,
 576         LPWSTR  a1
 577         )
 578 {
 579         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 580         return FALSE;
 581 }
 582
 583
 584 /*
 585  * @unimplemented
 586  */
 587 int
 588 STDCALL
 589 EnumICMProfilesW(
 590         HDC             hDC,
 591         ICMENUMPROCW    lpEnumICMProfilesFunc,
 592         LPARAM          lParam
 593         )
 594 {
 595   /*
 596    * FIXME - call NtGdiEnumICMProfiles with NULL for lpstrBuffer
 597    * to find out how big a buffer we need. Then allocate that buffer
 598    * and call NtGdiEnumICMProfiles again to have the buffer filled.
 599    *
 600    * Finally, step through the buffer ( MULTI-SZ recommended for format ),
 601    * and call the user's callback function until we run out of strings or
 602    * the user returns FALSE
 603    */
 604   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 605   return 0;
 606 }
 607
 608
 609 /*
 610  * @unimplemented
 611  */
 612 BOOL
 613 STDCALL
 614 wglUseFontBitmapsW(
 615         HDC             a0,
 616         DWORD           a1,
 617         DWORD           a2,
 618         DWORD           a3
 619         )
 620 {
 621         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 622         return FALSE;
 623 }
 624
 625
 626 /*
 627  * @unimplemented
 628  */
 629 BOOL
 630 STDCALL
 631 wglUseFontOutlinesW(
 632         HDC                     a0,
 633         DWORD                   a1,
 634         DWORD                   a2,
 635         DWORD                   a3,
 636         FLOAT                   a4,
 637         FLOAT                   a5,
 638         int                     a6,
 639         LPGLYPHMETRICSFLOAT     a7
 640         )
 641 {
 642         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 643         return FALSE;
 644 }
 645
 646
 647 /*
 648  * @unimplemented
 649  */
 650 WINBOOL
 651 STDCALL
 652 UpdateICMRegKeyW(
 653         DWORD   a0,
 654         DWORD   a1,
 655         LPWSTR  a2,
 656         UINT    a3
 657         )
 658 {
 659         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 660         return FALSE;
 661 }
 662
 663
 664 /* === AFTER THIS POINT I GUESS... =========
 665  * (based on stack size in Norlander's .def)
 666  * === WHERE ARE THEY DEFINED? =============
 667  */
 668
 669
 670 /*
 671  * @unimplemented
 672  */
 673 DWORD
 674 STDCALL
 675 GetFontResourceInfoW(
 676         DWORD   a0,
 677         DWORD   a1,
 678         DWORD   a2,
 679         DWORD   a3
 680         )
 681 {
 682         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 683         return 0;
 684 }
 685
 686
 687 /* EOF */