gdi: Load system fonts from $(datadir)/wine/fonts if loading from
[wine] / dlls / gdi / mfdrv / graphics.c
1 /*
2  * Metafile driver graphics functions
3  *
4  * Copyright 1993, 1994 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <stdlib.h>
22 #include <string.h>
23
24 #include "gdi.h"
25 #include "mfdrv/metafiledrv.h"
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
29
30 /**********************************************************************
31  *           MFDRV_MoveTo
32  */
33 BOOL
34 MFDRV_MoveTo(PHYSDEV dev, INT x, INT y)
35 {
36     return MFDRV_MetaParam2(dev,META_MOVETO,x,y);
37 }
38
39 /***********************************************************************
40  *           MFDRV_LineTo
41  */
42 BOOL
43 MFDRV_LineTo( PHYSDEV dev, INT x, INT y )
44 {
45      return MFDRV_MetaParam2(dev, META_LINETO, x, y);
46 }
47
48
49 /***********************************************************************
50  *           MFDRV_Arc
51  */
52 BOOL
53 MFDRV_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
54            INT xstart, INT ystart, INT xend, INT yend )
55 {
56      return MFDRV_MetaParam8(dev, META_ARC, left, top, right, bottom,
57                              xstart, ystart, xend, yend);
58 }
59
60
61 /***********************************************************************
62  *           MFDRV_Pie
63  */
64 BOOL
65 MFDRV_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
66            INT xstart, INT ystart, INT xend, INT yend )
67 {
68     return MFDRV_MetaParam8(dev, META_PIE, left, top, right, bottom,
69                             xstart, ystart, xend, yend);
70 }
71
72
73 /***********************************************************************
74  *           MFDRV_Chord
75  */
76 BOOL
77 MFDRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
78              INT xstart, INT ystart, INT xend, INT yend )
79 {
80     return MFDRV_MetaParam8(dev, META_CHORD, left, top, right, bottom,
81                             xstart, ystart, xend, yend);
82 }
83
84 /***********************************************************************
85  *           MFDRV_Ellipse
86  */
87 BOOL
88 MFDRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
89 {
90     return MFDRV_MetaParam4(dev, META_ELLIPSE, left, top, right, bottom);
91 }
92
93 /***********************************************************************
94  *           MFDRV_Rectangle
95  */
96 BOOL
97 MFDRV_Rectangle(PHYSDEV dev, INT left, INT top, INT right, INT bottom)
98 {
99     return MFDRV_MetaParam4(dev, META_RECTANGLE, left, top, right, bottom);
100 }
101
102 /***********************************************************************
103  *           MFDRV_RoundRect
104  */
105 BOOL
106 MFDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
107                  INT bottom, INT ell_width, INT ell_height )
108 {
109     return MFDRV_MetaParam6(dev, META_ROUNDRECT, left, top, right, bottom,
110                             ell_width, ell_height);
111 }
112
113 /***********************************************************************
114  *           MFDRV_SetPixel
115  */
116 COLORREF
117 MFDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
118 {
119     return MFDRV_MetaParam4(dev, META_SETPIXEL, x, y,HIWORD(color),
120                             LOWORD(color));
121 }
122
123
124 /******************************************************************
125  *         MFDRV_MetaPoly - implements Polygon and Polyline
126  */
127 static BOOL MFDRV_MetaPoly(PHYSDEV dev, short func, LPPOINT16 pt, short count)
128 {
129     BOOL ret;
130     DWORD len;
131     METARECORD *mr;
132
133     len = sizeof(METARECORD) + (count * 4);
134     if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len )))
135         return FALSE;
136
137     mr->rdSize = len / 2;
138     mr->rdFunction = func;
139     *(mr->rdParm) = count;
140     memcpy(mr->rdParm + 1, pt, count * 4);
141     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
142     HeapFree( GetProcessHeap(), 0, mr);
143     return ret;
144 }
145
146
147 /**********************************************************************
148  *          MFDRV_Polyline
149  */
150 BOOL
151 MFDRV_Polyline( PHYSDEV dev, const POINT* pt, INT count )
152 {
153     register int i;
154     LPPOINT16   pt16;
155     BOOL16      ret;
156
157     pt16 = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT16)*count );
158     if(!pt16) return FALSE;
159     for (i=count;i--;)
160     {
161         pt16[i].x = pt[i].x;
162         pt16[i].y = pt[i].y;
163     }
164     ret = MFDRV_MetaPoly(dev, META_POLYLINE, pt16, count);
165
166     HeapFree( GetProcessHeap(), 0, pt16 );
167     return ret;
168 }
169
170
171 /**********************************************************************
172  *          MFDRV_Polygon
173  */
174 BOOL
175 MFDRV_Polygon( PHYSDEV dev, const POINT* pt, INT count )
176 {
177     register int i;
178     LPPOINT16   pt16;
179     BOOL16      ret;
180
181     pt16 = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT16)*count );
182     if(!pt16) return FALSE;
183     for (i=count;i--;)
184     {
185         pt16[i].x = pt[i].x;
186         pt16[i].y = pt[i].y;
187     }
188     ret = MFDRV_MetaPoly(dev, META_POLYGON, pt16, count);
189
190     HeapFree( GetProcessHeap(), 0, pt16 );
191     return ret;
192 }
193
194
195 /**********************************************************************
196  *          MFDRV_PolyPolygon
197  */
198 BOOL
199 MFDRV_PolyPolygon( PHYSDEV dev, const POINT* pt, const INT* counts, UINT polygons)
200 {
201     BOOL ret;
202     DWORD len;
203     METARECORD *mr;
204     unsigned int i,j;
205     LPPOINT16 pt16;
206     INT16 totalpoint16 = 0;
207     INT16 * pointcounts;
208
209     for (i=0;i<polygons;i++) {
210          totalpoint16 += counts[i];
211     }
212
213     /* allocate space for all points */
214     pt16=HeapAlloc( GetProcessHeap(), 0, sizeof(POINT16) * totalpoint16 );
215     pointcounts = HeapAlloc( GetProcessHeap(), 0, sizeof(INT16) * totalpoint16 );
216
217     /* copy point counts */
218     for (i=0;i<polygons;i++) {
219           pointcounts[i] = counts[i];
220     }
221
222     /* convert all points */
223     for (j = totalpoint16; j--;){
224         pt16[j].x = pt[j].x;
225         pt16[j].y = pt[j].y;
226     }
227
228     len = sizeof(METARECORD) + sizeof(WORD) + polygons*sizeof(INT16) + totalpoint16*sizeof(POINT16);
229
230     if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len ))) {
231          HeapFree( GetProcessHeap(), 0, pt16 );
232          HeapFree( GetProcessHeap(), 0, pointcounts );
233          return FALSE;
234     }
235
236     mr->rdSize = len /2;
237     mr->rdFunction = META_POLYPOLYGON;
238     *(mr->rdParm) = polygons;
239     memcpy(mr->rdParm + 1, pointcounts, polygons*sizeof(INT16));
240     memcpy(mr->rdParm + 1+polygons, pt16 , totalpoint16*sizeof(POINT16));
241     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
242
243     HeapFree( GetProcessHeap(), 0, pt16 );
244     HeapFree( GetProcessHeap(), 0, pointcounts );
245     HeapFree( GetProcessHeap(), 0, mr);
246     return ret;
247 }
248
249
250 /**********************************************************************
251  *          MFDRV_ExtFloodFill
252  */
253 BOOL
254 MFDRV_ExtFloodFill( PHYSDEV dev, INT x, INT y, COLORREF color, UINT fillType )
255 {
256     return MFDRV_MetaParam4(dev,META_FLOODFILL,x,y,HIWORD(color),
257                             LOWORD(color));
258 }
259
260
261 /******************************************************************
262  *         MFDRV_CreateRegion
263  *
264  * For explanation of the format of the record see MF_Play_MetaCreateRegion in
265  * objects/metafile.c
266  */
267 static INT16 MFDRV_CreateRegion(PHYSDEV dev, HRGN hrgn)
268 {
269     DWORD len;
270     METARECORD *mr;
271     RGNDATA *rgndata;
272     RECT *pCurRect, *pEndRect;
273     WORD Bands = 0, MaxBands = 0;
274     WORD *Param, *StartBand;
275     BOOL ret;
276
277     if (!(len = GetRegionData( hrgn, 0, NULL ))) return -1;
278     if( !(rgndata = HeapAlloc( GetProcessHeap(), 0, len )) ) {
279         WARN("Can't alloc rgndata buffer\n");
280         return -1;
281     }
282     GetRegionData( hrgn, len, rgndata );
283
284     /* Overestimate of length:
285      * Assume every rect is a separate band -> 6 WORDs per rect
286      */
287     len = sizeof(METARECORD) + 20 + (rgndata->rdh.nCount * 12);
288     if( !(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len )) ) {
289         WARN("Can't alloc METARECORD buffer\n");
290         HeapFree( GetProcessHeap(), 0, rgndata );
291         return -1;
292     }
293
294     Param = mr->rdParm + 11;
295     StartBand = NULL;
296
297     pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;
298     for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)
299     {
300         if( StartBand && pCurRect->top == *(StartBand + 1) )
301         {
302             *Param++ = pCurRect->left;
303             *Param++ = pCurRect->right;
304         }
305         else
306         {
307             if(StartBand)
308             {
309                 *StartBand = Param - StartBand - 3;
310                 *Param++ = *StartBand;
311                 if(*StartBand > MaxBands)
312                     MaxBands = *StartBand;
313                 Bands++;
314             }
315             StartBand = Param++;
316             *Param++ = pCurRect->top;
317             *Param++ = pCurRect->bottom;
318             *Param++ = pCurRect->left;
319             *Param++ = pCurRect->right;
320         }
321     }
322     len = Param - (WORD *)mr;
323
324     mr->rdParm[0] = 0;
325     mr->rdParm[1] = 6;
326     mr->rdParm[2] = 0x1234;
327     mr->rdParm[3] = 0;
328     mr->rdParm[4] = len * 2;
329     mr->rdParm[5] = Bands;
330     mr->rdParm[6] = MaxBands;
331     mr->rdParm[7] = rgndata->rdh.rcBound.left;
332     mr->rdParm[8] = rgndata->rdh.rcBound.top;
333     mr->rdParm[9] = rgndata->rdh.rcBound.right;
334     mr->rdParm[10] = rgndata->rdh.rcBound.bottom;
335     mr->rdFunction = META_CREATEREGION;
336     mr->rdSize = len / 2;
337     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2 );
338     HeapFree( GetProcessHeap(), 0, mr );
339     HeapFree( GetProcessHeap(), 0, rgndata );
340     if(!ret)
341     {
342         WARN("MFDRV_WriteRecord failed\n");
343         return -1;
344     }
345     return MFDRV_AddHandle( dev, hrgn );
346 }
347
348
349 /**********************************************************************
350  *          MFDRV_PaintRgn
351  */
352 BOOL
353 MFDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
354 {
355     INT16 index;
356     index = MFDRV_CreateRegion( dev, hrgn );
357     if(index == -1)
358         return FALSE;
359     return MFDRV_MetaParam1( dev, META_PAINTREGION, index );
360 }
361
362
363 /**********************************************************************
364  *          MFDRV_InvertRgn
365  */
366 BOOL
367 MFDRV_InvertRgn( PHYSDEV dev, HRGN hrgn )
368 {
369     INT16 index;
370     index = MFDRV_CreateRegion( dev, hrgn );
371     if(index == -1)
372         return FALSE;
373     return MFDRV_MetaParam1( dev, META_INVERTREGION, index );
374 }
375
376
377 /**********************************************************************
378  *          MFDRV_FillRgn
379  */
380 BOOL
381 MFDRV_FillRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush )
382 {
383     INT16 iRgn, iBrush;
384     iRgn = MFDRV_CreateRegion( dev, hrgn );
385     if(iRgn == -1)
386         return FALSE;
387     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
388     if(!iBrush)
389         return FALSE;
390     return MFDRV_MetaParam2( dev, META_FILLREGION, iRgn, iBrush );
391 }
392
393 /**********************************************************************
394  *          MFDRV_FrameRgn
395  */
396 BOOL
397 MFDRV_FrameRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush, INT x, INT y )
398 {
399     INT16 iRgn, iBrush;
400     iRgn = MFDRV_CreateRegion( dev, hrgn );
401     if(iRgn == -1)
402         return FALSE;
403     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
404     if(!iBrush)
405         return FALSE;
406     return MFDRV_MetaParam4( dev, META_FRAMEREGION, iRgn, iBrush, x, y );
407 }
408
409
410 /**********************************************************************
411  *          MFDRV_ExtSelectClipRgn
412  */
413 INT MFDRV_ExtSelectClipRgn( PHYSDEV dev, HRGN hrgn, INT mode )
414 {
415     INT16 iRgn;
416     INT ret;
417
418     if (mode != RGN_COPY) return ERROR;
419     if (!hrgn) return NULLREGION;
420     iRgn = MFDRV_CreateRegion( dev, hrgn );
421     if(iRgn == -1) return ERROR;
422     ret = MFDRV_MetaParam1( dev, META_SELECTCLIPREGION, iRgn ) ? NULLREGION : ERROR;
423     MFDRV_MetaParam1( dev, META_DELETEOBJECT, iRgn );
424     return ret;
425 }
426
427
428 /**********************************************************************
429  *          MFDRV_SetBkColor
430  */
431 COLORREF
432 MFDRV_SetBkColor( PHYSDEV dev, COLORREF color )
433 {
434     return MFDRV_MetaParam2(dev, META_SETBKCOLOR, HIWORD(color),
435                             LOWORD(color)) ? color : CLR_INVALID;
436 }
437
438
439 /**********************************************************************
440  *          MFDRV_SetTextColor
441  */
442 COLORREF
443 MFDRV_SetTextColor( PHYSDEV dev, COLORREF color )
444 {
445     return MFDRV_MetaParam2(dev, META_SETTEXTCOLOR, HIWORD(color),
446                             LOWORD(color)) ? color : CLR_INVALID;
447 }
448
449
450 /**********************************************************************
451  *          MFDRV_PolyBezier
452  * Since MetaFiles don't record Beziers and they don't even record
453  * approximations to them using lines, we need this stub function.
454  */
455 BOOL
456 MFDRV_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD count )
457 {
458     return FALSE;
459 }
460
461 /**********************************************************************
462  *          MFDRV_PolyBezierTo
463  * Since MetaFiles don't record Beziers and they don't even record
464  * approximations to them using lines, we need this stub function.
465  */
466 BOOL
467 MFDRV_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD count )
468 {
469     return FALSE;
470 }