4 * Copyright 1993 Alexandre Julliard
7 #define NO_TRANSITION_TYPES /* This file is Win32-clean */
24 /* Object types for EnumObjects() */
28 /***********************************************************************
32 static BRUSHOBJ WhiteBrush =
34 { 0, BRUSH_MAGIC, 1 }, /* header */
35 { BS_SOLID, RGB(255,255,255), 0 } /* logbrush */
38 static BRUSHOBJ LtGrayBrush =
40 { 0, BRUSH_MAGIC, 1 }, /* header */
41 { BS_SOLID, RGB(192,192,192), 0 } /* logbrush */
44 static BRUSHOBJ GrayBrush =
46 { 0, BRUSH_MAGIC, 1 }, /* header */
47 { BS_SOLID, RGB(128,128,128), 0 } /* logbrush */
50 static BRUSHOBJ DkGrayBrush =
52 { 0, BRUSH_MAGIC, 1 }, /* header */
53 { BS_SOLID, RGB(64,64,64), 0 } /* logbrush */
56 static BRUSHOBJ BlackBrush =
58 { 0, BRUSH_MAGIC, 1 }, /* header */
59 { BS_SOLID, RGB(0,0,0), 0 } /* logbrush */
62 static BRUSHOBJ NullBrush =
64 { 0, BRUSH_MAGIC, 1 }, /* header */
65 { BS_NULL, 0, 0 } /* logbrush */
68 static PENOBJ WhitePen =
70 { 0, PEN_MAGIC, 1 }, /* header */
71 { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
74 static PENOBJ BlackPen =
76 { 0, PEN_MAGIC, 1 }, /* header */
77 { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
80 static PENOBJ NullPen =
82 { 0, PEN_MAGIC, 1 }, /* header */
83 { PS_NULL, { 1, 0 }, 0 } /* logpen */
86 static FONTOBJ OEMFixedFont =
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, "" }
93 static FONTOBJ AnsiFixedFont =
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, "" }
100 static FONTOBJ AnsiVarFont =
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, "" }
107 static FONTOBJ SystemFont =
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, "" }
114 static FONTOBJ DeviceDefaultFont =
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, "" }
121 static FONTOBJ SystemFixedFont =
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, "" }
129 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
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,
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
151 /***********************************************************************
154 * GDI initialization.
156 BOOL32 GDI_Init(void)
159 extern BOOL32 X11DRV_Init(void);
161 /* Initialize drivers */
163 if (!X11DRV_Init()) return FALSE;
165 /* Create default palette */
167 if (!(hpalette = COLOR_Init())) return FALSE;
168 StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hpalette );
174 /***********************************************************************
177 HGDIOBJ16 GDI_AllocObject( WORD size, WORD magic )
179 static DWORD count = 0;
181 HGDIOBJ16 handle = GDI_HEAP_ALLOC( size );
182 if (!handle) return 0;
183 obj = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
186 obj->dwCount = ++count;
191 /***********************************************************************
194 BOOL32 GDI_FreeObject( HGDIOBJ16 handle )
198 /* Can't free stock objects */
199 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
202 object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
203 if (!object) return FALSE;
204 object->wMagic = 0; /* Mark it as invalid */
208 GDI_HEAP_FREE( handle );
212 /***********************************************************************
215 * Return a pointer to the GDI object associated to the handle.
216 * Return NULL if the object has the wrong magic number.
218 GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ16 handle, WORD magic )
220 GDIOBJHDR * ptr = NULL;
222 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
223 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
225 ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
226 if (!ptr) return NULL;
227 if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) return NULL;
232 /***********************************************************************
233 * DeleteObject16 (GDI.69)
235 BOOL16 DeleteObject16( HGDIOBJ16 obj )
237 return DeleteObject32( obj );
241 /***********************************************************************
242 * DeleteObject32 (GDI32.70)
244 BOOL32 DeleteObject32( HGDIOBJ32 obj )
246 /* Check if object is valid */
248 GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
249 if (!header || HIWORD(obj)) return FALSE;
251 dprintf_gdi(stddeb, "DeleteObject: %04x\n", obj );
255 switch(header->wMagic)
257 case PEN_MAGIC: return GDI_FreeObject( obj );
258 case BRUSH_MAGIC: return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
259 case FONT_MAGIC: return GDI_FreeObject( obj );
260 case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
261 case BITMAP_MAGIC: return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
262 case REGION_MAGIC: return REGION_DeleteObject( obj, (RGNOBJ*)header );
268 /***********************************************************************
269 * GetStockObject16 (GDI.87)
271 HGDIOBJ16 GetStockObject16( INT16 obj )
273 return (HGDIOBJ16)GetStockObject32( obj );
277 /***********************************************************************
278 * GetStockObject32 (GDI32.220)
280 HGDIOBJ32 GetStockObject32( INT32 obj )
282 if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
283 if (!StockObjects[obj]) return 0;
284 dprintf_gdi(stddeb, "GetStockObject: returning %d\n",
285 FIRST_STOCK_HANDLE + obj );
286 return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
290 /***********************************************************************
291 * GetObject16 (GDI.82)
293 INT16 GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
295 GDIOBJHDR * ptr = NULL;
296 dprintf_gdi(stddeb, "GetObject16: %04x %d %p\n", handle, count, buffer );
297 if (!count) return 0;
299 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
300 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
302 ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
308 return PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
310 return BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
312 return BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
314 return FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
316 return PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
322 /***********************************************************************
323 * GetObject32A (GDI32.204)
325 INT32 GetObject32A( HANDLE32 handle, INT32 count, LPVOID buffer )
327 GDIOBJHDR * ptr = NULL;
328 dprintf_gdi(stddeb, "GetObject32A: %08x %d %p\n", handle, count, buffer );
329 if (!count) return 0;
331 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
332 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
334 ptr = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
340 return PEN_GetObject32( (PENOBJ *)ptr, count, buffer );
342 return BRUSH_GetObject32( (BRUSHOBJ *)ptr, count, buffer );
344 return BITMAP_GetObject32( (BITMAPOBJ *)ptr, count, buffer );
346 return FONT_GetObject32A( (FONTOBJ *)ptr, count, buffer );
348 fprintf( stderr, "GetObject32: magic %04x not implemented\n",
356 /***********************************************************************
357 * GetObject32W (GDI32.206)
359 INT32 GetObject32W( HANDLE32 handle, INT32 count, LPVOID buffer )
361 return GetObject32A( handle, count, buffer );
365 /***********************************************************************
366 * SelectObject16 (GDI.45)
368 HGDIOBJ16 SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
370 return (HGDIOBJ16)SelectObject32( hdc, handle );
374 /***********************************************************************
375 * SelectObject32 (GDI32.299)
377 HGDIOBJ32 SelectObject32( HDC32 hdc, HGDIOBJ32 handle )
379 DC * dc = DC_GetDCPtr( hdc );
380 if (!dc || !dc->funcs->pSelectObject) return 0;
381 dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", hdc, handle );
382 return dc->funcs->pSelectObject( dc, handle );
386 /***********************************************************************
387 * UnrealizeObject16 (GDI.150)
389 BOOL16 UnrealizeObject16( HGDIOBJ16 obj )
391 return UnrealizeObject32( obj );
395 /***********************************************************************
396 * UnrealizeObject (GDI32.358)
398 BOOL32 UnrealizeObject32( HGDIOBJ32 obj )
400 /* Check if object is valid */
402 GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( obj );
403 if (!header) return FALSE;
405 dprintf_gdi( stddeb, "UnrealizeObject: %04x\n", obj );
407 /* Unrealize object */
409 switch(header->wMagic)
412 return PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
415 /* Windows resets the brush origin. We don't need to. */
422 /***********************************************************************
423 * EnumObjects16 (GDI.71)
425 INT16 EnumObjects16( HDC16 hdc, INT16 nObjType, GOBJENUMPROC16 lpEnumFunc,
428 /* Solid colors to enumerate */
429 static const COLORREF solid_colors[] =
430 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
431 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
432 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
433 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
434 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
435 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
436 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
437 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
442 LOGBRUSH16 *brush = NULL;
444 dprintf_gdi( stddeb, "EnumObjects16: %04x %d %08lx %08lx\n",
445 hdc, nObjType, (DWORD)lpEnumFunc, lParam );
449 /* Enumerate solid pens */
450 if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
451 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
453 pen->lopnStyle = PS_SOLID;
454 pen->lopnWidth.x = 1;
455 pen->lopnWidth.y = 0;
456 pen->lopnColor = solid_colors[i];
457 retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
458 dprintf_gdi( stddeb, "EnumObjects16: solid pen %08lx, ret=%d\n",
459 solid_colors[i], retval);
466 /* Enumerate solid brushes */
467 if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
468 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
470 brush->lbStyle = BS_SOLID;
471 brush->lbColor = solid_colors[i];
473 retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
474 dprintf_gdi( stddeb, "EnumObjects16: solid brush %08lx, ret=%d\n",
475 solid_colors[i], retval);
479 /* Now enumerate hatched brushes */
480 if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
482 brush->lbStyle = BS_HATCHED;
483 brush->lbColor = RGB(0,0,0);
485 retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
486 dprintf_gdi( stddeb, "EnumObjects16: hatched brush %d, ret=%d\n",
494 fprintf( stderr, "EnumObjects16: invalid type %d\n", nObjType );
501 /***********************************************************************
502 * EnumObjects32 (GDI32.89)
504 INT32 EnumObjects32( HDC32 hdc, INT32 nObjType, GOBJENUMPROC32 lpEnumFunc,
507 /* Solid colors to enumerate */
508 static const COLORREF solid_colors[] =
509 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
510 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
511 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
512 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
513 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
514 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
515 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
516 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
523 dprintf_gdi( stddeb, "EnumObjects32: %04x %d %08lx %08lx\n",
524 hdc, nObjType, (DWORD)lpEnumFunc, lParam );
528 /* Enumerate solid pens */
529 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
531 pen.lopnStyle = PS_SOLID;
534 pen.lopnColor = solid_colors[i];
535 retval = lpEnumFunc( &pen, lParam );
536 dprintf_gdi( stddeb, "EnumObjects32: solid pen %08lx, ret=%d\n",
537 solid_colors[i], retval);
543 /* Enumerate solid brushes */
544 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
546 brush.lbStyle = BS_SOLID;
547 brush.lbColor = solid_colors[i];
549 retval = lpEnumFunc( &brush, lParam );
550 dprintf_gdi( stddeb, "EnumObjects32: solid brush %08lx, ret=%d\n",
551 solid_colors[i], retval);
555 /* Now enumerate hatched brushes */
556 if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
558 brush.lbStyle = BS_HATCHED;
559 brush.lbColor = RGB(0,0,0);
561 retval = lpEnumFunc( &brush, lParam );
562 dprintf_gdi( stddeb, "EnumObjects32: hatched brush %d, ret=%d\n",
569 /* FIXME: implement Win32 types */
570 fprintf( stderr, "EnumObjects32: invalid type %d\n", nObjType );
577 /***********************************************************************
578 * IsGDIObject (GDI.462)
580 BOOL16 IsGDIObject( HGDIOBJ16 handle )
582 GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LIN_ADDR( handle );
584 return (object->wMagic>=PEN_MAGIC && object->wMagic<= METAFILE_DC_MAGIC);
589 /***********************************************************************
592 INT16 MulDiv16( INT16 foo, INT16 bar, INT16 baz )
595 if (!baz) return -32768;
596 ret = (foo * bar) / baz;
597 if ((ret > 32767) || (ret < -32767)) return -32768;
602 /***********************************************************************
603 * MulDiv32 (KERNEL32.391)
605 INT32 MulDiv32( INT32 foo, INT32 bar, INT32 baz )
610 ret = ((long long)foo * bar) / baz;
611 if ((ret > 2147483647) || (ret < -2147483647)) return -1;
615 return (foo * bar) / baz;