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
  22 LPSTR GDI_Heap = NULL;
  23 WORD GDI_HeapSel = 0;
  24
  25 /* Object types for EnumObjects() */
  26 #define OBJ_PEN             1
  27 #define OBJ_BRUSH           2
  28
  29 #define MAX_OBJ                         1024
  30 HANDLE *lpPenBrushList = NULL;
  31
  32
  33 /***********************************************************************
  34  *          GDI stock objects
  35  */
  36
  37 static BRUSHOBJ WhiteBrush =
  38 {
  39     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  40     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  41 };
  42
  43 static BRUSHOBJ LtGrayBrush =
  44 {
  45     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  46     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  47 };
  48
  49 static BRUSHOBJ GrayBrush =
  50 {
  51     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  52     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  53 };
  54
  55 static BRUSHOBJ DkGrayBrush =
  56 {
  57     { 0, BRUSH_MAGIC, 1, 0 },       /* header */
  58     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  59 };
  60
  61 static BRUSHOBJ BlackBrush =
  62 {
  63     { 0, BRUSH_MAGIC, 1, 0 },    /* header */
  64     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  65 };
  66
  67 static BRUSHOBJ NullBrush =
  68 {
  69     { 0, BRUSH_MAGIC, 1, 0 },  /* header */
  70     { BS_NULL, 0, 0 }          /* logbrush */
  71 };
  72
  73 static PENOBJ WhitePen =
  74 {
  75     { 0, PEN_MAGIC, 1, 0 },                  /* header */
  76     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  77 };
  78
  79 static PENOBJ BlackPen =
  80 {
  81     { 0, PEN_MAGIC, 1, 0 },            /* header */
  82     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  83 };
  84
  85 static PENOBJ NullPen =
  86 {
  87     { 0, PEN_MAGIC, 1, 0 },   /* header */
  88     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  89 };
  90
  91 static FONTOBJ OEMFixedFont =
  92 {
  93     { 0, FONT_MAGIC, 1, 0 },   /* header */
  94     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  95       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  96 };
  97
  98 static FONTOBJ AnsiFixedFont =
  99 {
 100     { 0, FONT_MAGIC, 1, 0 },   /* header */
 101     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 102       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 103 };
 104
 105 static FONTOBJ AnsiVarFont =
 106 {
 107     { 0, FONT_MAGIC, 1, 0 },   /* header */
 108     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 109       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 110 };
 111
 112 static FONTOBJ SystemFont =
 113 {
 114     { 0, FONT_MAGIC, 1, 0 },   /* header */
 115     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 116       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 117 };
 118
 119 static FONTOBJ DeviceDefaultFont =
 120 {
 121     { 0, FONT_MAGIC, 1, 0 },   /* header */
 122     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 123       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 124 };
 125
 126 static FONTOBJ SystemFixedFont =
 127 {
 128     { 0, FONT_MAGIC, 1, 0 },   /* header */
 129     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 130       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 131 };
 132
 133
 134 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 135 {
 136     (GDIOBJHDR *) &WhiteBrush,
 137     (GDIOBJHDR *) &LtGrayBrush,
 138     (GDIOBJHDR *) &GrayBrush,
 139     (GDIOBJHDR *) &DkGrayBrush,
 140     (GDIOBJHDR *) &BlackBrush,
 141     (GDIOBJHDR *) &NullBrush,
 142     (GDIOBJHDR *) &WhitePen,
 143     (GDIOBJHDR *) &BlackPen,
 144     (GDIOBJHDR *) &NullPen,
 145     NULL,
 146     (GDIOBJHDR *) &OEMFixedFont,
 147     (GDIOBJHDR *) &AnsiFixedFont,
 148     (GDIOBJHDR *) &AnsiVarFont,
 149     (GDIOBJHDR *) &SystemFont,
 150     (GDIOBJHDR *) &DeviceDefaultFont,
 151     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 152     (GDIOBJHDR *) &SystemFixedFont
 153 };
 154
 155
 156 /***********************************************************************
 157  *           GDI_Init
 158  *
 159  * GDI initialisation.
 160  */
 161 BOOL GDI_Init(void)
 162 {
 163     HPALETTE hpalette;
 164
 165 #ifndef WINELIB
 166       /* Create GDI heap */
 167
 168     if (!(GDI_HeapSel = GlobalAlloc(GMEM_FIXED, GDI_HEAP_SIZE))) return FALSE;
 169     GDI_Heap = GlobalLock( GDI_HeapSel );
 170     LocalInit( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
 171 #endif
 172
 173       /* Create default palette */
 174
 175     if (!(hpalette = COLOR_Init())) return FALSE;
 176     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( hpalette );
 177
 178       /* Create default bitmap */
 179
 180     if (!BITMAP_Init()) return FALSE;
 181
 182       /* Initialise brush dithering */
 183
 184     if (!BRUSH_Init()) return FALSE;
 185
 186       /* Initialise fonts */
 187
 188     if (!FONT_Init()) return FALSE;
 189
 190     return TRUE;
 191 }
 192
 193
 194 /***********************************************************************
 195  *           GDI_AppendToPenBrushList
 196  */
 197 BOOL GDI_AppendToPenBrushList(HANDLE hNewObj)
 198 {
 199         HANDLE          *lphObj;
 200         int             i = 1;
 201         if (hNewObj == 0) return FALSE;
 202         if (lpPenBrushList == NULL) {
 203                 lpPenBrushList = malloc(MAX_OBJ * sizeof(HANDLE));
 204                 lpPenBrushList[0] = 0;
 205                 dprintf_gdi(stddeb,"GDI_AppendToPenBrushList() lpPenBrushList allocated !\n");
 206         }
 207         for (lphObj = lpPenBrushList; i < MAX_OBJ; i++) {
 208                 if (*lphObj == 0) {
 209                         *lphObj = hNewObj;
 210                         *(lphObj + 1) = 0;
 211                         dprintf_gdi(stddeb,"GDI_AppendToPenBrushList("NPFMT") appended (count=%d)\n", hNewObj, i);
 212                         return TRUE;
 213                 }
 214                 lphObj++;
 215         }
 216         return FALSE;
 217 }
 218
 219
 220 /***********************************************************************
 221  *           GDI_AllocObject
 222  */
 223 HANDLE GDI_AllocObject( WORD size, WORD magic )
 224 {
 225     static DWORD count = 0;
 226     GDIOBJHDR * obj;
 227     HANDLE handle = GDI_HEAP_ALLOC( size );
 228     if (!handle) return 0;
 229     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 230     obj->hNext   = 0;
 231     obj->wMagic  = magic;
 232     obj->dwCount = ++count;
 233     if (magic == PEN_MAGIC || magic == BRUSH_MAGIC) {
 234       GDI_AppendToPenBrushList(handle);
 235     }
 236     return handle;
 237 }
 238
 239
 240 /***********************************************************************
 241  *           GDI_FreeObject
 242  */
 243 BOOL GDI_FreeObject( HANDLE handle )
 244 {
 245     GDIOBJHDR * object;
 246
 247       /* Can't free stock objects */
 248     if ((DWORD)handle >= FIRST_STOCK_HANDLE &&
 249         (DWORD)handle <= LAST_STOCK_HANDLE   ) return TRUE;
 250
 251     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 252     if (!object) return FALSE;
 253     object->wMagic = 0;  /* Mark it as invalid */
 254
 255       /* Free object */
 256
 257     GDI_HEAP_FREE( handle );
 258     return TRUE;
 259 }
 260
 261 /***********************************************************************
 262  *           GDI_GetObjPtr
 263  *
 264  * Return a pointer to the GDI object associated to the handle.
 265  * Return NULL if the object has the wrong magic number.
 266  */
 267 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 268 {
 269     GDIOBJHDR * ptr = NULL;
 270
 271     if ((DWORD)handle >= FIRST_STOCK_HANDLE &&
 272         (DWORD)handle <= LAST_STOCK_HANDLE   )
 273       ptr = StockObjects[(DWORD)handle - FIRST_STOCK_HANDLE];
 274     else
 275       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 276     if (!ptr) return NULL;
 277     if (ptr->wMagic != magic) return NULL;
 278     return ptr;
 279 }
 280
 281
 282 /***********************************************************************
 283  *           DeleteObject    (GDI.69)
 284  */
 285 BOOL DeleteObject( HANDLE obj )
 286 {
 287       /* Check if object is valid */
 288
 289     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 290     if (!header) return FALSE;
 291
 292     dprintf_gdi(stddeb, "DeleteObject: "NPFMT"\n", obj );
 293
 294       /* Delete object */
 295
 296     switch(header->wMagic)
 297     {
 298       case PEN_MAGIC:     return GDI_FreeObject( obj );
 299       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 300       case FONT_MAGIC:    return GDI_FreeObject( obj );
 301       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 302       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 303       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 304     }
 305     return FALSE;
 306 }
 307
 308
 309 /***********************************************************************
 310  *           GetStockObject    (GDI.87)
 311  */
 312 HANDLE GetStockObject( int obj )
 313 {
 314     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 315     if (!StockObjects[obj]) return 0;
 316     dprintf_gdi(stddeb, "GetStockObject: returning %ld\n",
 317                 (DWORD)FIRST_STOCK_HANDLE + obj );
 318     return (HANDLE)((DWORD)FIRST_STOCK_HANDLE + obj);
 319 }
 320
 321
 322 /***********************************************************************
 323  *           GetObject    (GDI.82)
 324  */
 325 int GetObject( HANDLE handle, int count, LPSTR buffer )
 326 {
 327     GDIOBJHDR * ptr = NULL;
 328     dprintf_gdi(stddeb, "GetObject: "NPFMT" %d %p\n", handle, count, buffer );
 329     if (!count) return 0;
 330
 331     if ((DWORD)handle >= FIRST_STOCK_HANDLE &&
 332         (DWORD)handle <= LAST_STOCK_HANDLE   )
 333       ptr = StockObjects[(DWORD)handle - FIRST_STOCK_HANDLE];
 334     else
 335       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 336     if (!ptr) return 0;
 337
 338     switch(ptr->wMagic)
 339     {
 340       case PEN_MAGIC:
 341           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 342       case BRUSH_MAGIC:
 343           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 344       case BITMAP_MAGIC:
 345           return BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 346       case FONT_MAGIC:
 347           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 348       case PALETTE_MAGIC:
 349           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 350     }
 351     return 0;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           SelectObject    (GDI.45)
 357  */
 358 HANDLE SelectObject( HDC hdc, HANDLE handle )
 359 {
 360     GDIOBJHDR * ptr = NULL;
 361     DC * dc;
 362
 363     dprintf_gdi(stddeb, "SelectObject: "NPFMT" "NPFMT"\n", hdc, handle );
 364     if ((DWORD)handle >= FIRST_STOCK_HANDLE &&
 365         (DWORD)handle <= LAST_STOCK_HANDLE   )
 366       ptr = StockObjects[(DWORD)handle - FIRST_STOCK_HANDLE];
 367     else
 368       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 369     if (!ptr) return 0;
 370
 371     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 372     if (!dc)
 373     {
 374         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 375         if (!dc) return 0;
 376     }
 377
 378     switch(ptr->wMagic)
 379     {
 380       case PEN_MAGIC:
 381           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 382       case BRUSH_MAGIC:
 383           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 384       case BITMAP_MAGIC:
 385           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 386       case FONT_MAGIC:
 387           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 388       case REGION_MAGIC:
 389           return (HANDLE)SelectClipRgn( hdc, handle );
 390     }
 391     return 0;
 392 }
 393
 394
 395 /***********************************************************************
 396  *           UnrealizeObject    (GDI.150)
 397  */
 398 BOOL UnrealizeObject( HANDLE handle )
 399 {
 400     dprintf_gdi(stdnimp, "UnrealizeObject: "NPFMT"\n", handle );
 401     return TRUE;
 402 }
 403
 404
 405 /***********************************************************************
 406  *           EnumObjects    (GDI.71)
 407  */
 408 int EnumObjects(HDC hDC, int nObjType, FARPROC lpEnumFunc, LPSTR lpData)
 409 {
 410   /*    HANDLE          handle;
 411    DC                   *dc;*/
 412   HANDLE        *lphObj;
 413   GDIOBJHDR     *header;
 414   WORD          wMagic;
 415   LPSTR         lpLog;          /* Point to a LOGBRUSH or LOGPEN struct */
 416   HANDLE        hLog;
 417   int           nRet = 0;
 418
 419   if (lpEnumFunc == NULL) {
 420     fprintf(stderr,"EnumObjects // Bad EnumProc callback address !\n");
 421     return 0;
 422   }
 423   switch (nObjType) {
 424    case OBJ_PEN:
 425     wMagic = PEN_MAGIC;
 426     dprintf_gdi(stddeb,"EnumObjects("NPFMT", OBJ_PEN, %08lx, %p);\n",
 427                 hDC, (LONG)lpEnumFunc, lpData);
 428     hLog = GDI_HEAP_ALLOC( sizeof(LOGPEN) );
 429     lpLog = (LPSTR) GDI_HEAP_LIN_ADDR(hLog);
 430     if (lpLog == NULL) {
 431       fprintf(stderr,"EnumObjects // Unable to alloc LOGPEN struct !\n");
 432       return 0;
 433     }
 434     break;
 435    case OBJ_BRUSH:
 436     wMagic = BRUSH_MAGIC;
 437     dprintf_gdi(stddeb,"EnumObjects("NPFMT", OBJ_BRUSH, %08lx, %p);\n",
 438                 hDC, (LONG)lpEnumFunc, lpData);
 439     hLog = GDI_HEAP_ALLOC( sizeof(LOGBRUSH) );
 440     lpLog = (LPSTR) GDI_HEAP_LIN_ADDR(hLog);
 441     if (lpLog == NULL) {
 442       fprintf(stderr,"EnumObjects // Unable to alloc LOGBRUSH struct !\n");
 443       return 0;
 444     }
 445     break;
 446    default:
 447     fprintf(stderr,"EnumObjects("NPFMT", %04X, %08lx, %p); // Unknown OBJ type !\n",
 448             hDC, nObjType, (LONG)lpEnumFunc, lpData);
 449     return 0;
 450   }
 451 #ifdef notdef  /* FIXME: stock object ptr won't work in callback */
 452   dprintf_gdi(stddeb,"EnumObjects // Stock Objects first !\n");
 453   for (i = 0; i < NB_STOCK_OBJECTS; i++) {
 454     header = StockObjects[i];
 455     if (header->wMagic == wMagic) {
 456       PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 457       BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH),lpLog);
 458       dprintf_gdi(stddeb,"EnumObjects // StockObj lpLog=%p lpData=%p\n", lpLog, lpData);
 459       if (header->wMagic == BRUSH_MAGIC) {
 460         dprintf_gdi(stddeb,"EnumObjects // StockBrush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 461         dprintf_gdi(stddeb,"EnumObjects // StockBrush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 462         dprintf_gdi(stddeb,"EnumObjects // StockBrush lbHatch=%04X\n", ((LPLOGBRUSH)lpLog)->lbHatch);
 463       }
 464       if (header->wMagic == PEN_MAGIC) {
 465         dprintf_gdi(stddeb,"EnumObjects // StockPen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 466         dprintf_gdi(stddeb,"EnumObjects // StockPen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 467         dprintf_gdi(stddeb,"EnumObjects // StockPen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 468       }
 469       nRet = CallEnumObjectsProc( lpEnumFunc,
 470                                  GDI_HEAP_SEG_ADDR(hLog),
 471                                  (int)lpData );
 472       dprintf_gdi(stddeb,"EnumObjects // after Callback!\n");
 473       if (nRet == 0) {
 474         GDI_HEAP_FREE(hLog);
 475         dprintf_gdi(stddeb,"EnumObjects // EnumEnd requested by application !\n");
 476         return 0;
 477       }
 478     }
 479   }
 480   dprintf_gdi(stddeb,"EnumObjects // Now DC owned objects %p !\n", header);
 481 #endif  /* notdef */
 482
 483   if (lpPenBrushList == NULL) return 0;
 484   for (lphObj = lpPenBrushList; *lphObj != 0; ) {
 485     dprintf_gdi(stddeb,"EnumObjects // *lphObj="NPFMT"\n", *lphObj);
 486     header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR(*lphObj++);
 487     if (header->wMagic == wMagic) {
 488       dprintf_gdi(stddeb,"EnumObjects // DC_Obj lpLog=%p lpData=%p\n", lpLog, lpData);
 489       if (header->wMagic == BRUSH_MAGIC) {
 490         BRUSH_GetObject( (BRUSHOBJ *)header, sizeof(LOGBRUSH), lpLog);
 491         dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbStyle=%04X\n", ((LPLOGBRUSH)lpLog)->lbStyle);
 492         dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbColor=%08lX\n", ((LPLOGBRUSH)lpLog)->lbColor);
 493         dprintf_gdi(stddeb,"EnumObjects // DC_Brush lbHatch=%04lX\n", (LONG)((LPLOGBRUSH)lpLog)->lbHatch);
 494       }
 495       if (header->wMagic == PEN_MAGIC) {
 496         PEN_GetObject( (PENOBJ *)header, sizeof(LOGPEN), lpLog);
 497         dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnStyle=%04X\n", ((LPLOGPEN)lpLog)->lopnStyle);
 498         dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnWidth=%d\n", ((LPLOGPEN)lpLog)->lopnWidth.x);
 499         dprintf_gdi(stddeb,"EnumObjects // DC_Pen lopnColor=%08lX\n", ((LPLOGPEN)lpLog)->lopnColor);
 500       }
 501       nRet = CallEnumObjectsProc(lpEnumFunc, GDI_HEAP_SEG_ADDR(hLog),
 502                                  (LONG)lpData);
 503       if (nRet == 0)
 504         break;
 505     }
 506   }
 507   GDI_HEAP_FREE(hLog);
 508   dprintf_gdi(stddeb,"EnumObjects // End of enumeration !\n");
 509   return nRet;
 510 }
 511
 512 /***********************************************************************
 513  *              IsGDIObject(GDI.462)
 514  */
 515 BOOL IsGDIObject(HANDLE handle)
 516 {
 517         GDIOBJHDR *object;
 518
 519         object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 520         if (object)
 521                 return TRUE;
 522         else
 523                 return FALSE;
 524 }