objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include "gdi.h"
  10 #include "color.h"
  11 #include "bitmap.h"
  12 #include "brush.h"
  13 #include "font.h"
  14 #include "palette.h"
  15 #include "pen.h"
  16 #include "region.h"
  17 #include "callback.h"
  18 #include "stddebug.h"
  19 /* #define DEBUG_GDI */
  20 #include "debug.h"
  21 #include "xmalloc.h"
  22
  23 LPSTR GDI_Heap = NULL;
  24 WORD GDI_HeapSel = 0;
  25
  26 /* Object types for EnumObjects() */
  27 #define OBJ_PEN             1
  28 #define OBJ_BRUSH           2
  29
  30 #define MAX_OBJ                         1024
  31 HANDLE *lpPenBrushList = NULL;
  32
  33
  34 /***********************************************************************
  35  *          GDI stock objects
  36  */
  37
  38 static BRUSHOBJ WhiteBrush =
  39 {
  40     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  41     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  42 };
  43
  44 static BRUSHOBJ LtGrayBrush =
  45 {
  46     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  47     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  48 };
  49
  50 static BRUSHOBJ GrayBrush =
  51 {
  52     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  53     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  54 };
  55
  56 static BRUSHOBJ DkGrayBrush =
  57 {
  58     { 0, BRUSH_MAGIC, 1, 0 },       /* header */
  59     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  60 };
  61
  62 static BRUSHOBJ BlackBrush =
  63 {
  64     { 0, BRUSH_MAGIC, 1, 0 },    /* header */
  65     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  66 };
  67
  68 static BRUSHOBJ NullBrush =
  69 {
  70     { 0, BRUSH_MAGIC, 1, 0 },  /* header */
  71     { BS_NULL, 0, 0 }          /* logbrush */
  72 };
  73
  74 static PENOBJ WhitePen =
  75 {
  76     { 0, PEN_MAGIC, 1, 0 },                  /* header */
  77     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  78 };
  79
  80 static PENOBJ BlackPen =
  81 {
  82     { 0, PEN_MAGIC, 1, 0 },            /* header */
  83     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  84 };
  85
  86 static PENOBJ NullPen =
  87 {
  88     { 0, PEN_MAGIC, 1, 0 },   /* header */
  89     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  90 };
  91
  92 static FONTOBJ OEMFixedFont =
  93 {
  94     { 0, FONT_MAGIC, 1, 0 },   /* header */
  95     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  96       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  97 };
  98
  99 static FONTOBJ AnsiFixedFont =
 100 {
 101     { 0, FONT_MAGIC, 1, 0 },   /* header */
 102     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 103       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 104 };
 105
 106 static FONTOBJ AnsiVarFont =
 107 {
 108     { 0, FONT_MAGIC, 1, 0 },   /* header */
 109     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 110       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 111 };
 112
 113 static FONTOBJ SystemFont =
 114 {
 115     { 0, FONT_MAGIC, 1, 0 },   /* header */
 116     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 117       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 118 };
 119
 120 static FONTOBJ DeviceDefaultFont =
 121 {
 122     { 0, FONT_MAGIC, 1, 0 },   /* header */
 123     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 124       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 125 };
 126
 127 static FONTOBJ SystemFixedFont =
 128 {
 129     { 0, FONT_MAGIC, 1, 0 },   /* header */
 130     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 131       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 132 };
 133
 134
 135 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 136 {
 137     (GDIOBJHDR *) &WhiteBrush,
 138     (GDIOBJHDR *) &LtGrayBrush,
 139     (GDIOBJHDR *) &GrayBrush,
 140     (GDIOBJHDR *) &DkGrayBrush,
 141     (GDIOBJHDR *) &BlackBrush,
 142     (GDIOBJHDR *) &NullBrush,
 143     (GDIOBJHDR *) &WhitePen,
 144     (GDIOBJHDR *) &BlackPen,
 145     (GDIOBJHDR *) &NullPen,
 146     NULL,
 147     (GDIOBJHDR *) &OEMFixedFont,
 148     (GDIOBJHDR *) &AnsiFixedFont,
 149     (GDIOBJHDR *) &AnsiVarFont,
 150     (GDIOBJHDR *) &SystemFont,
 151     (GDIOBJHDR *) &DeviceDefaultFont,
 152     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 153     (GDIOBJHDR *) &SystemFixedFont
 154 };
 155
 156
 157 /***********************************************************************
 158  *           GDI_Init
 159  *
 160  * GDI initialisation.
 161  */
 162 BOOL GDI_Init(void)
 163 {
 164     HPALETTE hpalette;
 165
 166 #ifndef WINELIB
 167       /* Create GDI heap */
 168
 169     if (!(GDI_HeapSel = GlobalAlloc(GMEM_FIXED, GDI_HEAP_SIZE))) return FALSE;
 170     GDI_Heap = GlobalLock( GDI_HeapSel );
 171     LocalInit( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
 172 #endif
 173
 174       /* Create default palette */
 175
 176     if (!(hpalette = COLOR_Init())) return FALSE;
 177     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hpalette );
 178
 179       /* Create default bitmap */
 180
 181     if (!BITMAP_Init()) return FALSE;
 182
 183       /* Initialise brush dithering */
 184
 185     if (!BRUSH_Init()) return FALSE;
 186
 187       /* Initialise fonts */
 188
 189     if (!FONT_Init()) return FALSE;
 190
 191     return TRUE;
 192 }
 193
 194
 195 /***********************************************************************
 196  *           GDI_AllocObject
 197  */
 198 HANDLE GDI_AllocObject( WORD size, WORD magic )
 199 {
 200     static DWORD count = 0;
 201     GDIOBJHDR * obj;
 202     HANDLE handle = GDI_HEAP_ALLOC( size );
 203     if (!handle) return 0;
 204     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 205     obj->hNext   = 0;
 206     obj->wMagic  = magic;
 207     obj->dwCount = ++count;
 208     return handle;
 209 }
 210
 211
 212 /***********************************************************************
 213  *           GDI_FreeObject
 214  */
 215 BOOL GDI_FreeObject( HANDLE handle )
 216 {
 217     GDIOBJHDR * object;
 218
 219       /* Can't free stock objects */
 220     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 221         return TRUE;
 222
 223     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 224     if (!object) return FALSE;
 225     object->wMagic = 0;  /* Mark it as invalid */
 226
 227       /* Free object */
 228
 229     GDI_HEAP_FREE( handle );
 230     return TRUE;
 231 }
 232
 233 /***********************************************************************
 234  *           GDI_GetObjPtr
 235  *
 236  * Return a pointer to the GDI object associated to the handle.
 237  * Return NULL if the object has the wrong magic number.
 238  */
 239 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 240 {
 241     GDIOBJHDR * ptr = NULL;
 242
 243     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 244       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 245     else
 246       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 247     if (!ptr) return NULL;
 248     if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) return NULL;
 249     return ptr;
 250 }
 251
 252
 253 /***********************************************************************
 254  *           DeleteObject    (GDI.69)
 255  */
 256 BOOL DeleteObject( HGDIOBJ obj )
 257 {
 258       /* Check if object is valid */
 259
 260     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 261     if (!header) return FALSE;
 262
 263     dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
 264
 265       /* Delete object */
 266
 267     switch(header->wMagic)
 268     {
 269       case PEN_MAGIC:     return GDI_FreeObject( obj );
 270       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 271       case FONT_MAGIC:    return GDI_FreeObject( obj );
 272       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 273       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 274       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 275     }
 276     return FALSE;
 277 }
 278
 279
 280 /***********************************************************************
 281  *           GetStockObject    (GDI.87)
 282  */
 283 HANDLE GetStockObject( int obj )
 284 {
 285     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 286     if (!StockObjects[obj]) return 0;
 287     dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
 288                 FIRST_STOCK_HANDLE + obj );
 289     return (HANDLE)(FIRST_STOCK_HANDLE + obj);
 290 }
 291
 292
 293 /***********************************************************************
 294  *           GetObject    (GDI.82)
 295  */
 296 int GetObject( HANDLE handle, int count, LPSTR buffer )
 297 {
 298     GDIOBJHDR * ptr = NULL;
 299     dprintf_gdi(stddeb, "GetObject: %04x %d %p\n", handle, count, buffer );
 300     if (!count) return 0;
 301
 302     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 303       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 304     else
 305       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 306     if (!ptr) return 0;
 307
 308     switch(ptr->wMagic)
 309     {
 310       case PEN_MAGIC:
 311           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 312       case BRUSH_MAGIC:
 313           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 314       case BITMAP_MAGIC:
 315           return BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 316       case FONT_MAGIC:
 317           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 318       case PALETTE_MAGIC:
 319           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 320     }
 321     return 0;
 322 }
 323
 324
 325 /***********************************************************************
 326  *           SelectObject    (GDI.45)
 327  */
 328 HANDLE SelectObject( HDC hdc, HANDLE handle )
 329 {
 330     GDIOBJHDR * ptr = NULL;
 331     DC * dc;
 332
 333     dprintf_gdi(stddeb, "SelectObject: %04x %04x\n", hdc, handle );
 334     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 335       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 336     else
 337       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 338     if (!ptr) return 0;
 339
 340     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 341     if (!dc)
 342     {
 343         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 344         if (!dc) return 0;
 345     }
 346
 347     switch(ptr->wMagic)
 348     {
 349       case PEN_MAGIC:
 350           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 351       case BRUSH_MAGIC:
 352           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 353       case BITMAP_MAGIC:
 354           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 355       case FONT_MAGIC:
 356           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 357       case REGION_MAGIC:
 358           return (HANDLE)SelectClipRgn( hdc, handle );
 359     }
 360     return 0;
 361 }
 362
 363
 364 /***********************************************************************
 365  *           UnrealizeObject    (GDI.150)
 366  */
 367 BOOL UnrealizeObject( HANDLE handle )
 368 {
 369     dprintf_gdi(stdnimp, "UnrealizeObject: %04x\n", handle );
 370     return TRUE;
 371 }
 372
 373
 374 /***********************************************************************
 375  *           EnumObjects    (GDI.71)
 376  */
 377 INT EnumObjects( HDC hdc, INT nObjType, GOBJENUMPROC lpEnumFunc, LPARAM lParam )
 378 {
 379     /* Solid colors to enumerate */
 380     static const COLORREF solid_colors[] =
 381     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 382       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 383       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 384       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 385       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 386       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 387       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 388       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 389     };
 390
 391     int i, retval = 0;
 392
 393     dprintf_gdi( stddeb, "EnumObjects: %04x %d %08lx %08lx\n",
 394                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 395     switch(nObjType)
 396     {
 397     case OBJ_PEN:
 398         /* Enumerate solid pens */
 399         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 400         {
 401             LOGPEN pen = { PS_SOLID, { 1, 0 }, solid_colors[i] };
 402             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&pen),
 403                                           lParam );
 404             dprintf_gdi( stddeb, "EnumObject: solid pen %08lx, ret=%d\n",
 405                          solid_colors[i], retval);
 406             if (!retval) break;
 407         }
 408         break;
 409
 410     case OBJ_BRUSH:
 411         /* Enumerate solid brushes */
 412         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 413         {
 414             LOGBRUSH brush = { BS_SOLID, solid_colors[i], 0 };
 415             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&brush),
 416                                           lParam );
 417             dprintf_gdi( stddeb, "EnumObject: solid brush %08lx, ret=%d\n",
 418                          solid_colors[i], retval);
 419             if (!retval) break;
 420         }
 421         if (!retval) break;
 422
 423         /* Now enumerate hatched brushes */
 424         for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 425         {
 426             LOGBRUSH brush = { BS_HATCHED, RGB(0,0,0), i };
 427             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&brush),
 428                                           lParam );
 429             dprintf_gdi( stddeb, "EnumObject: hatched brush %d, ret=%d\n",
 430                          i, retval);
 431             if (!retval) break;
 432         }
 433         break;
 434
 435     default:
 436         fprintf( stderr, "EnumObjects: invalid type %d\n", nObjType );
 437         break;
 438     }
 439     return retval;
 440 }
 441
 442
 443 /***********************************************************************
 444  *           IsGDIObject    (GDI.462)
 445  */
 446 BOOL IsGDIObject(HANDLE handle)
 447 {
 448     GDIOBJHDR *object;
 449
 450     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 451     /* FIXME: should check magic here */
 452     return (object != NULL);
 453 }