objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <assert.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12
  13 #include "windef.h"
  14 #include "wingdi.h"
  15 #include "winerror.h"
  16 #include "wine/winbase16.h"
  17
  18 #include "bitmap.h"
  19 #include "brush.h"
  20 #include "font.h"
  21 #include "heap.h"
  22 #include "options.h"
  23 #include "palette.h"
  24 #include "pen.h"
  25 #include "region.h"
  26 #include "debugtools.h"
  27 #include "gdi.h"
  28 #include "tweak.h"
  29 #include "syslevel.h"
  30
  31 DEFAULT_DEBUG_CHANNEL(gdi);
  32
  33
  34 /***********************************************************************
  35  *          GDI stock objects
  36  */
  37
  38 static BRUSHOBJ WhiteBrush =
  39 {
  40     { 0, BRUSH_MAGIC, 1 },             /* header */
  41     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  42 };
  43
  44 static BRUSHOBJ LtGrayBrush =
  45 {
  46     { 0, BRUSH_MAGIC, 1 },             /* header */
  47 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  48     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  49 };
  50
  51 static BRUSHOBJ GrayBrush =
  52 {
  53     { 0, BRUSH_MAGIC, 1 },             /* header */
  54 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
  55     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  56 };
  57
  58 static BRUSHOBJ DkGrayBrush =
  59 {
  60     { 0, BRUSH_MAGIC, 1 },          /* header */
  61 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
  62 /* NB_HATCH_STYLES is an index into HatchBrushes */
  63     { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES }  /* logbrush */
  64 };
  65
  66 static BRUSHOBJ BlackBrush =
  67 {
  68     { 0, BRUSH_MAGIC, 1 },       /* header */
  69     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  70 };
  71
  72 static BRUSHOBJ NullBrush =
  73 {
  74     { 0, BRUSH_MAGIC, 1 },  /* header */
  75     { BS_NULL, 0, 0 }       /* logbrush */
  76 };
  77
  78 static PENOBJ WhitePen =
  79 {
  80     { 0, PEN_MAGIC, 1 },                     /* header */
  81     { PS_SOLID, { 0, 0 }, RGB(255,255,255) } /* logpen */
  82 };
  83
  84 static PENOBJ BlackPen =
  85 {
  86     { 0, PEN_MAGIC, 1 },               /* header */
  87     { PS_SOLID, { 0, 0 }, RGB(0,0,0) } /* logpen */
  88 };
  89
  90 static PENOBJ NullPen =
  91 {
  92     { 0, PEN_MAGIC, 1 },      /* header */
  93     { PS_NULL, { 0, 0 }, 0 }  /* logpen */
  94 };
  95
  96 static FONTOBJ OEMFixedFont =
  97 {
  98     { 0, FONT_MAGIC, 1 },   /* header */
  99     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
 100       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 101 };
 102 /* Filler to make the location counter dword aligned again.  This is necessary
 103    since (a) FONTOBJ is packed, (b) gcc places initialised variables in the code
 104    segment, and (c) Solaris assembler is stupid.  */
 105 static UINT16 align_OEMFixedFont = 1;
 106
 107 static FONTOBJ AnsiFixedFont =
 108 {
 109     { 0, FONT_MAGIC, 1 },   /* header */
 110     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 111       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 112 };
 113 static UINT16 align_AnsiFixedFont = 1;
 114
 115 static FONTOBJ AnsiVarFont =
 116 {
 117     { 0, FONT_MAGIC, 1 },   /* header */
 118     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 119       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
 120 };
 121 static UINT16 align_AnsiVarFont = 1;
 122
 123 static FONTOBJ SystemFont =
 124 {
 125     { 0, FONT_MAGIC, 1 },
 126     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 127       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "System" }
 128 };
 129 static UINT16 align_SystemFont = 1;
 130
 131 static FONTOBJ DeviceDefaultFont =
 132 {
 133     { 0, FONT_MAGIC, 1 },   /* header */
 134     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 135       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 136 };
 137 static UINT16 align_DeviceDefaultFont = 1;
 138
 139 static FONTOBJ SystemFixedFont =
 140 {
 141     { 0, FONT_MAGIC, 1 },   /* header */
 142     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 143       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 144 };
 145 static UINT16 align_SystemFixedFont = 1;
 146
 147 /* FIXME: Is this correct? */
 148 static FONTOBJ DefaultGuiFont =
 149 {
 150     { 0, FONT_MAGIC, 1 },   /* header */
 151     { 0, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 152       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
 153 };
 154 static UINT16 align_DefaultGuiFont = 1;
 155
 156
 157 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 158 {
 159     (GDIOBJHDR *) &WhiteBrush,
 160     (GDIOBJHDR *) &LtGrayBrush,
 161     (GDIOBJHDR *) &GrayBrush,
 162     (GDIOBJHDR *) &DkGrayBrush,
 163     (GDIOBJHDR *) &BlackBrush,
 164     (GDIOBJHDR *) &NullBrush,
 165     (GDIOBJHDR *) &WhitePen,
 166     (GDIOBJHDR *) &BlackPen,
 167     (GDIOBJHDR *) &NullPen,
 168     NULL,
 169     (GDIOBJHDR *) &OEMFixedFont,
 170     (GDIOBJHDR *) &AnsiFixedFont,
 171     (GDIOBJHDR *) &AnsiVarFont,
 172     (GDIOBJHDR *) &SystemFont,
 173     (GDIOBJHDR *) &DeviceDefaultFont,
 174     NULL,            /* DEFAULT_PALETTE created by PALETTE_Init */
 175     (GDIOBJHDR *) &SystemFixedFont,
 176     (GDIOBJHDR *) &DefaultGuiFont
 177 };
 178
 179 HBITMAP hPseudoStockBitmap; /* 1x1 bitmap for memory DCs */
 180
 181 static SYSLEVEL GDI_level;
 182 static WORD GDI_HeapSel;
 183
 184
 185 /******************************************************************************
 186  *
 187  *   void  ReadFontInformation(
 188  *      char const  *fontName,
 189  *      FONTOBJ  *font,
 190  *      int  defHeight,
 191  *      int  defBold,
 192  *      int  defItalic,
 193  *      int  defUnderline,
 194  *      int  defStrikeOut )
 195  *
 196  *   ReadFontInformation() checks the Wine configuration file's Tweak.Fonts
 197  *   section for entries containing fontName.Height, fontName.Bold, etc.,
 198  *   where fontName is the name specified in the call (e.g., "System").  It
 199  *   attempts to be user friendly by accepting 'n', 'N', 'f', 'F', or '0' as
 200  *   the first character in the boolean attributes (bold, italic, and
 201  *   underline).
 202  *****************************************************************************/
 203
 204 static void  ReadFontInformation(
 205     char const *fontName,
 206     FONTOBJ *font,
 207     int  defHeight,
 208     int  defBold,
 209     int  defItalic,
 210     int  defUnderline,
 211     int  defStrikeOut )
 212 {
 213     char  key[256];
 214
 215     /* In order for the stock fonts to be independent of
 216      * mapping mode, the height (& width) must be 0
 217      */
 218     sprintf(key, "%s.Height", fontName);
 219     font->logfont.lfHeight =
 220         PROFILE_GetWineIniInt("Tweak.Fonts", key, defHeight);
 221
 222     sprintf(key, "%s.Bold", fontName);
 223     font->logfont.lfWeight =
 224         (PROFILE_GetWineIniBool("Tweak.Fonts", key, defBold)) ?
 225         FW_BOLD : FW_NORMAL;
 226
 227     sprintf(key, "%s.Italic", fontName);
 228     font->logfont.lfItalic =
 229         PROFILE_GetWineIniBool("Tweak.Fonts", key, defItalic);
 230
 231     sprintf(key, "%s.Underline", fontName);
 232     font->logfont.lfUnderline =
 233         PROFILE_GetWineIniBool("Tweak.Fonts", key, defUnderline);
 234
 235     sprintf(key, "%s.StrikeOut", fontName);
 236     font->logfont.lfStrikeOut =
 237         PROFILE_GetWineIniBool("Tweak.Fonts", key, defStrikeOut);
 238
 239     return;
 240 }
 241
 242 /***********************************************************************
 243  * Because the stock fonts have their structure initialized with
 244  * a height of 0 to keep them independent of mapping mode, simply
 245  * returning the LOGFONT as is will not work correctly.
 246  * These "FixStockFontSizeXXX()" methods will get the correct
 247  * size for the fonts.
 248  */
 249 static void GetFontMetrics(HFONT handle, LPTEXTMETRICA lptm)
 250 {
 251   HDC         hdc;
 252   HFONT       hOldFont;
 253
 254   hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
 255
 256   hOldFont = (HFONT)SelectObject(hdc, handle);
 257
 258   GetTextMetricsA(hdc, lptm);
 259
 260   SelectObject(hdc, hOldFont);
 261
 262   DeleteDC(hdc);
 263 }
 264
 265 static inline void FixStockFontSize16(
 266   HFONT  handle,
 267   INT16  count,
 268   LPVOID buffer)
 269 {
 270   TEXTMETRICA tm;
 271   LOGFONT16*  pLogFont = (LOGFONT16*)buffer;
 272
 273   /*
 274    * Was the lfHeight field copied (it's the first field)?
 275    * If it was and it was null, replace the height.
 276    */
 277   if ( (count >= 2*sizeof(INT16)) &&
 278        (pLogFont->lfHeight == 0) )
 279   {
 280     GetFontMetrics(handle, &tm);
 281
 282     pLogFont->lfHeight = tm.tmHeight;
 283     pLogFont->lfWidth  = tm.tmAveCharWidth;
 284   }
 285 }
 286
 287 static inline void FixStockFontSizeA(
 288   HFONT  handle,
 289   INT    count,
 290   LPVOID buffer)
 291 {
 292   TEXTMETRICA tm;
 293   LOGFONTA*  pLogFont = (LOGFONTA*)buffer;
 294
 295   /*
 296    * Was the lfHeight field copied (it's the first field)?
 297    * If it was and it was null, replace the height.
 298    */
 299   if ( (count >= 2*sizeof(INT)) &&
 300        (pLogFont->lfHeight == 0) )
 301   {
 302     GetFontMetrics(handle, &tm);
 303
 304     pLogFont->lfHeight = tm.tmHeight;
 305     pLogFont->lfWidth  = tm.tmAveCharWidth;
 306   }
 307 }
 308
 309 /**
 310  * Since the LOGFONTA and LOGFONTW structures are identical up to the
 311  * lfHeight member (the one of interest in this case) we simply define
 312  * the W version as the A version.
 313  */
 314 #define FixStockFontSizeW FixStockFontSizeA
 315
 316 #define TRACE_SEC(handle,text) \
 317    TRACE("(%04x): " text " %ld\n", (handle), GDI_level.crst.RecursionCount)
 318
 319 /***********************************************************************
 320  *           GDI_Init
 321  *
 322  * GDI initialization.
 323  */
 324 BOOL GDI_Init(void)
 325 {
 326     BOOL systemIsBold = (TWEAK_WineLook == WIN31_LOOK);
 327     HPALETTE16 hpalette;
 328     HINSTANCE16 instance;
 329
 330     _CreateSysLevel( &GDI_level, 3 );
 331
 332     /* create GDI heap */
 333     if ((instance = LoadLibrary16( "GDI.EXE" )) < 32) return FALSE;
 334     GDI_HeapSel = GlobalHandleToSel16( instance );
 335
 336     /* Kill some warnings.  */
 337     (void)align_OEMFixedFont;
 338     (void)align_AnsiFixedFont;
 339     (void)align_AnsiVarFont;
 340     (void)align_SystemFont;
 341     (void)align_DeviceDefaultFont;
 342     (void)align_SystemFixedFont;
 343     (void)align_DefaultGuiFont;
 344
 345     /* TWEAK: Initialize font hints */
 346     ReadFontInformation("OEMFixed", &OEMFixedFont, 0, 0, 0, 0, 0);
 347     ReadFontInformation("AnsiFixed", &AnsiFixedFont, 0, 0, 0, 0, 0);
 348     ReadFontInformation("AnsiVar", &AnsiVarFont, 0, 0, 0, 0, 0);
 349     ReadFontInformation("System", &SystemFont, 0, systemIsBold, 0, 0, 0);
 350     ReadFontInformation("DeviceDefault", &DeviceDefaultFont, 0, 0, 0, 0, 0);
 351     ReadFontInformation("SystemFixed", &SystemFixedFont, 0, systemIsBold, 0, 0, 0);
 352     ReadFontInformation("DefaultGui", &DefaultGuiFont, 0, 0, 0, 0, 0);
 353
 354     /* Create default palette */
 355
 356     /* DR well *this* palette can't be moveable (?) */
 357     hpalette = PALETTE_Init();
 358     if( !hpalette ) return FALSE;
 359     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, hpalette );
 360
 361     hPseudoStockBitmap = CreateBitmap( 1, 1, 1, 1, NULL );
 362     return TRUE;
 363 }
 364
 365 #define FIRST_LARGE_HANDLE 16
 366 #define MAX_LARGE_HANDLES ((GDI_HEAP_SIZE - FIRST_LARGE_HANDLE) >> 2)
 367 static GDIOBJHDR *large_handles[MAX_LARGE_HANDLES];
 368 static int next_large_handle;
 369
 370 /***********************************************************************
 371  *           alloc_large_heap
 372  *
 373  * Allocate a GDI handle from the large heap. Helper for GDI_AllocObject
 374  */
 375 inline static GDIOBJHDR *alloc_large_heap( WORD size, HGDIOBJ *handle )
 376 {
 377     int i;
 378     GDIOBJHDR *obj;
 379
 380     for (i = next_large_handle + 1; i < MAX_LARGE_HANDLES; i++)
 381         if (!large_handles[i]) goto found;
 382     for (i = 0; i <= next_large_handle; i++)
 383         if (!large_handles[i]) goto found;
 384     *handle = 0;
 385     return NULL;
 386
 387  found:
 388     if ((obj = HeapAlloc( GetProcessHeap(), 0, size )))
 389     {
 390         large_handles[i] = obj;
 391         *handle = (i + FIRST_LARGE_HANDLE) << 2;
 392         next_large_handle = i;
 393     }
 394     return obj;
 395 }
 396
 397
 398 /***********************************************************************
 399  *           GDI_AllocObject
 400  */
 401 void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle )
 402 {
 403     static DWORD count = 0;
 404     GDIOBJHDR *obj;
 405
 406     _EnterSysLevel( &GDI_level );
 407     switch(magic)
 408     {
 409         /* allocate DCs on the larger heap */
 410     case DC_MAGIC:
 411     case DISABLED_DC_MAGIC:
 412     case META_DC_MAGIC:
 413     case METAFILE_MAGIC:
 414     case METAFILE_DC_MAGIC:
 415     case ENHMETAFILE_MAGIC:
 416     case ENHMETAFILE_DC_MAGIC:
 417         if (!(obj = alloc_large_heap( size, handle ))) goto error;
 418         break;
 419     default:
 420         if (!(*handle = LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, size ))) goto error;
 421         assert( *handle & 2 );
 422         obj = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, *handle );
 423         break;
 424     }
 425
 426     obj->hNext   = 0;
 427     obj->wMagic  = magic|OBJECT_NOSYSTEM;
 428     obj->dwCount = ++count;
 429
 430     TRACE_SEC( *handle, "enter" );
 431     return obj;
 432
 433 error:
 434     _LeaveSysLevel( &GDI_level );
 435     *handle = 0;
 436     return NULL;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           GDI_ReallocObject
 442  *
 443  * The object ptr must have been obtained with GDI_GetObjPtr.
 444  * The new pointer must be released with GDI_ReleaseObj.
 445  */
 446 void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
 447 {
 448     HGDIOBJ new_handle;
 449
 450     assert( handle & 2 );  /* no realloc for large handles */
 451     LOCAL_Unlock( GDI_HeapSel, handle );
 452     if (!(new_handle = LOCAL_ReAlloc( GDI_HeapSel, handle, size, LMEM_MOVEABLE )))
 453     {
 454         TRACE_SEC( handle, "leave" );
 455         _LeaveSysLevel( &GDI_level );
 456         return NULL;
 457     }
 458     assert( new_handle == handle );  /* moveable handle cannot change */
 459     return LOCAL_Lock( GDI_HeapSel, handle );
 460 }
 461
 462
 463 /***********************************************************************
 464  *           GDI_FreeObject
 465  */
 466 BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
 467 {
 468     GDIOBJHDR *object = ptr;
 469
 470     /* can't free stock objects */
 471     if (handle < FIRST_STOCK_HANDLE)
 472     {
 473         object->wMagic = 0;  /* Mark it as invalid */
 474         if (handle & 2)  /* GDI heap handle */
 475         {
 476             LOCAL_Unlock( GDI_HeapSel, handle );
 477             LOCAL_Free( GDI_HeapSel, handle );
 478         }
 479         else  /* large heap handle */
 480         {
 481             int i = (handle >> 2) - FIRST_LARGE_HANDLE;
 482             if (i >= 0 && large_handles[i])
 483             {
 484                 HeapFree( GetProcessHeap(), 0, large_handles[i] );
 485                 large_handles[i] = NULL;
 486             }
 487         }
 488     }
 489     TRACE_SEC( handle, "leave" );
 490     _LeaveSysLevel( &GDI_level );
 491     return TRUE;
 492 }
 493
 494
 495 /***********************************************************************
 496  *           GDI_GetObjPtr
 497  *
 498  * Return a pointer to the GDI object associated to the handle.
 499  * Return NULL if the object has the wrong magic number.
 500  * The object must be released with GDI_ReleaseObj.
 501  */
 502 void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
 503 {
 504     GDIOBJHDR *ptr = NULL;
 505
 506     _EnterSysLevel( &GDI_level );
 507
 508     if (handle >= FIRST_STOCK_HANDLE)
 509     {
 510         if (handle <= LAST_STOCK_HANDLE) ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 511         if (ptr && (magic != MAGIC_DONTCARE)
 512         && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 513     }
 514     else if (handle & 2)  /* GDI heap handle */
 515     {
 516         ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, handle );
 517         if (ptr &&
 518         (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic))
 519         {
 520             LOCAL_Unlock( GDI_HeapSel, handle );
 521             ptr = NULL;
 522         }
 523     }
 524     else  /* large heap handle */
 525     {
 526         int i = (handle >> 2) - FIRST_LARGE_HANDLE;
 527         if (i >= 0)
 528         {
 529             ptr = large_handles[i];
 530             if (ptr && (magic != MAGIC_DONTCARE) && (GDIMAGIC(ptr->wMagic) != magic)) ptr = NULL;
 531         }
 532     }
 533
 534     if (!ptr)
 535     {
 536         _LeaveSysLevel( &GDI_level );
 537         SetLastError( ERROR_INVALID_HANDLE );
 538     }
 539     else TRACE_SEC( handle, "enter" );
 540
 541     return ptr;
 542 }
 543
 544
 545 /***********************************************************************
 546  *           GDI_ReleaseObj
 547  *
 548  */
 549 void GDI_ReleaseObj( HGDIOBJ handle )
 550 {
 551     if (handle < FIRST_STOCK_HANDLE && (handle & 2)) LOCAL_Unlock( GDI_HeapSel, handle );
 552     TRACE_SEC( handle, "leave" );
 553     _LeaveSysLevel( &GDI_level );
 554 }
 555
 556
 557 /***********************************************************************
 558  *           DeleteObject16    (GDI.69)
 559  */
 560 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
 561 {
 562     return DeleteObject( obj );
 563 }
 564
 565
 566 /***********************************************************************
 567  *           DeleteObject    (GDI32.70)
 568  */
 569 BOOL WINAPI DeleteObject( HGDIOBJ obj )
 570 {
 571       /* Check if object is valid */
 572
 573     GDIOBJHDR * header;
 574     if (HIWORD(obj)) return FALSE;
 575     if ((obj >= FIRST_STOCK_HANDLE) && (obj <= LAST_STOCK_HANDLE)) {
 576         TRACE("Preserving Stock object %04x\n", obj );
 577         /* NOTE: No GDI_Release is necessary */
 578         return TRUE;
 579     }
 580     if (obj == hPseudoStockBitmap) return TRUE;
 581     if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
 582
 583     if (!(header->wMagic & OBJECT_NOSYSTEM)
 584     &&   (header->wMagic >= FIRST_MAGIC) && (header->wMagic <= LAST_MAGIC))
 585     {
 586         TRACE("Preserving system object %04x\n", obj);
 587         GDI_ReleaseObj( obj );
 588         return TRUE;
 589     }
 590
 591     TRACE("%04x\n", obj );
 592
 593       /* Delete object */
 594
 595     switch(GDIMAGIC(header->wMagic))
 596     {
 597       case PEN_MAGIC:     return GDI_FreeObject( obj, header );
 598       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 599       case FONT_MAGIC:    return GDI_FreeObject( obj, header );
 600       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 601       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 602       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 603       case DC_MAGIC:
 604           GDI_ReleaseObj( obj );
 605           return DeleteDC(obj);
 606       case 0 :
 607         WARN("Already deleted\n");
 608         break;
 609       default:
 610         WARN("Unknown magic number (%d)\n",GDIMAGIC(header->wMagic));
 611     }
 612     GDI_ReleaseObj( obj );
 613     return FALSE;
 614 }
 615
 616 /***********************************************************************
 617  *           GetStockObject16    (GDI.87)
 618  */
 619 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
 620 {
 621     return (HGDIOBJ16)GetStockObject( obj );
 622 }
 623
 624
 625 /***********************************************************************
 626  *           GetStockObject    (GDI32.220)
 627  */
 628 HGDIOBJ WINAPI GetStockObject( INT obj )
 629 {
 630     HGDIOBJ ret;
 631     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 632     if (!StockObjects[obj]) return 0;
 633     ret = (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
 634     TRACE("returning %4x\n", ret );
 635     return ret;
 636 }
 637
 638
 639 /***********************************************************************
 640  *           GetObject16    (GDI.82)
 641  */
 642 INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 643 {
 644     GDIOBJHDR * ptr;
 645     INT16 result = 0;
 646     TRACE("%04x %d %p\n", handle, count, buffer );
 647     if (!count) return 0;
 648
 649     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 650
 651     switch(GDIMAGIC(ptr->wMagic))
 652       {
 653       case PEN_MAGIC:
 654         result = PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
 655         break;
 656       case BRUSH_MAGIC:
 657         result = BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
 658         break;
 659       case BITMAP_MAGIC:
 660         result = BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 661         break;
 662       case FONT_MAGIC:
 663         result = FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
 664
 665         /*
 666          * Fix the LOGFONT structure for the stock fonts
 667          */
 668         if ( (handle >= FIRST_STOCK_HANDLE) &&
 669              (handle <= LAST_STOCK_HANDLE) )
 670           FixStockFontSize16(handle, count, buffer);
 671         break;
 672       case PALETTE_MAGIC:
 673         result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 674         break;
 675       }
 676     GDI_ReleaseObj( handle );
 677     return result;
 678 }
 679
 680
 681 /***********************************************************************
 682  *           GetObjectA    (GDI32.204)
 683  */
 684 INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
 685 {
 686     GDIOBJHDR * ptr;
 687     INT result = 0;
 688     TRACE("%08x %d %p\n", handle, count, buffer );
 689     if (!count) return 0;
 690
 691     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 692
 693     switch(GDIMAGIC(ptr->wMagic))
 694     {
 695       case PEN_MAGIC:
 696           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 697           break;
 698       case BRUSH_MAGIC:
 699           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 700           break;
 701       case BITMAP_MAGIC:
 702           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 703           break;
 704       case FONT_MAGIC:
 705           result = FONT_GetObjectA( (FONTOBJ *)ptr, count, buffer );
 706
 707           /*
 708            * Fix the LOGFONT structure for the stock fonts
 709            */
 710           if ( (handle >= FIRST_STOCK_HANDLE) &&
 711                (handle <= LAST_STOCK_HANDLE) )
 712             FixStockFontSizeA(handle, count, buffer);
 713           break;
 714       case PALETTE_MAGIC:
 715           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 716           break;
 717
 718       case REGION_MAGIC:
 719       case DC_MAGIC:
 720       case DISABLED_DC_MAGIC:
 721       case META_DC_MAGIC:
 722       case METAFILE_MAGIC:
 723       case METAFILE_DC_MAGIC:
 724       case ENHMETAFILE_MAGIC:
 725       case ENHMETAFILE_DC_MAGIC:
 726           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 727           break;
 728
 729       default:
 730           ERR("Invalid GDI Magic %04x\n", GDIMAGIC(ptr->wMagic));
 731           break;
 732     }
 733     GDI_ReleaseObj( handle );
 734     return result;
 735 }
 736
 737 /***********************************************************************
 738  *           GetObjectW    (GDI32.206)
 739  */
 740 INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
 741 {
 742     GDIOBJHDR * ptr;
 743     INT result = 0;
 744     TRACE("%08x %d %p\n", handle, count, buffer );
 745     if (!count) return 0;
 746
 747     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 748
 749     switch(GDIMAGIC(ptr->wMagic))
 750     {
 751       case PEN_MAGIC:
 752           result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 753           break;
 754       case BRUSH_MAGIC:
 755           result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 756           break;
 757       case BITMAP_MAGIC:
 758           result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 759           break;
 760       case FONT_MAGIC:
 761           result = FONT_GetObjectW( (FONTOBJ *)ptr, count, buffer );
 762
 763           /*
 764            * Fix the LOGFONT structure for the stock fonts
 765            */
 766           if ( (handle >= FIRST_STOCK_HANDLE) &&
 767                (handle <= LAST_STOCK_HANDLE) )
 768             FixStockFontSizeW(handle, count, buffer);
 769           break;
 770       case PALETTE_MAGIC:
 771           result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 772           break;
 773       default:
 774           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 775           break;
 776     }
 777     GDI_ReleaseObj( handle );
 778     return result;
 779 }
 780
 781 /***********************************************************************
 782  *           GetObjectType    (GDI32.205)
 783  */
 784 DWORD WINAPI GetObjectType( HANDLE handle )
 785 {
 786     GDIOBJHDR * ptr;
 787     INT result = 0;
 788     TRACE("%08x\n", handle );
 789
 790     if (!(ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE ))) return 0;
 791
 792     switch(GDIMAGIC(ptr->wMagic))
 793     {
 794       case PEN_MAGIC:
 795           result = OBJ_PEN;
 796           break;
 797       case BRUSH_MAGIC:
 798           result = OBJ_BRUSH;
 799           break;
 800       case BITMAP_MAGIC:
 801           result = OBJ_BITMAP;
 802           break;
 803       case FONT_MAGIC:
 804           result = OBJ_FONT;
 805           break;
 806       case PALETTE_MAGIC:
 807           result = OBJ_PAL;
 808           break;
 809       case REGION_MAGIC:
 810           result = OBJ_REGION;
 811           break;
 812       case DC_MAGIC:
 813           result = OBJ_DC;
 814           break;
 815       case META_DC_MAGIC:
 816           result = OBJ_METADC;
 817           break;
 818       case METAFILE_MAGIC:
 819           result = OBJ_METAFILE;
 820           break;
 821       case METAFILE_DC_MAGIC:
 822           result = OBJ_METADC;
 823           break;
 824       case ENHMETAFILE_MAGIC:
 825           result = OBJ_ENHMETAFILE;
 826           break;
 827       case ENHMETAFILE_DC_MAGIC:
 828           result = OBJ_ENHMETADC;
 829           break;
 830       default:
 831           FIXME("Magic %04x not implemented\n", GDIMAGIC(ptr->wMagic) );
 832           break;
 833     }
 834     GDI_ReleaseObj( handle );
 835     return result;
 836 }
 837
 838 /***********************************************************************
 839  *           GetCurrentObject           (GDI32.166)
 840  */
 841 HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
 842 {
 843     HANDLE ret = 0;
 844     DC * dc = DC_GetDCPtr( hdc );
 845
 846     if (dc)
 847     {
 848     switch (type) {
 849         case OBJ_PEN:    ret = dc->hPen; break;
 850         case OBJ_BRUSH:  ret = dc->hBrush; break;
 851         case OBJ_PAL:    ret = dc->hPalette; break;
 852         case OBJ_FONT:   ret = dc->hFont; break;
 853         case OBJ_BITMAP: ret = dc->hBitmap; break;
 854     default:
 855         /* the SDK only mentions those above */
 856         FIXME("(%08x,%d): unknown type.\n",hdc,type);
 857             break;
 858         }
 859         GDI_ReleaseObj( hdc );
 860     }
 861     return ret;
 862 }
 863
 864
 865 /***********************************************************************
 866  *           SelectObject16    (GDI.45)
 867  */
 868 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
 869 {
 870     return (HGDIOBJ16)SelectObject( hdc, handle );
 871 }
 872
 873
 874 /***********************************************************************
 875  *           SelectObject    (GDI32.299)
 876  */
 877 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
 878 {
 879     HGDIOBJ ret = 0;
 880     DC * dc = DC_GetDCUpdate( hdc );
 881     if (!dc) return 0;
 882     TRACE("hdc=%04x %04x\n", hdc, handle );
 883     if (dc->funcs->pSelectObject)
 884         ret = dc->funcs->pSelectObject( dc, handle );
 885     GDI_ReleaseObj( hdc );
 886     return ret;
 887 }
 888
 889
 890 /***********************************************************************
 891  *           UnrealizeObject16    (GDI.150)
 892  */
 893 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
 894 {
 895     return UnrealizeObject( obj );
 896 }
 897
 898
 899 /***********************************************************************
 900  *           UnrealizeObject    (GDI32.358)
 901  */
 902 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
 903 {
 904     BOOL result = TRUE;
 905   /* Check if object is valid */
 906
 907     GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
 908     if (!header) return FALSE;
 909
 910     TRACE("%04x\n", obj );
 911
 912       /* Unrealize object */
 913
 914     switch(GDIMAGIC(header->wMagic))
 915     {
 916     case PALETTE_MAGIC:
 917         result = PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 918         break;
 919
 920     case BRUSH_MAGIC:
 921         /* Windows resets the brush origin. We don't need to. */
 922         break;
 923     }
 924     GDI_ReleaseObj( obj );
 925     return result;
 926 }
 927
 928
 929 /***********************************************************************
 930  *           EnumObjects16    (GDI.71)
 931  */
 932 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
 933                             GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
 934 {
 935     /* Solid colors to enumerate */
 936     static const COLORREF solid_colors[] =
 937     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 938       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 939       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 940       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 941       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 942       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 943       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 944       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 945     };
 946
 947     INT16 i, retval = 0;
 948     LOGPEN16 *pen;
 949     LOGBRUSH16 *brush = NULL;
 950
 951     TRACE("%04x %d %08lx %08lx\n",
 952                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 953     switch(nObjType)
 954     {
 955     case OBJ_PEN:
 956         /* Enumerate solid pens */
 957         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 958         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 959         {
 960             pen->lopnStyle   = PS_SOLID;
 961             pen->lopnWidth.x = 1;
 962             pen->lopnWidth.y = 0;
 963             pen->lopnColor   = solid_colors[i];
 964             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 965             TRACE("solid pen %08lx, ret=%d\n",
 966                          solid_colors[i], retval);
 967             if (!retval) break;
 968         }
 969         SEGPTR_FREE(pen);
 970         break;
 971
 972     case OBJ_BRUSH:
 973         /* Enumerate solid brushes */
 974         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 975         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 976         {
 977             brush->lbStyle = BS_SOLID;
 978             brush->lbColor = solid_colors[i];
 979             brush->lbHatch = 0;
 980             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 981             TRACE("solid brush %08lx, ret=%d\n",
 982                          solid_colors[i], retval);
 983             if (!retval) break;
 984         }
 985
 986         /* Now enumerate hatched brushes */
 987         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 988         {
 989             brush->lbStyle = BS_HATCHED;
 990             brush->lbColor = RGB(0,0,0);
 991             brush->lbHatch = i;
 992             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 993             TRACE("hatched brush %d, ret=%d\n",
 994                          i, retval);
 995             if (!retval) break;
 996         }
 997         SEGPTR_FREE(brush);
 998         break;
 999
1000     default:
1001         WARN("(%d): Invalid type\n", nObjType );
1002         break;
1003     }
1004     return retval;
1005 }
1006
1007
1008 /***********************************************************************
1009  *           EnumObjects    (GDI32.89)
1010  */
1011 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
1012                             GOBJENUMPROC lpEnumFunc, LPARAM lParam )
1013 {
1014     /* Solid colors to enumerate */
1015     static const COLORREF solid_colors[] =
1016     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
1017       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
1018       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
1019       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
1020       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
1021       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
1022       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
1023       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
1024     };
1025
1026     INT i, retval = 0;
1027     LOGPEN pen;
1028     LOGBRUSH brush;
1029
1030     TRACE("%04x %d %08lx %08lx\n",
1031                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
1032     switch(nObjType)
1033     {
1034     case OBJ_PEN:
1035         /* Enumerate solid pens */
1036         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1037         {
1038             pen.lopnStyle   = PS_SOLID;
1039             pen.lopnWidth.x = 1;
1040             pen.lopnWidth.y = 0;
1041             pen.lopnColor   = solid_colors[i];
1042             retval = lpEnumFunc( &pen, lParam );
1043             TRACE("solid pen %08lx, ret=%d\n",
1044                          solid_colors[i], retval);
1045             if (!retval) break;
1046         }
1047         break;
1048
1049     case OBJ_BRUSH:
1050         /* Enumerate solid brushes */
1051         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
1052         {
1053             brush.lbStyle = BS_SOLID;
1054             brush.lbColor = solid_colors[i];
1055             brush.lbHatch = 0;
1056             retval = lpEnumFunc( &brush, lParam );
1057             TRACE("solid brush %08lx, ret=%d\n",
1058                          solid_colors[i], retval);
1059             if (!retval) break;
1060         }
1061
1062         /* Now enumerate hatched brushes */
1063         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
1064         {
1065             brush.lbStyle = BS_HATCHED;
1066             brush.lbColor = RGB(0,0,0);
1067             brush.lbHatch = i;
1068             retval = lpEnumFunc( &brush, lParam );
1069             TRACE("hatched brush %d, ret=%d\n",
1070                          i, retval);
1071             if (!retval) break;
1072         }
1073         break;
1074
1075     default:
1076         /* FIXME: implement Win32 types */
1077         WARN("(%d): Invalid type\n", nObjType );
1078         break;
1079     }
1080     return retval;
1081 }
1082
1083
1084 /***********************************************************************
1085  *           IsGDIObject    (GDI.462)
1086  *
1087  * returns type of object if valid (W95 system programming secrets p. 264-5)
1088  */
1089 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
1090 {
1091     UINT16 magic = 0;
1092
1093     GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1094     if (object)
1095     {
1096         magic = GDIMAGIC(object->wMagic) - PEN_MAGIC + 1;
1097         GDI_ReleaseObj( handle );
1098     }
1099     return magic;
1100 }
1101
1102
1103 /***********************************************************************
1104  *           SetObjectOwner16    (GDI.461)
1105  */
1106 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
1107 {
1108     /* Nothing to do */
1109 }
1110
1111
1112 /***********************************************************************
1113  *           SetObjectOwner    (GDI32.386)
1114  */
1115 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
1116 {
1117     /* Nothing to do */
1118 }
1119
1120
1121 /***********************************************************************
1122  *           MakeObjectPrivate    (GDI.463)
1123  *
1124  * What does that mean ?
1125  * Some little docu can be found in "Undocumented Windows",
1126  * but this is basically useless.
1127  * At least we know that this flags the GDI object's wMagic
1128  * with 0x2000 (OBJECT_PRIVATE), so we just do it.
1129  * But Wine doesn't react on that yet.
1130  */
1131 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle, BOOL16 private )
1132 {
1133     GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
1134     if (!ptr)
1135     {
1136         ERR("invalid GDI object %04x !\n", handle);
1137         return;
1138     }
1139     ptr->wMagic |= OBJECT_PRIVATE;
1140     GDI_ReleaseObj( handle );
1141 }
1142
1143
1144 /***********************************************************************
1145  *           GdiFlush    (GDI32.128)
1146  */
1147 BOOL WINAPI GdiFlush(void)
1148 {
1149     return TRUE;  /* FIXME */
1150 }
1151
1152
1153 /***********************************************************************
1154  *           GdiGetBatchLimit    (GDI32.129)
1155  */
1156 DWORD WINAPI GdiGetBatchLimit(void)
1157 {
1158     return 1;  /* FIXME */
1159 }
1160
1161
1162 /***********************************************************************
1163  *           GdiSetBatchLimit    (GDI32.139)
1164  */
1165 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
1166 {
1167     return 1; /* FIXME */
1168 }
1169
1170
1171 /***********************************************************************
1172  *           GdiSeeGdiDo   (GDI.452)
1173  */
1174 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
1175                           WORD wParam3 )
1176 {
1177     switch (wReqType)
1178     {
1179     case 0x0001:  /* LocalAlloc */
1180         return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
1181     case 0x0002:  /* LocalFree */
1182         return LOCAL_Free( GDI_HeapSel, wParam1 );
1183     case 0x0003:  /* LocalCompact */
1184         return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
1185     case 0x0103:  /* LocalHeap */
1186         return GDI_HeapSel;
1187     default:
1188         WARN("(wReqType=%04x): Unknown\n", wReqType);
1189         return (DWORD)-1;
1190     }
1191 }
1192
1193 /***********************************************************************
1194  *           GdiSignalProc     (GDI.610)
1195  */
1196 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
1197                            DWORD dwFlags, HMODULE16 hModule )
1198 {
1199     return 0;
1200 }
1201
1202 /***********************************************************************
1203  *           FinalGdiInit16     (GDI.405)
1204  */
1205 void WINAPI FinalGdiInit16( HANDLE16 unknown )
1206 {
1207 }
1208
1209 /***********************************************************************
1210  *           GdiFreeResources   (GDI.609)
1211  */
1212 WORD WINAPI GdiFreeResources16( DWORD reserve )
1213 {
1214    return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
1215                   (int)LOCAL_HeapSize( GDI_HeapSel ) );
1216 }
1217
1218 /***********************************************************************
1219  *           MulDiv16   (GDI.128)
1220  */
1221 INT16 WINAPI MulDiv16(
1222              INT16 nMultiplicand,
1223              INT16 nMultiplier,
1224              INT16 nDivisor)
1225 {
1226     INT ret;
1227     if (!nDivisor) return -32768;
1228     /* We want to deal with a positive divisor to simplify the logic. */
1229     if (nDivisor < 0)
1230     {
1231       nMultiplicand = - nMultiplicand;
1232       nDivisor = -nDivisor;
1233     }
1234     /* If the result is positive, we "add" to round. else,
1235      * we subtract to round. */
1236     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
1237          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
1238         ret = (((int)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1239     else
1240         ret = (((int)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
1241     if ((ret > 32767) || (ret < -32767)) return -32768;
1242     return (INT16) ret;
1243 }
1244
1245
1246 /*******************************************************************
1247  *      GetColorAdjustment [GDI32.164]
1248  *
1249  *
1250  */
1251 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1252 {
1253         FIXME("GetColorAdjustment, stub\n");
1254         return 0;
1255 }
1256
1257 /*******************************************************************
1258  *      GetMiterLimit [GDI32.201]
1259  *
1260  *
1261  */
1262 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1263 {
1264         FIXME("GetMiterLimit, stub\n");
1265         return 0;
1266 }
1267
1268 /*******************************************************************
1269  *      SetMiterLimit [GDI32.325]
1270  *
1271  *
1272  */
1273 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1274 {
1275         FIXME("SetMiterLimit, stub\n");
1276         return 0;
1277 }
1278
1279 /*******************************************************************
1280  *      GdiComment [GDI32.109]
1281  *
1282  *
1283  */
1284 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1285 {
1286         FIXME("GdiComment, stub\n");
1287         return 0;
1288 }
1289 /*******************************************************************
1290  *      SetColorAdjustment [GDI32.309]
1291  *
1292  *
1293  */
1294 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1295 {
1296         FIXME("SetColorAdjustment, stub\n");
1297         return 0;
1298 }
1299