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 "heap.h"
  15 #include "module.h"
  16 #include "palette.h"
  17 #include "pen.h"
  18 #include "region.h"
  19 #include "callback.h"
  20 #include "stddebug.h"
  21 #include "debug.h"
  22 #include "xmalloc.h"
  23
  24 WORD GDI_HeapSel = 0;
  25
  26 /* Object types for EnumObjects() */
  27 #define OBJ_PEN             1
  28 #define OBJ_BRUSH           2
  29
  30 /***********************************************************************
  31  *          GDI stock objects
  32  */
  33
  34 static BRUSHOBJ WhiteBrush =
  35 {
  36     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  37     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  38 };
  39
  40 static BRUSHOBJ LtGrayBrush =
  41 {
  42     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  43     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  44 };
  45
  46 static BRUSHOBJ GrayBrush =
  47 {
  48     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  49     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  50 };
  51
  52 static BRUSHOBJ DkGrayBrush =
  53 {
  54     { 0, BRUSH_MAGIC, 1, 0 },       /* header */
  55     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  56 };
  57
  58 static BRUSHOBJ BlackBrush =
  59 {
  60     { 0, BRUSH_MAGIC, 1, 0 },    /* header */
  61     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  62 };
  63
  64 static BRUSHOBJ NullBrush =
  65 {
  66     { 0, BRUSH_MAGIC, 1, 0 },  /* header */
  67     { BS_NULL, 0, 0 }          /* logbrush */
  68 };
  69
  70 static PENOBJ WhitePen =
  71 {
  72     { 0, PEN_MAGIC, 1, 0 },                  /* header */
  73     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  74 };
  75
  76 static PENOBJ BlackPen =
  77 {
  78     { 0, PEN_MAGIC, 1, 0 },            /* header */
  79     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  80 };
  81
  82 static PENOBJ NullPen =
  83 {
  84     { 0, PEN_MAGIC, 1, 0 },   /* header */
  85     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  86 };
  87
  88 static FONTOBJ OEMFixedFont =
  89 {
  90     { 0, FONT_MAGIC, 1, 0 },   /* header */
  91     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  92       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  93 };
  94
  95 static FONTOBJ AnsiFixedFont =
  96 {
  97     { 0, FONT_MAGIC, 1, 0 },   /* header */
  98     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  99       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 100 };
 101
 102 static FONTOBJ AnsiVarFont =
 103 {
 104     { 0, FONT_MAGIC, 1, 0 },   /* header */
 105     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 106       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 107 };
 108
 109 static FONTOBJ SystemFont =
 110 {
 111     { 0, FONT_MAGIC, 1, 0 },   /* header */
 112     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 113       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 114 };
 115
 116 static FONTOBJ DeviceDefaultFont =
 117 {
 118     { 0, FONT_MAGIC, 1, 0 },   /* header */
 119     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 120       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 121 };
 122
 123 static FONTOBJ SystemFixedFont =
 124 {
 125     { 0, FONT_MAGIC, 1, 0 },   /* header */
 126     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 127       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 128 };
 129
 130
 131 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 132 {
 133     (GDIOBJHDR *) &WhiteBrush,
 134     (GDIOBJHDR *) &LtGrayBrush,
 135     (GDIOBJHDR *) &GrayBrush,
 136     (GDIOBJHDR *) &DkGrayBrush,
 137     (GDIOBJHDR *) &BlackBrush,
 138     (GDIOBJHDR *) &NullBrush,
 139     (GDIOBJHDR *) &WhitePen,
 140     (GDIOBJHDR *) &BlackPen,
 141     (GDIOBJHDR *) &NullPen,
 142     NULL,
 143     (GDIOBJHDR *) &OEMFixedFont,
 144     (GDIOBJHDR *) &AnsiFixedFont,
 145     (GDIOBJHDR *) &AnsiVarFont,
 146     (GDIOBJHDR *) &SystemFont,
 147     (GDIOBJHDR *) &DeviceDefaultFont,
 148     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 149     (GDIOBJHDR *) &SystemFixedFont
 150 };
 151
 152 static FARPROC16 defDCHookCallback;
 153
 154
 155 /***********************************************************************
 156  *           GDI_Init
 157  *
 158  * GDI initialization.
 159  */
 160 BOOL32 GDI_Init(void)
 161 {
 162     HPALETTE16 hpalette;
 163
 164     defDCHookCallback = (FARPROC16)MODULE_GetEntryPoint(GetModuleHandle("USER"),
 165                                                         362  /* DCHook */ );
 166     dprintf_gdi( stddeb, "DCHook: 16-bit callback is %08x\n",
 167                  (unsigned)defDCHookCallback );
 168
 169       /* Create default palette */
 170
 171     if (!(hpalette = COLOR_Init())) return FALSE;
 172     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hpalette );
 173
 174       /* Create default bitmap */
 175
 176     if (!BITMAP_Init()) return FALSE;
 177
 178       /* Initialize brush dithering */
 179
 180     if (!BRUSH_Init()) return FALSE;
 181
 182       /* Initialize fonts */
 183
 184     if (!FONT_Init()) return FALSE;
 185
 186     return TRUE;
 187 }
 188
 189
 190 /***********************************************************************
 191  *           GDI_GetDefDCHook
 192  */
 193 FARPROC16 GDI_GetDefDCHook(void)
 194 {
 195     return defDCHookCallback;
 196 }
 197
 198
 199 /***********************************************************************
 200  *           GDI_AllocObject
 201  */
 202 HANDLE16 GDI_AllocObject( WORD size, WORD magic )
 203 {
 204     static DWORD count = 0;
 205     GDIOBJHDR * obj;
 206     HANDLE handle = GDI_HEAP_ALLOC( size );
 207     if (!handle) return 0;
 208     obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 209     obj->hNext   = 0;
 210     obj->wMagic  = magic;
 211     obj->dwCount = ++count;
 212     return handle;
 213 }
 214
 215
 216 /***********************************************************************
 217  *           GDI_FreeObject
 218  */
 219 BOOL32 GDI_FreeObject( HANDLE16 handle )
 220 {
 221     GDIOBJHDR * object;
 222
 223       /* Can't free stock objects */
 224     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 225         return TRUE;
 226
 227     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 228     if (!object) return FALSE;
 229     object->wMagic = 0;  /* Mark it as invalid */
 230
 231       /* Free object */
 232
 233     GDI_HEAP_FREE( handle );
 234     return TRUE;
 235 }
 236
 237 /***********************************************************************
 238  *           GDI_GetObjPtr
 239  *
 240  * Return a pointer to the GDI object associated to the handle.
 241  * Return NULL if the object has the wrong magic number.
 242  */
 243 GDIOBJHDR * GDI_GetObjPtr( HANDLE16 handle, WORD magic )
 244 {
 245     GDIOBJHDR * ptr = NULL;
 246
 247     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 248       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 249     else
 250       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 251     if (!ptr) return NULL;
 252     if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) return NULL;
 253     return ptr;
 254 }
 255
 256
 257 /***********************************************************************
 258  *           DeleteObject    (GDI.69)
 259  */
 260 BOOL DeleteObject( HGDIOBJ16 obj )
 261 {
 262       /* Check if object is valid */
 263
 264     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 265     if (!header) return FALSE;
 266
 267     dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
 268
 269       /* Delete object */
 270
 271     switch(header->wMagic)
 272     {
 273       case PEN_MAGIC:     return GDI_FreeObject( obj );
 274       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
 275       case FONT_MAGIC:    return GDI_FreeObject( obj );
 276       case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 277       case BITMAP_MAGIC:  return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
 278       case REGION_MAGIC:  return REGION_DeleteObject( obj, (RGNOBJ*)header );
 279     }
 280     return FALSE;
 281 }
 282
 283
 284 /***********************************************************************
 285  *           GetStockObject    (GDI.87)
 286  */
 287 HANDLE GetStockObject( int obj )
 288 {
 289     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 290     if (!StockObjects[obj]) return 0;
 291     dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
 292                 FIRST_STOCK_HANDLE + obj );
 293     return (HANDLE)(FIRST_STOCK_HANDLE + obj);
 294 }
 295
 296
 297 /***********************************************************************
 298  *           GetObject16    (GDI.82)
 299  */
 300 INT16 GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 301 {
 302     GDIOBJHDR * ptr = NULL;
 303     dprintf_gdi(stddeb, "GetObject16: %04x %d %p\n", handle, count, buffer );
 304     if (!count) return 0;
 305
 306     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 307       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 308     else
 309       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 310     if (!ptr) return 0;
 311
 312     switch(ptr->wMagic)
 313     {
 314       case PEN_MAGIC:
 315           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 316       case BRUSH_MAGIC:
 317           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 318       case BITMAP_MAGIC:
 319           return BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 320       case FONT_MAGIC:
 321           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 322       case PALETTE_MAGIC:
 323           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 324     }
 325     return 0;
 326 }
 327
 328
 329 /***********************************************************************
 330  *           GetObject32A    (GDI32.204)
 331  */
 332 INT32 GetObject32A( HANDLE32 handle, INT32 count, LPVOID buffer )
 333 {
 334     GDIOBJHDR * ptr = NULL;
 335     dprintf_gdi(stddeb, "GetObject32A: %08x %d %p\n", handle, count, buffer );
 336     if (!count) return 0;
 337
 338     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 339       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 340     else
 341       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 342     if (!ptr) return 0;
 343
 344     switch(ptr->wMagic)
 345     {
 346       case BITMAP_MAGIC:
 347           return BITMAP_GetObject32( (BITMAPOBJ *)ptr, count, buffer );
 348       case PEN_MAGIC:
 349       case BRUSH_MAGIC:
 350       case FONT_MAGIC:
 351       case PALETTE_MAGIC:
 352           fprintf( stderr, "GetObject32: magic %04x not implemented\n",
 353                    ptr->wMagic );
 354           break;
 355     }
 356     return 0;
 357 }
 358
 359
 360 /***********************************************************************
 361  *           GetObject32W    (GDI32.206)
 362  */
 363 INT32 GetObject32W( HANDLE32 handle, INT32 count, LPVOID buffer )
 364 {
 365     return GetObject32A( handle, count, buffer );
 366 }
 367
 368
 369 /***********************************************************************
 370  *           SelectObject    (GDI.45)
 371  */
 372 HANDLE SelectObject( HDC hdc, HANDLE handle )
 373 {
 374     GDIOBJHDR * ptr = NULL;
 375     DC * dc;
 376
 377     dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", hdc, handle );
 378     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 379       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 380     else
 381       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 382     if (!ptr) return 0;
 383
 384     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 385     if (!dc)
 386     {
 387         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 388         if (!dc) return 0;
 389     }
 390
 391     switch(ptr->wMagic)
 392     {
 393       case PEN_MAGIC:
 394           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 395       case BRUSH_MAGIC:
 396           return BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
 397       case BITMAP_MAGIC:
 398           return BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
 399       case FONT_MAGIC:
 400           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 401       case REGION_MAGIC:
 402           return (HANDLE)SelectClipRgn( hdc, handle );
 403     }
 404     return 0;
 405 }
 406
 407
 408 /***********************************************************************
 409  *           UnrealizeObject    (GDI.150)
 410  */
 411 BOOL UnrealizeObject( HANDLE obj )
 412 {
 413       /* Check if object is valid */
 414
 415     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 416     if (!header) return FALSE;
 417
 418     dprintf_gdi( stddeb, "UnrealizeObject: %04x\n", obj );
 419
 420       /* Unrealize object */
 421
 422     switch(header->wMagic)
 423     {
 424     case PALETTE_MAGIC:
 425         return PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 426
 427     case BRUSH_MAGIC:
 428         /* Windows resets the brush origin. We don't need to. */
 429         break;
 430     }
 431     return TRUE;
 432 }
 433
 434
 435 /***********************************************************************
 436  *           EnumObjects    (GDI.71)
 437  */
 438 INT EnumObjects( HDC hdc, INT nObjType, GOBJENUMPROC lpEnumFunc, LPARAM lParam )
 439 {
 440     /* Solid colors to enumerate */
 441     static const COLORREF solid_colors[] =
 442     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 443       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 444       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 445       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 446       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 447       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 448       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 449       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 450     };
 451
 452     int i, retval = 0;
 453     LOGPEN16 *pen;
 454     LOGBRUSH16 *brush = NULL;
 455
 456     dprintf_gdi( stddeb, "EnumObjects: %04x %d %08lx %08lx\n",
 457                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 458     switch(nObjType)
 459     {
 460     case OBJ_PEN:
 461         /* Enumerate solid pens */
 462         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 463         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 464         {
 465             pen->lopnStyle   = PS_SOLID;
 466             pen->lopnWidth.x = 1;
 467             pen->lopnWidth.y = 0;
 468             pen->lopnColor   = solid_colors[i];
 469             retval = CallEnumObjectsProc( (FARPROC16)lpEnumFunc,
 470                                           SEGPTR_GET(pen), lParam );
 471             dprintf_gdi( stddeb, "EnumObject: solid pen %08lx, ret=%d\n",
 472                          solid_colors[i], retval);
 473             if (!retval) break;
 474         }
 475         SEGPTR_FREE(pen);
 476         break;
 477
 478     case OBJ_BRUSH:
 479         /* Enumerate solid brushes */
 480         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 481         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 482         {
 483             brush->lbStyle = BS_SOLID;
 484             brush->lbColor = solid_colors[i];
 485             brush->lbHatch = 0;
 486             retval = CallEnumObjectsProc( (FARPROC16)lpEnumFunc,
 487                                           SEGPTR_GET(brush), lParam );
 488             dprintf_gdi( stddeb, "EnumObject: solid brush %08lx, ret=%d\n",
 489                          solid_colors[i], retval);
 490             if (!retval) break;
 491         }
 492
 493         /* Now enumerate hatched brushes */
 494         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 495         {
 496             brush->lbStyle = BS_HATCHED;
 497             brush->lbColor = RGB(0,0,0);
 498             brush->lbHatch = i;
 499             retval = CallEnumObjectsProc( (FARPROC16)lpEnumFunc,
 500                                           SEGPTR_GET(brush), lParam );
 501             dprintf_gdi( stddeb, "EnumObject: hatched brush %d, ret=%d\n",
 502                          i, retval);
 503             if (!retval) break;
 504         }
 505         SEGPTR_FREE(brush);
 506         break;
 507
 508     default:
 509         fprintf( stderr, "EnumObjects: invalid type %d\n", nObjType );
 510         break;
 511     }
 512     return retval;
 513 }
 514
 515
 516 /***********************************************************************
 517  *           IsGDIObject    (GDI.462)
 518  */
 519 BOOL IsGDIObject(HANDLE handle)
 520 {
 521     GDIOBJHDR *object;
 522
 523     object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 524     /* FIXME: should check magic here */
 525     return (object != NULL);
 526 }
 527
 528
 529 /***********************************************************************
 530  *           MulDiv16   (GDI.128)
 531  */
 532 INT16 MulDiv16( INT16 foo, INT16 bar, INT16 baz )
 533 {
 534     INT32 ret;
 535     if (!baz) return -32768;
 536     ret = (foo * bar) / baz;
 537     if ((ret > 32767) || (ret < -32767)) return -32768;
 538     return ret;
 539 }
 540
 541
 542 /***********************************************************************
 543  *           MulDiv32   (KERNEL32.391)
 544  */
 545 INT32 MulDiv32( INT32 foo, INT32 bar, INT32 baz )
 546 {
 547 #ifdef __GNUC__
 548     long long ret;
 549     if (!baz) return -1;
 550     ret = ((long long)foo * bar) / baz;
 551     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
 552     return ret;
 553 #else
 554     if (!baz) return -1;
 555     return (foo * bar) / baz;
 556 #endif
 557 }