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