objects/gdiobj.c

   1 /*
   2  * GDI functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include "gdi.h"
  12 #include "prototypes.h"
  13
  14 MDESC *GDI_Heap = NULL;
  15
  16 extern HPALETTE COLOR_Init();  /* color.c */
  17
  18 /***********************************************************************
  19  *          GDI stock objects
  20  */
  21
  22 static BRUSHOBJ WhiteBrush =
  23 {
  24     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  25     { BS_SOLID, RGB(255,255,255), 0 }  /* logbrush */
  26 };
  27
  28 static BRUSHOBJ LtGrayBrush =
  29 {
  30     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  31     { BS_SOLID, RGB(192,192,192), 0 }  /* logbrush */
  32 };
  33
  34 static BRUSHOBJ GrayBrush =
  35 {
  36     { 0, BRUSH_MAGIC, 1, 0 },          /* header */
  37     { BS_SOLID, RGB(128,128,128), 0 }  /* logbrush */
  38 };
  39
  40 static BRUSHOBJ DkGrayBrush =
  41 {
  42     { 0, BRUSH_MAGIC, 1, 0 },       /* header */
  43     { BS_SOLID, RGB(64,64,64), 0 }  /* logbrush */
  44 };
  45
  46 static BRUSHOBJ BlackBrush =
  47 {
  48     { 0, BRUSH_MAGIC, 1, 0 },    /* header */
  49     { BS_SOLID, RGB(0,0,0), 0 }  /* logbrush */
  50 };
  51
  52 static BRUSHOBJ NullBrush =
  53 {
  54     { 0, BRUSH_MAGIC, 1, 0 },  /* header */
  55     { BS_NULL, 0, 0 }          /* logbrush */
  56 };
  57
  58 static PENOBJ WhitePen =
  59 {
  60     { 0, PEN_MAGIC, 1, 0 },                  /* header */
  61     { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
  62 };
  63
  64 static PENOBJ BlackPen =
  65 {
  66     { 0, PEN_MAGIC, 1, 0 },            /* header */
  67     { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
  68 };
  69
  70 static PENOBJ NullPen =
  71 {
  72     { 0, PEN_MAGIC, 1, 0 },   /* header */
  73     { PS_NULL, { 1, 0 }, 0 }  /* logpen */
  74 };
  75
  76 static FONTOBJ OEMFixedFont =
  77 {
  78     { 0, FONT_MAGIC, 1, 0 },   /* header */
  79     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
  80       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  81 };
  82
  83 static FONTOBJ AnsiFixedFont =
  84 {
  85     { 0, FONT_MAGIC, 1, 0 },   /* header */
  86     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  87       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
  88 };
  89
  90 static FONTOBJ AnsiVarFont =
  91 {
  92     { 0, FONT_MAGIC, 1, 0 },   /* header */
  93     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  94       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
  95 };
  96
  97 static FONTOBJ SystemFont =
  98 {
  99     { 0, FONT_MAGIC, 1, 0 },   /* header */
 100     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 101       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 102 };
 103
 104 static FONTOBJ DeviceDefaultFont =
 105 {
 106     { 0, FONT_MAGIC, 1, 0 },   /* header */
 107     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 108       0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
 109 };
 110
 111 static FONTOBJ SystemFixedFont =
 112 {
 113     { 0, FONT_MAGIC, 1, 0 },   /* header */
 114     { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
 115       0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
 116 };
 117
 118
 119 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
 120 {
 121     (GDIOBJHDR *) &WhiteBrush,
 122     (GDIOBJHDR *) &LtGrayBrush,
 123     (GDIOBJHDR *) &GrayBrush,
 124     (GDIOBJHDR *) &DkGrayBrush,
 125     (GDIOBJHDR *) &BlackBrush,
 126     (GDIOBJHDR *) &NullBrush,
 127     (GDIOBJHDR *) &WhitePen,
 128     (GDIOBJHDR *) &BlackPen,
 129     (GDIOBJHDR *) &NullPen,
 130     NULL,
 131     (GDIOBJHDR *) &OEMFixedFont,
 132     (GDIOBJHDR *) &AnsiFixedFont,
 133     (GDIOBJHDR *) &AnsiVarFont,
 134     (GDIOBJHDR *) &SystemFont,
 135     (GDIOBJHDR *) &DeviceDefaultFont,
 136     NULL,            /* DEFAULT_PALETTE created by COLOR_Init */
 137     (GDIOBJHDR *) &SystemFixedFont
 138 };
 139
 140
 141 /***********************************************************************
 142  *           GDI_Init
 143  *
 144  * GDI initialisation.
 145  */
 146 BOOL GDI_Init()
 147 {
 148     HPALETTE hpalette;
 149     struct segment_descriptor_s * s;
 150
 151 #ifndef WINELIB
 152     /* Create GDI heap */
 153
 154     s = (struct segment_descriptor_s *)GetNextSegment( 0, 0x10000 );
 155     if (s == NULL) return FALSE;
 156     HEAP_Init( &GDI_Heap, s->base_addr, GDI_HEAP_SIZE );
 157 #endif
 158
 159       /* Create default palette */
 160
 161     if (!(hpalette = COLOR_Init())) return FALSE;
 162     StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *) GDI_HEAP_ADDR( hpalette );
 163
 164       /* Create default bitmap */
 165
 166     if (!BITMAP_Init()) return FALSE;
 167
 168       /* Initialise regions */
 169
 170     if (!REGION_Init()) return FALSE;
 171
 172       /* Initialise dithering */
 173
 174     if (!DITHER_Init()) return FALSE;
 175
 176     return TRUE;
 177 }
 178
 179
 180 /***********************************************************************
 181  *           GDI_FindPrevObject
 182  *
 183  * Return the GDI object whose hNext field points to obj.
 184  */
 185 HANDLE GDI_FindPrevObject( HANDLE first, HANDLE obj )
 186 {
 187     HANDLE handle;
 188
 189     for (handle = first; handle && (handle != obj); )
 190     {
 191         GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 192         handle = header->hNext;
 193     }
 194     return handle;
 195 }
 196
 197
 198 /***********************************************************************
 199  *           GDI_AllocObject
 200  */
 201 HANDLE GDI_AllocObject( WORD size, WORD magic )
 202 {
 203     static DWORD count = 0;
 204     GDIOBJHDR * obj;
 205     HANDLE handle = GDI_HEAP_ALLOC( GMEM_MOVEABLE, size );
 206     if (!handle) return 0;
 207     obj = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 208     if (obj == NULL) {
 209         printf("GDI_AllocObject // Error trying to get GDI_HEAD_ADDR !\n");
 210         return 0;
 211         }
 212     obj->hNext   = 0;
 213     obj->wMagic  = magic;
 214     obj->dwCount = ++count;
 215     return handle;
 216 }
 217
 218
 219 /***********************************************************************
 220  *           GDI_FreeObject
 221  */
 222 BOOL GDI_FreeObject( HANDLE handle )
 223 {
 224     GDIOBJHDR * object;
 225
 226       /* Can't free stock objects */
 227     if (handle >= FIRST_STOCK_HANDLE) return FALSE;
 228
 229     object = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 230     if (!object) return FALSE;
 231
 232       /* Free object */
 233
 234     GDI_HEAP_FREE( handle );
 235     return TRUE;
 236 }
 237
 238 /***********************************************************************
 239  *           GDI_GetObjPtr
 240  *
 241  * Return a pointer to the GDI object associated to the handle.
 242  * Return NULL if the object has the wrong magic number.
 243  */
 244 GDIOBJHDR * GDI_GetObjPtr( HANDLE handle, WORD magic )
 245 {
 246     GDIOBJHDR * ptr = NULL;
 247
 248     if (handle >= FIRST_STOCK_HANDLE)
 249     {
 250         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 251             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 252     }
 253     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 254     if (!ptr) return NULL;
 255     if (ptr->wMagic != magic) return NULL;
 256     return ptr;
 257 }
 258
 259
 260 /***********************************************************************
 261  *           DeleteObject    (GDI.69)
 262  */
 263 BOOL DeleteObject( HANDLE obj )
 264 {
 265       /* Check if object is valid */
 266
 267     GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_ADDR( obj );
 268     if (!header) return FALSE;
 269
 270 #ifdef DEBUG_GDI
 271     printf( "DeleteObject: %d\n", obj );
 272 #endif
 273
 274       /* Delete object */
 275
 276     switch(header->wMagic)
 277     {
 278       case PEN_MAGIC:     return GDI_FreeObject( obj );
 279       case BRUSH_MAGIC:   return BRUSH_DeleteObject( obj, header );
 280       case FONT_MAGIC:    return GDI_FreeObject( obj );
 281       case PALETTE_MAGIC: return GDI_FreeObject( obj );
 282       case BITMAP_MAGIC:  return BMP_DeleteObject( obj, header );
 283       case REGION_MAGIC:  return REGION_DeleteObject( obj, header );
 284     }
 285     return FALSE;
 286 }
 287
 288
 289 /***********************************************************************
 290  *           GetStockObject    (GDI.87)
 291  */
 292 HANDLE GetStockObject( int obj )
 293 {
 294     if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
 295     if (!StockObjects[obj]) return 0;
 296 #ifdef DEBUG_GDI
 297     printf( "GetStockObject: returning %04x\n", FIRST_STOCK_HANDLE + obj );
 298 #endif
 299     return FIRST_STOCK_HANDLE + obj;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           GetObject    (GDI.82)
 305  */
 306 int GetObject( HANDLE handle, int count, LPSTR buffer )
 307 {
 308     GDIOBJHDR * ptr = NULL;
 309 #ifdef DEBUG_GDI
 310     printf( "GetObject: %04x %d %08x\n", handle, count, buffer );
 311 #endif
 312     if (!count) return 0;
 313
 314     if (handle >= FIRST_STOCK_HANDLE)
 315     {
 316         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 317             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 318     }
 319     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 320     if (!ptr) return 0;
 321
 322     switch(ptr->wMagic)
 323     {
 324       case PEN_MAGIC:
 325           return PEN_GetObject( (PENOBJ *)ptr, count, buffer );
 326       case BRUSH_MAGIC:
 327           return BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
 328       case BITMAP_MAGIC:
 329           return BMP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
 330       case FONT_MAGIC:
 331           return FONT_GetObject( (FONTOBJ *)ptr, count, buffer );
 332       case PALETTE_MAGIC:
 333           return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
 334     }
 335     return 0;
 336 }
 337
 338
 339 /***********************************************************************
 340  *           SelectObject    (GDI.45)
 341  */
 342 HANDLE SelectObject( HDC hdc, HANDLE handle )
 343 {
 344     GDIOBJHDR * ptr = NULL;
 345     DC * dc;
 346
 347 #ifdef DEBUG_GDI
 348     printf( "SelectObject: %d %04x\n", hdc, handle );
 349 #endif
 350     if (handle >= FIRST_STOCK_HANDLE)
 351     {
 352         if (handle < FIRST_STOCK_HANDLE + NB_STOCK_OBJECTS)
 353             ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
 354     }
 355     else ptr = (GDIOBJHDR *) GDI_HEAP_ADDR( handle );
 356     if (!ptr) return 0;
 357
 358     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 359     if (!dc)
 360     {
 361         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 362         if (!dc) return 0;
 363     }
 364
 365     switch(ptr->wMagic)
 366     {
 367       case PEN_MAGIC:
 368           return PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 369       case BRUSH_MAGIC:
 370           return BRUSH_SelectObject( hdc, dc, handle, (BRUSHOBJ *)ptr );
 371       case BITMAP_MAGIC:
 372           return BITMAP_SelectObject( hdc, dc, handle, (BITMAPOBJ *)ptr );
 373       case FONT_MAGIC:
 374           return FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 375       case REGION_MAGIC:
 376           return SelectClipRgn( hdc, handle );
 377     }
 378     return 0;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           UnrealizeObject    (GDI.150)
 384  */
 385 BOOL UnrealizeObject( HANDLE handle )
 386 {
 387 #ifdef DEBUG_GDI
 388     printf( "UnrealizeObject: %04x\n", handle );
 389 #endif
 390     return TRUE;
 391 }