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 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       /* Create default palette */
 166
 167     if (!(hpalette = COLOR_Init())) return FALSE;
 168     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hpalette );
 169
 170       /* Create default bitmap */
 171
 172     if (!BITMAP_Init()) return FALSE;
 173
 174       /* Initialise brush dithering */
 175
 176     if (!BRUSH_Init()) return FALSE;
 177
 178       /* Initialise fonts */
 179
 180     if (!FONT_Init()) return FALSE;
 181
 182     return TRUE;
 183 }
 184
 185
 186 /***********************************************************************
 187  *           GDI_AllocObject
 188  */
 189 HANDLE GDI_AllocObject( WORD size, WORD magic )
 190 {
 191     static DWORD count = 0;
 192     GDIOBJHDR * obj;
 193     HANDLE handle = GDI_HEAP_ALLOC( size );
 194     if (!handle) return 0;
 195     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 196     obj->hNext   = 0;
 197     obj->wMagic  = magic;
 198     obj->dwCount = ++count;
 199     return handle;
 200 }
 201
 202
 203 /***********************************************************************
 204  *           GDI_FreeObject
 205  */
 206 BOOL GDI_FreeObject( HANDLE handle )
 207 {
 208     GDIOBJHDR * object;
 209
 210       /* Can't free stock objects */
 211     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 212         return TRUE;
 213
 214     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 215     if (!object) return FALSE;
 216     object->wMagic = 0;  /* Mark it as invalid */
 217
 218       /* Free object */
 219
 220     GDI_HEAP_FREE( handle );
 221     return TRUE;
 222 }
 223
 224 /***********************************************************************
 225  *           GDI_GetObjPtr
 226  *
 227  * Return a pointer to the GDI object associated to the handle.
 228  * Return NULL if the object has the wrong magic number.
 229  */
 230 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 231 {
 232     GDIOBJHDR * ptr = NULL;
 233
 234     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 235       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 236     else
 237       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 238     if (!ptr) return NULL;
 239     if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) return NULL;
 240     return ptr;
 241 }
 242
 243
 244 /***********************************************************************
 245  *           DeleteObject    (GDI.69)
 246  */
 247 BOOL DeleteObject( HGDIOBJ obj )
 248 {
 249       /* Check if object is valid */
 250
 251     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 252     if (!header) return FALSE;
 253
 254     dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
 255
 256       /* Delete object */
 257
 258     switch(header->wMagic)
 259     {
 260       case PEN_MAGIC:     return GDI_FreeObject( obj );
 261       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 262       case FONT_MAGIC:    return GDI_FreeObject( obj );
 263       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 264       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 265       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 266     }
 267     return FALSE;
 268 }
 269
 270
 271 /***********************************************************************
 272  *           GetStockObject    (GDI.87)
 273  */
 274 HANDLE GetStockObject( int obj )
 275 {
 276     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 277     if (!StockObjects[obj]) return 0;
 278     dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
 279                 FIRST_STOCK_HANDLE + obj );
 280     return (HANDLE)(FIRST_STOCK_HANDLE + obj);
 281 }
 282
 283
 284 /***********************************************************************
 285  *           GetObject    (GDI.82)
 286  */
 287 int GetObject( HANDLE handle, int count, LPSTR buffer )
 288 {
 289     GDIOBJHDR * ptr = NULL;
 290     dprintf_gdi(stddeb, "GetObject: %04x %d %p\n", handle, count, buffer );
 291     if (!count) return 0;
 292
 293     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 294       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 295     else
 296       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 297     if (!ptr) return 0;
 298
 299     switch(ptr->wMagic)
 300     {
 301       case PEN_MAGIC:
 302           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 303       case BRUSH_MAGIC:
 304           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 305       case BITMAP_MAGIC:
 306           return BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 307       case FONT_MAGIC:
 308           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 309       case PALETTE_MAGIC:
 310           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 311     }
 312     return 0;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           SelectObject    (GDI.45)
 318  */
 319 HANDLE SelectObject( HDC hdc, HANDLE handle )
 320 {
 321     GDIOBJHDR * ptr = NULL;
 322     DC * dc;
 323
 324     dprintf_gdi(stddeb, "SelectObject: %04x %04x\n", hdc, handle );
 325     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 326       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 327     else
 328       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 329     if (!ptr) return 0;
 330
 331     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 332     if (!dc)
 333     {
 334         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 335         if (!dc) return 0;
 336     }
 337
 338     switch(ptr->wMagic)
 339     {
 340       case PEN_MAGIC:
 341           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 342       case BRUSH_MAGIC:
 343           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 344       case BITMAP_MAGIC:
 345           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 346       case FONT_MAGIC:
 347           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 348       case REGION_MAGIC:
 349           return (HANDLE)SelectClipRgn( hdc, handle );
 350     }
 351     return 0;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           UnrealizeObject    (GDI.150)
 357  */
 358 BOOL UnrealizeObject( HANDLE handle )
 359 {
 360     dprintf_gdi(stdnimp, "UnrealizeObject: %04x\n", handle );
 361     return TRUE;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           EnumObjects    (GDI.71)
 367  */
 368 INT EnumObjects( HDC hdc, INT nObjType, GOBJENUMPROC lpEnumFunc, LPARAM lParam )
 369 {
 370     /* Solid colors to enumerate */
 371     static const COLORREF solid_colors[] =
 372     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 373       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 374       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 375       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 376       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 377       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 378       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 379       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 380     };
 381
 382     int i, retval = 0;
 383
 384     dprintf_gdi( stddeb, "EnumObjects: %04x %d %08lx %08lx\n",
 385                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 386     switch(nObjType)
 387     {
 388     case OBJ_PEN:
 389         /* Enumerate solid pens */
 390         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 391         {
 392             LOGPEN pen = { PS_SOLID, { 1, 0 }, solid_colors[i] };
 393             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&pen),
 394                                           lParam );
 395             dprintf_gdi( stddeb, "EnumObject: solid pen %08lx, ret=%d\n",
 396                          solid_colors[i], retval);
 397             if (!retval) break;
 398         }
 399         break;
 400
 401     case OBJ_BRUSH:
 402         /* Enumerate solid brushes */
 403         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 404         {
 405             LOGBRUSH brush = { BS_SOLID, solid_colors[i], 0 };
 406             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&brush),
 407                                           lParam );
 408             dprintf_gdi( stddeb, "EnumObject: solid brush %08lx, ret=%d\n",
 409                          solid_colors[i], retval);
 410             if (!retval) break;
 411         }
 412         if (!retval) break;
 413
 414         /* Now enumerate hatched brushes */
 415         for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 416         {
 417             LOGBRUSH brush = { BS_HATCHED, RGB(0,0,0), i };
 418             retval = CallEnumObjectsProc( lpEnumFunc, MAKE_SEGPTR(&brush),
 419                                           lParam );
 420             dprintf_gdi( stddeb, "EnumObject: hatched brush %d, ret=%d\n",
 421                          i, retval);
 422             if (!retval) break;
 423         }
 424         break;
 425
 426     default:
 427         fprintf( stderr, "EnumObjects: invalid type %d\n", nObjType );
 428         break;
 429     }
 430     return retval;
 431 }
 432
 433
 434 /***********************************************************************
 435  *           IsGDIObject    (GDI.462)
 436  */
 437 BOOL IsGDIObject(HANDLE handle)
 438 {
 439     GDIOBJHDR *object;
 440
 441     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 442     /* FIXME: should check magic here */
 443     return (object != NULL);
 444 }
 445
 446
 447 /***********************************************************************
 448  *           MulDiv16   (GDI.128)
 449  */
 450 INT16 MulDiv16( INT16 foo, INT16 bar, INT16 baz )
 451 {
 452     INT32 ret;
 453     if (!baz) return -32768;
 454     ret = (foo * bar) / baz;
 455     if ((ret > 32767) || (ret < -32767)) return -32768;
 456     return ret;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           MulDiv32   (KERNEL32.391)
 462  */
 463 INT32 MulDiv32( INT32 foo, INT32 bar, INT32 baz )
 464 {
 465 #ifdef __GNUC__
 466     long long ret;
 467     if (!baz) return -1;
 468     ret = ((long long)foo * bar) / baz;
 469     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
 470     return ret;
 471 #else
 472     if (!baz) return -1;
 473     return (foo * bar) / baz;
 474 #endif
 475 }