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