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 "palette.h"
  16 #include "pen.h"
  17 #include "region.h"
  18 #include "stddebug.h"
  19 #include "debug.h"
  20 #include "xmalloc.h"
  21
  22 WORD GDI_HeapSel = 0;
  23
  24 /* Object types for EnumObjects() */
  25 #define OBJ_PEN             1
  26 #define OBJ_BRUSH           2
  27
  28 /***********************************************************************
  29  *          GDI stock objects
  30  */
  31
  32 static BRUSHOBJ WhiteBrush =
  33 {
  34     { 0, BRUSH_MAGIC, 1 },             /* header */
  35     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  36 };
  37
  38 static BRUSHOBJ LtGrayBrush =
  39 {
  40     { 0, BRUSH_MAGIC, 1 },             /* header */
  41     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  42 };
  43
  44 static BRUSHOBJ GrayBrush =
  45 {
  46     { 0, BRUSH_MAGIC, 1 },             /* header */
  47     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  48 };
  49
  50 static BRUSHOBJ DkGrayBrush =
  51 {
  52     { 0, BRUSH_MAGIC, 1 },          /* header */
  53     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  54 };
  55
  56 static BRUSHOBJ BlackBrush =
  57 {
  58     { 0, BRUSH_MAGIC, 1 },       /* header */
  59     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  60 };
  61
  62 static BRUSHOBJ NullBrush =
  63 {
  64     { 0, BRUSH_MAGIC, 1 },  /* header */
  65     { BS_NULL, 0, 0 }       /* logbrush */
  66 };
  67
  68 static PENOBJ WhitePen =
  69 {
  70     { 0, PEN_MAGIC, 1 },                     /* header */
  71     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  72 };
  73
  74 static PENOBJ BlackPen =
  75 {
  76     { 0, PEN_MAGIC, 1 },               /* header */
  77     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  78 };
  79
  80 static PENOBJ NullPen =
  81 {
  82     { 0, PEN_MAGIC, 1 },      /* header */
  83     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  84 };
  85
  86 static FONTOBJ OEMFixedFont =
  87 {
  88     { 0, FONT_MAGIC, 1 },   /* header */
  89     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  90       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  91 };
  92
  93 static FONTOBJ AnsiFixedFont =
  94 {
  95     { 0, FONT_MAGIC, 1 },   /* header */
  96     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  97       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  98 };
  99
 100 static FONTOBJ AnsiVarFont =
 101 {
 102     { 0, FONT_MAGIC, 1 },   /* header */
 103     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 104       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 105 };
 106
 107 static FONTOBJ SystemFont =
 108 {
 109     { 0, FONT_MAGIC, 1 },   /* header */
 110     { 12, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 111       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 112 };
 113
 114 static FONTOBJ DeviceDefaultFont =
 115 {
 116     { 0, FONT_MAGIC, 1 },   /* header */
 117     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 118       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 119 };
 120
 121 static FONTOBJ SystemFixedFont =
 122 {
 123     { 0, FONT_MAGIC, 1 },   /* header */
 124     { 12, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
 125       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 126 };
 127
 128
 129 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 130 {
 131     (GDIOBJHDR *) &WhiteBrush,
 132     (GDIOBJHDR *) &LtGrayBrush,
 133     (GDIOBJHDR *) &GrayBrush,
 134     (GDIOBJHDR *) &DkGrayBrush,
 135     (GDIOBJHDR *) &BlackBrush,
 136     (GDIOBJHDR *) &NullBrush,
 137     (GDIOBJHDR *) &WhitePen,
 138     (GDIOBJHDR *) &BlackPen,
 139     (GDIOBJHDR *) &NullPen,
 140     NULL,
 141     (GDIOBJHDR *) &OEMFixedFont,
 142     (GDIOBJHDR *) &AnsiFixedFont,
 143     (GDIOBJHDR *) &AnsiVarFont,
 144     (GDIOBJHDR *) &SystemFont,
 145     (GDIOBJHDR *) &DeviceDefaultFont,
 146     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 147     (GDIOBJHDR *) &SystemFixedFont
 148 };
 149
 150
 151 /***********************************************************************
 152  *           GDI_Init
 153  *
 154  * GDI initialization.
 155  */
 156 BOOL32 GDI_Init(void)
 157 {
 158     HPALETTE16 hpalette;
 159     extern BOOL32 X11DRV_Init(void);
 160
 161     /* Initialize drivers */
 162
 163     if (!X11DRV_Init()) return FALSE;
 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       /* Initialize brush dithering */
 175
 176     if (!BRUSH_Init()) return FALSE;
 177
 178       /* Initialize fonts */
 179
 180     if (!FONT_Init()) return FALSE;
 181
 182     return TRUE;
 183 }
 184
 185
 186 /***********************************************************************
 187  *           GDI_AllocObject
 188  */
 189 HGDIOBJ16 GDI_AllocObject( WORD size, WORD magic )
 190 {
 191     static DWORD count = 0;
 192     GDIOBJHDR * obj;
 193     HGDIOBJ16 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 BOOL32 GDI_FreeObject( HGDIOBJ16 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( HGDIOBJ16 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( HGDIOBJ16 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 PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
 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 HGDIOBJ16 GetStockObject( INT16 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 (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
 281 }
 282
 283
 284 /***********************************************************************
 285  *           GetObject16    (GDI.82)
 286  */
 287 INT16 GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
 288 {
 289     GDIOBJHDR * ptr = NULL;
 290     dprintf_gdi(stddeb, "GetObject16: %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_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
 307       case FONT_MAGIC:
 308           return FONT_GetObject16( (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  *           GetObject32A    (GDI32.204)
 318  */
 319 INT32 GetObject32A( HANDLE32 handle, INT32 count, LPVOID buffer )
 320 {
 321     GDIOBJHDR * ptr = NULL;
 322     dprintf_gdi(stddeb, "GetObject32A: %08x %d %p\n", handle, count, buffer );
 323     if (!count) return 0;
 324
 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     switch(ptr->wMagic)
 332     {
 333       case BITMAP_MAGIC:
 334           return BITMAP_GetObject32( (BITMAPOBJ *)ptr, count, buffer );
 335       case FONT_MAGIC:
 336           return FONT_GetObject32A( (FONTOBJ *)ptr, count, buffer );
 337       case PEN_MAGIC:
 338       case BRUSH_MAGIC:
 339       case PALETTE_MAGIC:
 340           fprintf( stderr, "GetObject32: magic %04x not implemented\n",
 341                    ptr->wMagic );
 342           break;
 343     }
 344     return 0;
 345 }
 346
 347
 348 /***********************************************************************
 349  *           GetObject32W    (GDI32.206)
 350  */
 351 INT32 GetObject32W( HANDLE32 handle, INT32 count, LPVOID buffer )
 352 {
 353     return GetObject32A( handle, count, buffer );
 354 }
 355
 356
 357 /***********************************************************************
 358  *           SelectObject    (GDI.45)
 359  */
 360 HGDIOBJ16 SelectObject( HDC hdc, HGDIOBJ16 handle )
 361 {
 362     GDIOBJHDR * ptr = NULL;
 363     DC * dc;
 364
 365     dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", hdc, handle );
 366     if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
 367       ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 368     else
 369       ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 370     if (!ptr) return 0;
 371
 372     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 373     if (!dc)
 374     {
 375         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 376         if (!dc) return 0;
 377     }
 378
 379     switch(ptr->wMagic)
 380     {
 381       case PEN_MAGIC:
 382           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 383       case BRUSH_MAGIC:
 384           return BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
 385       case BITMAP_MAGIC:
 386           return BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
 387       case FONT_MAGIC:
 388           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 389       case REGION_MAGIC:
 390           return (HGDIOBJ16)SelectClipRgn( hdc, handle );
 391     }
 392     return 0;
 393 }
 394
 395
 396 /***********************************************************************
 397  *           UnrealizeObject    (GDI.150)
 398  */
 399 BOOL UnrealizeObject( HGDIOBJ16 obj )
 400 {
 401       /* Check if object is valid */
 402
 403     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
 404     if (!header) return FALSE;
 405
 406     dprintf_gdi( stddeb, "UnrealizeObject: %04x\n", obj );
 407
 408       /* Unrealize object */
 409
 410     switch(header->wMagic)
 411     {
 412     case PALETTE_MAGIC:
 413         return PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
 414
 415     case BRUSH_MAGIC:
 416         /* Windows resets the brush origin. We don't need to. */
 417         break;
 418     }
 419     return TRUE;
 420 }
 421
 422
 423 /***********************************************************************
 424  *           EnumObjects    (GDI.71)
 425  */
 426 INT EnumObjects( HDC hdc, INT nObjType, GOBJENUMPROC16 lpEnumFunc,
 427                  LPARAM lParam )
 428 {
 429     /* Solid colors to enumerate */
 430     static const COLORREF solid_colors[] =
 431     { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
 432       RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
 433       RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
 434       RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
 435       RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
 436       RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
 437       RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
 438       RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
 439     };
 440
 441     int i, retval = 0;
 442     LOGPEN16 *pen;
 443     LOGBRUSH16 *brush = NULL;
 444
 445     dprintf_gdi( stddeb, "EnumObjects: %04x %d %08lx %08lx\n",
 446                  hdc, nObjType, (DWORD)lpEnumFunc, lParam );
 447     switch(nObjType)
 448     {
 449     case OBJ_PEN:
 450         /* Enumerate solid pens */
 451         if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
 452         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 453         {
 454             pen->lopnStyle   = PS_SOLID;
 455             pen->lopnWidth.x = 1;
 456             pen->lopnWidth.y = 0;
 457             pen->lopnColor   = solid_colors[i];
 458             retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
 459             dprintf_gdi( stddeb, "EnumObject: solid pen %08lx, ret=%d\n",
 460                          solid_colors[i], retval);
 461             if (!retval) break;
 462         }
 463         SEGPTR_FREE(pen);
 464         break;
 465
 466     case OBJ_BRUSH:
 467         /* Enumerate solid brushes */
 468         if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
 469         for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
 470         {
 471             brush->lbStyle = BS_SOLID;
 472             brush->lbColor = solid_colors[i];
 473             brush->lbHatch = 0;
 474             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 475             dprintf_gdi( stddeb, "EnumObject: solid brush %08lx, ret=%d\n",
 476                          solid_colors[i], retval);
 477             if (!retval) break;
 478         }
 479
 480         /* Now enumerate hatched brushes */
 481         if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
 482         {
 483             brush->lbStyle = BS_HATCHED;
 484             brush->lbColor = RGB(0,0,0);
 485             brush->lbHatch = i;
 486             retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
 487             dprintf_gdi( stddeb, "EnumObject: hatched brush %d, ret=%d\n",
 488                          i, retval);
 489             if (!retval) break;
 490         }
 491         SEGPTR_FREE(brush);
 492         break;
 493
 494     default:
 495         fprintf( stderr, "EnumObjects: invalid type %d\n", nObjType );
 496         break;
 497     }
 498     return retval;
 499 }
 500
 501
 502 /***********************************************************************
 503  *           IsGDIObject    (GDI.462)
 504  */
 505 BOOL16 IsGDIObject( HGDIOBJ16 handle )
 506 {
 507     GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
 508     if (object)
 509       return (object->wMagic>=PEN_MAGIC && object->wMagic<= METAFILE_DC_MAGIC);
 510     return FALSE;
 511 }
 512
 513
 514 /***********************************************************************
 515  *           MulDiv16   (GDI.128)
 516  */
 517 INT16 MulDiv16( INT16 foo, INT16 bar, INT16 baz )
 518 {
 519     INT32 ret;
 520     if (!baz) return -32768;
 521     ret = (foo * bar) / baz;
 522     if ((ret > 32767) || (ret < -32767)) return -32768;
 523     return ret;
 524 }
 525
 526
 527 /***********************************************************************
 528  *           MulDiv32   (KERNEL32.391)
 529  */
 530 INT32 MulDiv32( INT32 foo, INT32 bar, INT32 baz )
 531 {
 532 #ifdef __GNUC__
 533     long long ret;
 534     if (!baz) return -1;
 535     ret = ((long long)foo * bar) / baz;
 536     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
 537     return ret;
 538 #else
 539     if (!baz) return -1;
 540     return (foo * bar) / baz;
 541 #endif
 542 }