?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Separated stuff for shv background contextmenu to separate file.
[wine.git] / objects / gdiobj.c
blobee50d78ef39f306189a4f9dec4d415abc0b0f83b
1 /*
2 * GDI functions
3 *
4 * Copyright 1993 Alexandre Julliard
5 */
6
7 #include "config.h"
8
9 #ifndef X_DISPLAY_MISSING
10 #include "x11drv.h"
11 #else /* !defined(X_DISPLAY_MISSING) */
12 #include "ttydrv.h"
13 #endif /* !defined(X_DISPLAY_MISSING */
14
15 #include <stdlib.h>
16
17 #include "bitmap.h"
18 #include "brush.h"
19 #include "dc.h"
20 #include "font.h"
21 #include "heap.h"
22 #include "options.h"
23 #include "palette.h"
24 #include "pen.h"
25 #include "region.h"
26 #include "debugtools.h"
27 #include "gdi.h"
28
29 DEFAULT_DEBUG_CHANNEL(gdi)
30
31 /**********************************************************************/
32
33 GDI_DRIVER *GDI_Driver = NULL;
34
35 /***********************************************************************
36 * GDI stock objects
37 */
38
39 static BRUSHOBJ WhiteBrush =
40 {
41 { 0, BRUSH_MAGIC, 1 }, /* header */
42 { BS_SOLID, RGB(255,255,255), 0 } /* logbrush */
43 };
44
45 static BRUSHOBJ LtGrayBrush =
46 {
47 { 0, BRUSH_MAGIC, 1 }, /* header */
48 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
49 { BS_SOLID, RGB(192,192,192), 0 } /* logbrush */
50 };
51
52 static BRUSHOBJ GrayBrush =
53 {
54 { 0, BRUSH_MAGIC, 1 }, /* header */
55 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
56 { BS_SOLID, RGB(128,128,128), 0 } /* logbrush */
57 };
58
59 static BRUSHOBJ DkGrayBrush =
60 {
61 { 0, BRUSH_MAGIC, 1 }, /* header */
62 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
63 /* NB_HATCH_STYLES is an index into HatchBrushes */
64 { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES } /* logbrush */
65 };
66
67 static BRUSHOBJ BlackBrush =
68 {
69 { 0, BRUSH_MAGIC, 1 }, /* header */
70 { BS_SOLID, RGB(0,0,0), 0 } /* logbrush */
71 };
72
73 static BRUSHOBJ NullBrush =
74 {
75 { 0, BRUSH_MAGIC, 1 }, /* header */
76 { BS_NULL, 0, 0 } /* logbrush */
77 };
78
79 static PENOBJ WhitePen =
80 {
81 { 0, PEN_MAGIC, 1 }, /* header */
82 { PS_SOLID, { 1, 0 }, RGB(255,255,255) } /* logpen */
83 };
84
85 static PENOBJ BlackPen =
86 {
87 { 0, PEN_MAGIC, 1 }, /* header */
88 { PS_SOLID, { 1, 0 }, RGB(0,0,0) } /* logpen */
89 };
90
91 static PENOBJ NullPen =
92 {
93 { 0, PEN_MAGIC, 1 }, /* header */
94 { PS_NULL, { 1, 0 }, 0 } /* logpen */
95 };
96
97 static FONTOBJ OEMFixedFont =
98 {
99 { 0, FONT_MAGIC, 1 }, /* header */
100 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
101 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
102 };
103 /* Filler to make the location counter dword aligned again. This is necessary
104 since (a) FONTOBJ is packed, (b) gcc places initialised variables in the code
105 segment, and (c) Solaris assembler is stupid. */
106 static UINT16 align_OEMFixedFont = 1;
107
108 static FONTOBJ AnsiFixedFont =
109 {
110 { 0, FONT_MAGIC, 1 }, /* header */
111 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
112 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
113 };
114 static UINT16 align_AnsiFixedFont = 1;
115
116 static FONTOBJ AnsiVarFont =
117 {
118 { 0, FONT_MAGIC, 1 }, /* header */
119 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
120 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
121 };
122 static UINT16 align_AnsiVarFont = 1;
123
124 static FONTOBJ SystemFont =
125 {
126 { 0, FONT_MAGIC, 1 },
127 { 16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
128 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "System" }
129 };
130 static UINT16 align_SystemFont = 1;
131
132 static FONTOBJ DeviceDefaultFont =
133 {
134 { 0, FONT_MAGIC, 1 }, /* header */
135 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
136 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "" }
137 };
138 static UINT16 align_DeviceDefaultFont = 1;
139
140 static FONTOBJ SystemFixedFont =
141 {
142 { 0, FONT_MAGIC, 1 }, /* header */
143 { 12, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET,
144 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, "" }
145 };
146 static UINT16 align_SystemFixedFont = 1;
147
148 /* FIXME: Is this correct? */
149 static FONTOBJ DefaultGuiFont =
150 {
151 { 9, FONT_MAGIC, 1 }, /* header */
152 { 12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
153 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, "MS Sans Serif" }
154 };
155 static UINT16 align_DefaultGuiFont = 1;
156
157
158 static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
159 {
160 (GDIOBJHDR *) &WhiteBrush,
161 (GDIOBJHDR *) &LtGrayBrush,
162 (GDIOBJHDR *) &GrayBrush,
163 (GDIOBJHDR *) &DkGrayBrush,
164 (GDIOBJHDR *) &BlackBrush,
165 (GDIOBJHDR *) &NullBrush,
166 (GDIOBJHDR *) &WhitePen,
167 (GDIOBJHDR *) &BlackPen,
168 (GDIOBJHDR *) &NullPen,
169 NULL,
170 (GDIOBJHDR *) &OEMFixedFont,
171 (GDIOBJHDR *) &AnsiFixedFont,
172 (GDIOBJHDR *) &AnsiVarFont,
173 (GDIOBJHDR *) &SystemFont,
174 (GDIOBJHDR *) &DeviceDefaultFont,
175 NULL, /* DEFAULT_PALETTE created by PALETTE_Init */
176 (GDIOBJHDR *) &SystemFixedFont,
177 (GDIOBJHDR *) &DefaultGuiFont
178 };
179
180 /******************************************************************************
181 *
182 * void ReadFontInformation(
183 * char const *fontName,
184 * FONTOBJ *font,
185 * int defHeight,
186 * int defBold,
187 * int defItalic,
188 * int defUnderline,
189 * int defStrikeOut )
190 *
191 * ReadFontInformation() checks the Wine configuration file's Tweak.Fonts
192 * section for entries containing fontName.Height, fontName.Bold, etc.,
193 * where fontName is the name specified in the call (e.g., "System"). It
194 * attempts to be user friendly by accepting 'n', 'N', 'f', 'F', or '0' as
195 * the first character in the boolean attributes (bold, italic, and
196 * underline).
197 *****************************************************************************/
198
199 static void ReadFontInformation(
200 char const *fontName,
201 FONTOBJ *font,
202 int defHeight,
203 int defBold,
204 int defItalic,
205 int defUnderline,
206 int defStrikeOut )
207 {
208 char key[256];
209
210 sprintf(key, "%s.Height", fontName);
211 font->logfont.lfHeight =
212 PROFILE_GetWineIniInt("Tweak.Fonts", key, defHeight);
213
214 sprintf(key, "%s.Bold", fontName);
215 font->logfont.lfWeight =
216 (PROFILE_GetWineIniBool("Tweak.Fonts", key, defBold)) ?
217 FW_BOLD : FW_NORMAL;
218
219 sprintf(key, "%s.Italic", fontName);
220 font->logfont.lfItalic =
221 PROFILE_GetWineIniBool("Tweak.Fonts", key, defItalic);
222
223 sprintf(key, "%s.Underline", fontName);
224 font->logfont.lfUnderline =
225 PROFILE_GetWineIniBool("Tweak.Fonts", key, defUnderline);
226
227 sprintf(key, "%s.StrikeOut", fontName);
228 font->logfont.lfStrikeOut =
229 PROFILE_GetWineIniBool("Tweak.Fonts", key, defStrikeOut);
230
231 return;
232 }
233
234
235 /***********************************************************************
236 * GDI_Init
237 *
238 * GDI initialization.
239 */
240 BOOL GDI_Init(void)
241 {
242 /* Kill some warnings. */
243 (void)align_OEMFixedFont;
244 (void)align_AnsiFixedFont;
245 (void)align_AnsiVarFont;
246 (void)align_SystemFont;
247 (void)align_DeviceDefaultFont;
248 (void)align_SystemFixedFont;
249 (void)align_DefaultGuiFont;
250
251 /* TWEAK: Initialize font hints */
252 ReadFontInformation("OEMFixed", &OEMFixedFont, 12, 0, 0, 0, 0);
253 ReadFontInformation("AnsiFixed", &AnsiFixedFont, 12, 0, 0, 0, 0);
254 ReadFontInformation("AnsiVar", &AnsiVarFont, 12, 0, 0, 0, 0);
255 ReadFontInformation("System", &SystemFont, 16, 1, 0, 0, 0);
256 ReadFontInformation("SystemFixed", &SystemFixedFont, 12, 1, 0, 0, 0);
257
258 /* Initialize drivers */
259
260 #ifndef X_DISPLAY_MISSING
261 GDI_Driver = &X11DRV_GDI_Driver;
262 #else /* !defined(X_DISPLAY_MISSING) */
263 GDI_Driver = &TTYDRV_GDI_Driver;
264 #endif /* !defined(X_DISPLAY_MISSING */
265
266 GDI_Driver->pInitialize();
267
268 /* Create default palette */
269
270 /* DR well *this* palette can't be moveable (?) */
271 {
272 HPALETTE16 hpalette = PALETTE_Init();
273 if( !hpalette )
274 return FALSE;
275 StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LOCK( hpalette );
276 }
277
278 return TRUE;
279 }
280
281
282 /***********************************************************************
283 * GDI_AllocObject
284 */
285 HGDIOBJ16 GDI_AllocObject( WORD size, WORD magic )
286 {
287 static DWORD count = 0;
288 GDIOBJHDR * obj;
289 HGDIOBJ16 handle;
290 if ( magic == DC_MAGIC || magic == METAFILE_DC_MAGIC )
291 handle = GDI_HEAP_ALLOC( size );
292 else
293 handle = GDI_HEAP_ALLOC_MOVEABLE( size );
294 if (!handle) return 0;
295 obj = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
296 obj->hNext = 0;
297 obj->wMagic = magic;
298 obj->dwCount = ++count;
299 GDI_HEAP_UNLOCK( handle );
300 return handle;
301 }
302
303
304 /***********************************************************************
305 * GDI_FreeObject
306 */
307 BOOL GDI_FreeObject( HGDIOBJ16 handle )
308 {
309 GDIOBJHDR * object;
310
311 /* Can't free stock objects */
312 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
313 return TRUE;
314
315 object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
316 if (!object) return FALSE;
317 object->wMagic = 0; /* Mark it as invalid */
318
319 /* Free object */
320
321 GDI_HEAP_FREE( handle );
322 return TRUE;
323 }
324
325 /***********************************************************************
326 * GDI_GetObjPtr
327 *
328 * Return a pointer to the GDI object associated to the handle.
329 * Return NULL if the object has the wrong magic number.
330 * Movable GDI objects are locked in memory: it is up to the caller to unlock
331 * it after the caller is done with the pointer.
332 */
333 GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ16 handle, WORD magic )
334 {
335 GDIOBJHDR * ptr = NULL;
336
337 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
338 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
339 else
340 ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
341 if (!ptr) return NULL;
342 if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic))
343 {
344 GDI_HEAP_UNLOCK( handle );
345 return NULL;
346 }
347 return ptr;
348 }
349
350
351 /***********************************************************************
352 * DeleteObject16 (GDI.69)
353 */
354 BOOL16 WINAPI DeleteObject16( HGDIOBJ16 obj )
355 {
356 return DeleteObject( obj );
357 }
358
359
360 /***********************************************************************
361 * DeleteObject32 (GDI32.70)
362 */
363 BOOL WINAPI DeleteObject( HGDIOBJ obj )
364 {
365 /* Check if object is valid */
366
367 GDIOBJHDR * header;
368 if (HIWORD(obj)) return FALSE;
369 if ((obj >= FIRST_STOCK_HANDLE) && (obj <= LAST_STOCK_HANDLE))
370 return TRUE;
371 if (!(header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj ))) return FALSE;
372
373 TRACE("%04x\n", obj );
374
375 /* Delete object */
376
377 switch(header->wMagic)
378 {
379 case PEN_MAGIC: return GDI_FreeObject( obj );
380 case BRUSH_MAGIC: return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
381 case FONT_MAGIC: return GDI_FreeObject( obj );
382 case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
383 case BITMAP_MAGIC: return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
384 case REGION_MAGIC: return REGION_DeleteObject( obj, (RGNOBJ*)header );
385 case DC_MAGIC: return DeleteDC(obj);
386 case 0 :
387 WARN("Already deleted\n");
388 break;
389 default:
390 WARN("Unknown magic number (%d)\n",header->wMagic);
391 }
392 return FALSE;
393 }
394
395 /***********************************************************************
396 * GetStockObject16 (GDI.87)
397 */
398 HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
399 {
400 return (HGDIOBJ16)GetStockObject( obj );
401 }
402
403
404 /***********************************************************************
405 * GetStockObject32 (GDI32.220)
406 */
407 HGDIOBJ WINAPI GetStockObject( INT obj )
408 {
409 if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
410 if (!StockObjects[obj]) return 0;
411 TRACE("returning %d\n",
412 FIRST_STOCK_HANDLE + obj );
413 return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
414 }
415
416
417 /***********************************************************************
418 * GetObject16 (GDI.82)
419 */
420 INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
421 {
422 GDIOBJHDR * ptr = NULL;
423 INT16 result = 0;
424 TRACE("%04x %d %p\n", handle, count, buffer );
425 if (!count) return 0;
426
427 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
428 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
429 else
430 ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
431 if (!ptr) return 0;
432
433 switch(ptr->wMagic)
434 {
435 case PEN_MAGIC:
436 result = PEN_GetObject16( (PENOBJ *)ptr, count, buffer );
437 break;
438 case BRUSH_MAGIC:
439 result = BRUSH_GetObject16( (BRUSHOBJ *)ptr, count, buffer );
440 break;
441 case BITMAP_MAGIC:
442 result = BITMAP_GetObject16( (BITMAPOBJ *)ptr, count, buffer );
443 break;
444 case FONT_MAGIC:
445 result = FONT_GetObject16( (FONTOBJ *)ptr, count, buffer );
446 break;
447 case PALETTE_MAGIC:
448 result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
449 break;
450 }
451 GDI_HEAP_UNLOCK( handle );
452 return result;
453 }
454
455
456 /***********************************************************************
457 * GetObject32A (GDI32.204)
458 */
459 INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
460 {
461 GDIOBJHDR * ptr = NULL;
462 INT result = 0;
463 TRACE("%08x %d %p\n", handle, count, buffer );
464 if (!count) return 0;
465
466 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
467 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
468 else
469 ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
470 if (!ptr) return 0;
471
472 switch(ptr->wMagic)
473 {
474 case PEN_MAGIC:
475 result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
476 break;
477 case BRUSH_MAGIC:
478 result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
479 break;
480 case BITMAP_MAGIC:
481 result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
482 break;
483 case FONT_MAGIC:
484 result = FONT_GetObjectA( (FONTOBJ *)ptr, count, buffer );
485 break;
486 case PALETTE_MAGIC:
487 result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
488 break;
489 default:
490 FIXME("Magic %04x not implemented\n",
491 ptr->wMagic );
492 break;
493 }
494 GDI_HEAP_UNLOCK( handle );
495 return result;
496 }
497 /***********************************************************************
498 * GetObject32W (GDI32.206)
499 */
500 INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
501 {
502 GDIOBJHDR * ptr = NULL;
503 INT result = 0;
504 TRACE("%08x %d %p\n", handle, count, buffer );
505 if (!count) return 0;
506
507 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
508 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
509 else
510 ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
511 if (!ptr) return 0;
512
513 switch(ptr->wMagic)
514 {
515 case PEN_MAGIC:
516 result = PEN_GetObject( (PENOBJ *)ptr, count, buffer );
517 break;
518 case BRUSH_MAGIC:
519 result = BRUSH_GetObject( (BRUSHOBJ *)ptr, count, buffer );
520 break;
521 case BITMAP_MAGIC:
522 result = BITMAP_GetObject( (BITMAPOBJ *)ptr, count, buffer );
523 break;
524 case FONT_MAGIC:
525 result = FONT_GetObjectW( (FONTOBJ *)ptr, count, buffer );
526 break;
527 case PALETTE_MAGIC:
528 result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
529 break;
530 default:
531 FIXME("Magic %04x not implemented\n",
532 ptr->wMagic );
533 break;
534 }
535 GDI_HEAP_UNLOCK( handle );
536 return result;
537 }
538
539 /***********************************************************************
540 * GetObjectType (GDI32.205)
541 */
542 DWORD WINAPI GetObjectType( HANDLE handle )
543 {
544 GDIOBJHDR * ptr = NULL;
545 INT result = 0;
546 TRACE("%08x\n", handle );
547
548 if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
549 ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
550 else
551 ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
552 if (!ptr) return 0;
553
554 switch(ptr->wMagic)
555 {
556 case PEN_MAGIC:
557 result = OBJ_PEN;
558 break;
559 case BRUSH_MAGIC:
560 result = OBJ_BRUSH;
561 break;
562 case BITMAP_MAGIC:
563 result = OBJ_BITMAP;
564 break;
565 case FONT_MAGIC:
566 result = OBJ_FONT;
567 break;
568 case PALETTE_MAGIC:
569 result = OBJ_PAL;
570 break;
571 case REGION_MAGIC:
572 result = OBJ_REGION;
573 break;
574 case DC_MAGIC:
575 result = OBJ_DC;
576 break;
577 case META_DC_MAGIC:
578 result = OBJ_METADC;
579 break;
580 case METAFILE_MAGIC:
581 result = OBJ_METAFILE;
582 break;
583 case METAFILE_DC_MAGIC:
584 result = OBJ_METADC;
585 break;
586 case ENHMETAFILE_MAGIC:
587 result = OBJ_ENHMETAFILE;
588 break;
589 case ENHMETAFILE_DC_MAGIC:
590 result = OBJ_ENHMETADC;
591 break;
592 default:
593 FIXME("Magic %04x not implemented\n",
594 ptr->wMagic );
595 break;
596 }
597 GDI_HEAP_UNLOCK( handle );
598 return result;
599 }
600
601 /***********************************************************************
602 * GetCurrentObject (GDI32.166)
603 */
604 HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
605 {
606 DC * dc = DC_GetDCPtr( hdc );
607
608 if (!dc)
609 return 0;
610 switch (type) {
611 case OBJ_PEN: return dc->w.hPen;
612 case OBJ_BRUSH: return dc->w.hBrush;
613 case OBJ_PAL: return dc->w.hPalette;
614 case OBJ_FONT: return dc->w.hFont;
615 case OBJ_BITMAP: return dc->w.hBitmap;
616 default:
617 /* the SDK only mentions those above */
618 WARN("(%08x,%d): unknown type.\n",hdc,type);
619 return 0;
620 }
621 }
622
623
624 /***********************************************************************
625 * SelectObject16 (GDI.45)
626 */
627 HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
628 {
629 return (HGDIOBJ16)SelectObject( hdc, handle );
630 }
631
632
633 /***********************************************************************
634 * SelectObject32 (GDI32.299)
635 */
636 HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
637 {
638 DC * dc = DC_GetDCPtr( hdc );
639 if (!dc || !dc->funcs->pSelectObject) return 0;
640 TRACE("hdc=%04x %04x\n", hdc, handle );
641 return dc->funcs->pSelectObject( dc, handle );
642 }
643
644
645 /***********************************************************************
646 * UnrealizeObject16 (GDI.150)
647 */
648 BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
649 {
650 return UnrealizeObject( obj );
651 }
652
653
654 /***********************************************************************
655 * UnrealizeObject (GDI32.358)
656 */
657 BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
658 {
659 BOOL result = TRUE;
660 /* Check if object is valid */
661
662 GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj );
663 if (!header) return FALSE;
664
665 TRACE("%04x\n", obj );
666
667 /* Unrealize object */
668
669 switch(header->wMagic)
670 {
671 case PALETTE_MAGIC:
672 result = PALETTE_UnrealizeObject( obj, (PALETTEOBJ *)header );
673 break;
674
675 case BRUSH_MAGIC:
676 /* Windows resets the brush origin. We don't need to. */
677 break;
678 }
679 GDI_HEAP_UNLOCK( obj );
680 return result;
681 }
682
683
684 /***********************************************************************
685 * EnumObjects16 (GDI.71)
686 */
687 INT16 WINAPI EnumObjects16( HDC16 hdc, INT16 nObjType,
688 GOBJENUMPROC16 lpEnumFunc, LPARAM lParam )
689 {
690 /* Solid colors to enumerate */
691 static const COLORREF solid_colors[] =
692 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
693 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
694 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
695 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
696 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
697 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
698 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
699 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
700 };
701
702 INT16 i, retval = 0;
703 LOGPEN16 *pen;
704 LOGBRUSH16 *brush = NULL;
705
706 TRACE("%04x %d %08lx %08lx\n",
707 hdc, nObjType, (DWORD)lpEnumFunc, lParam );
708 switch(nObjType)
709 {
710 case OBJ_PEN:
711 /* Enumerate solid pens */
712 if (!(pen = SEGPTR_NEW(LOGPEN16))) break;
713 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
714 {
715 pen->lopnStyle = PS_SOLID;
716 pen->lopnWidth.x = 1;
717 pen->lopnWidth.y = 0;
718 pen->lopnColor = solid_colors[i];
719 retval = lpEnumFunc( SEGPTR_GET(pen), lParam );
720 TRACE("solid pen %08lx, ret=%d\n",
721 solid_colors[i], retval);
722 if (!retval) break;
723 }
724 SEGPTR_FREE(pen);
725 break;
726
727 case OBJ_BRUSH:
728 /* Enumerate solid brushes */
729 if (!(brush = SEGPTR_NEW(LOGBRUSH16))) break;
730 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
731 {
732 brush->lbStyle = BS_SOLID;
733 brush->lbColor = solid_colors[i];
734 brush->lbHatch = 0;
735 retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
736 TRACE("solid brush %08lx, ret=%d\n",
737 solid_colors[i], retval);
738 if (!retval) break;
739 }
740
741 /* Now enumerate hatched brushes */
742 if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
743 {
744 brush->lbStyle = BS_HATCHED;
745 brush->lbColor = RGB(0,0,0);
746 brush->lbHatch = i;
747 retval = lpEnumFunc( SEGPTR_GET(brush), lParam );
748 TRACE("hatched brush %d, ret=%d\n",
749 i, retval);
750 if (!retval) break;
751 }
752 SEGPTR_FREE(brush);
753 break;
754
755 default:
756 WARN("(%d): Invalid type\n", nObjType );
757 break;
758 }
759 return retval;
760 }
761
762
763 /***********************************************************************
764 * EnumObjects32 (GDI32.89)
765 */
766 INT WINAPI EnumObjects( HDC hdc, INT nObjType,
767 GOBJENUMPROC lpEnumFunc, LPARAM lParam )
768 {
769 /* Solid colors to enumerate */
770 static const COLORREF solid_colors[] =
771 { RGB(0x00,0x00,0x00), RGB(0xff,0xff,0xff),
772 RGB(0xff,0x00,0x00), RGB(0x00,0xff,0x00),
773 RGB(0x00,0x00,0xff), RGB(0xff,0xff,0x00),
774 RGB(0xff,0x00,0xff), RGB(0x00,0xff,0xff),
775 RGB(0x80,0x00,0x00), RGB(0x00,0x80,0x00),
776 RGB(0x80,0x80,0x00), RGB(0x00,0x00,0x80),
777 RGB(0x80,0x00,0x80), RGB(0x00,0x80,0x80),
778 RGB(0x80,0x80,0x80), RGB(0xc0,0xc0,0xc0)
779 };
780
781 INT i, retval = 0;
782 LOGPEN pen;
783 LOGBRUSH brush;
784
785 TRACE("%04x %d %08lx %08lx\n",
786 hdc, nObjType, (DWORD)lpEnumFunc, lParam );
787 switch(nObjType)
788 {
789 case OBJ_PEN:
790 /* Enumerate solid pens */
791 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
792 {
793 pen.lopnStyle = PS_SOLID;
794 pen.lopnWidth.x = 1;
795 pen.lopnWidth.y = 0;
796 pen.lopnColor = solid_colors[i];
797 retval = lpEnumFunc( &pen, lParam );
798 TRACE("solid pen %08lx, ret=%d\n",
799 solid_colors[i], retval);
800 if (!retval) break;
801 }
802 break;
803
804 case OBJ_BRUSH:
805 /* Enumerate solid brushes */
806 for (i = 0; i < sizeof(solid_colors)/sizeof(solid_colors[0]); i++)
807 {
808 brush.lbStyle = BS_SOLID;
809 brush.lbColor = solid_colors[i];
810 brush.lbHatch = 0;
811 retval = lpEnumFunc( &brush, lParam );
812 TRACE("solid brush %08lx, ret=%d\n",
813 solid_colors[i], retval);
814 if (!retval) break;
815 }
816
817 /* Now enumerate hatched brushes */
818 if (retval) for (i = HS_HORIZONTAL; i <= HS_DIAGCROSS; i++)
819 {
820 brush.lbStyle = BS_HATCHED;
821 brush.lbColor = RGB(0,0,0);
822 brush.lbHatch = i;
823 retval = lpEnumFunc( &brush, lParam );
824 TRACE("hatched brush %d, ret=%d\n",
825 i, retval);
826 if (!retval) break;
827 }
828 break;
829
830 default:
831 /* FIXME: implement Win32 types */
832 WARN("(%d): Invalid type\n", nObjType );
833 break;
834 }
835 return retval;
836 }
837
838
839 /***********************************************************************
840 * IsGDIObject (GDI.462)
841 *
842 * returns type of object if valid (W95 system programming secrets p. 264-5)
843 */
844 BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
845 {
846 UINT16 magic = 0;
847
848 if (handle >= FIRST_STOCK_HANDLE )
849 {
850 switch (handle)
851 {
852 case STOCK_WHITE_BRUSH:
853 case STOCK_LTGRAY_BRUSH:
854 case STOCK_GRAY_BRUSH:
855 case STOCK_DKGRAY_BRUSH:
856 case STOCK_BLACK_BRUSH:
857 case STOCK_HOLLOW_BRUSH:
858 magic = BRUSH_MAGIC;
859 break;
860
861 case STOCK_WHITE_PEN:
862 case STOCK_BLACK_PEN:
863 case STOCK_NULL_PEN :
864 magic = PEN_MAGIC;
865 break;
866
867 case STOCK_OEM_FIXED_FONT:
868 case STOCK_ANSI_FIXED_FONT:
869 case STOCK_ANSI_VAR_FONT:
870 case STOCK_SYSTEM_FONT:
871 case STOCK_DEVICE_DEFAULT_FONT:
872 case STOCK_SYSTEM_FIXED_FONT:
873 case STOCK_DEFAULT_GUI_FONT:
874 magic = FONT_MAGIC;
875 break;
876
877 case STOCK_DEFAULT_PALETTE:
878 magic = PALETTE_MAGIC;
879 break;
880 }
881 }
882 else
883 {
884 GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
885 if (object)
886 {
887 magic = object->wMagic;
888 GDI_HEAP_UNLOCK( handle );
889 }
890 }
891
892 if (magic >= PEN_MAGIC && magic <= METAFILE_DC_MAGIC)
893 return magic - PEN_MAGIC + 1;
894 else
895 return FALSE;
896 }
897
898
899 /***********************************************************************
900 * SetObjectOwner16 (GDI.461)
901 */
902 void WINAPI SetObjectOwner16( HGDIOBJ16 handle, HANDLE16 owner )
903 {
904 /* Nothing to do */
905 }
906
907
908 /***********************************************************************
909 * SetObjectOwner32 (GDI32.386)
910 */
911 void WINAPI SetObjectOwner( HGDIOBJ handle, HANDLE owner )
912 {
913 /* Nothing to do */
914 }
915
916 /***********************************************************************
917 * MakeObjectPrivate (GDI.463)
918 */
919 void WINAPI MakeObjectPrivate16( HGDIOBJ16 handle, BOOL16 private )
920 {
921 /* FIXME */
922 }
923
924
925 /***********************************************************************
926 * GdiFlush (GDI32.128)
927 */
928 BOOL WINAPI GdiFlush(void)
929 {
930 return TRUE; /* FIXME */
931 }
932
933
934 /***********************************************************************
935 * GdiGetBatchLimit (GDI32.129)
936 */
937 DWORD WINAPI GdiGetBatchLimit(void)
938 {
939 return 1; /* FIXME */
940 }
941
942
943 /***********************************************************************
944 * GdiSetBatchLimit (GDI32.139)
945 */
946 DWORD WINAPI GdiSetBatchLimit( DWORD limit )
947 {
948 return 1; /* FIXME */
949 }
950
951
952 /***********************************************************************
953 * GdiSeeGdiDo (GDI.452)
954 */
955 DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
956 WORD wParam3 )
957 {
958 switch (wReqType)
959 {
960 case 0x0001: /* LocalAlloc */
961 return LOCAL_Alloc( GDI_HeapSel, wParam1, wParam3 );
962 case 0x0002: /* LocalFree */
963 return LOCAL_Free( GDI_HeapSel, wParam1 );
964 case 0x0003: /* LocalCompact */
965 return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
966 case 0x0103: /* LocalHeap */
967 return GDI_HeapSel;
968 default:
969 WARN("(wReqType=%04x): Unknown\n", wReqType);
970 return (DWORD)-1;
971 }
972 }
973
974 /***********************************************************************
975 * GdiSignalProc (GDI.610)
976 */
977 WORD WINAPI GdiSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
978 DWORD dwFlags, HMODULE16 hModule )
979 {
980 return 0;
981 }
982
983
984 /***********************************************************************
985 * GdiFreeResources (GDI.609)
986 */
987 WORD WINAPI GdiFreeResources16( DWORD reserve )
988 {
989 return (WORD)( (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
990 (int)LOCAL_HeapSize( GDI_HeapSel ) );
991 }
992
993 /***********************************************************************
994 * MulDiv16 (GDI.128)
995 */
996 INT16 WINAPI MulDiv16( INT16 foo, INT16 bar, INT16 baz )
997 {
998 INT ret;
999 if (!baz) return -32768;
1000 ret = (foo * bar) / baz;
1001 if ((ret > 32767) || (ret < -32767)) return -32768;
1002 return ret;
1003 }
1004
1005
1006 /***********************************************************************
1007 * MulDiv32 (KERNEL32.391)
1008 * RETURNS
1009 * Result of multiplication and division
1010 * -1: Overflow occurred or Divisor was 0
1011 */
1012 INT WINAPI MulDiv(
1013 INT nMultiplicand,
1014 INT nMultiplier,
1015 INT nDivisor
1016 ) {
1017 #if (SIZEOF_LONG_LONG >= 8)
1018 long long ret;
1019 if (!nDivisor) return -1;
1020 ret = (((long long)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1021 if ((ret > 2147483647) || (ret < -2147483647)) return -1;
1022 return ret;
1023 #else
1024 if (!nDivisor) return -1;
1025 return ((nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
1026 #endif
1027 }
1028 /*******************************************************************
1029 * GetColorAdjustment [GDI32.164]
1030 *
1031 *
1032 */
1033 BOOL WINAPI GetColorAdjustment(HDC hdc, LPCOLORADJUSTMENT lpca)
1034 {
1035 FIXME("GetColorAdjustment, stub\n");
1036 return 0;
1037 }
1038
1039 /*******************************************************************
1040 * GetMiterLimit [GDI32.201]
1041 *
1042 *
1043 */
1044 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1045 {
1046 FIXME("GetMiterLimit, stub\n");
1047 return 0;
1048 }
1049
1050 /*******************************************************************
1051 * SetMiterLimit [GDI32.325]
1052 *
1053 *
1054 */
1055 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1056 {
1057 FIXME("SetMiterLimit, stub\n");
1058 return 0;
1059 }
1060
1061 /*******************************************************************
1062 * GdiComment [GDI32.109]
1063 *
1064 *
1065 */
1066 BOOL WINAPI GdiComment(HDC hdc, UINT cbSize, const BYTE *lpData)
1067 {
1068 FIXME("GdiComment, stub\n");
1069 return 0;
1070 }
1071 /*******************************************************************
1072 * SetColorAdjustment [GDI32.309]
1073 *
1074 *
1075 */
1076 BOOL WINAPI SetColorAdjustment(HDC hdc, const COLORADJUSTMENT* lpca)
1077 {
1078 FIXME("SetColorAdjustment, stub\n");
1079 return 0;
1080 }
1081
Windows API implementation