1 /* libwmf ("ipa/xgd/draw.h"): library for wmf conversion
2 Copyright (C) 2000 - various; see CREDITS, ChangeLog, and sources
3
4 The libwmf Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The libwmf Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the libwmf Library; see the file COPYING. If not,
16 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
18
19
wmf_gd_flood_interior(wmfAPI * API,wmfFlood_t * flood)20 static void wmf_gd_flood_interior (wmfAPI* API,wmfFlood_t* flood)
21 { wmf_gd_t* ddata = WMF_GD_GetData (API);
22
23 gd_t* gd = (gd_t*) ddata->gd_data;
24
25 wmfRGB* rgb;
26
27 gdPoint pt;
28
29 int color;
30
31 WMF_DEBUG (API,"wmf_[gd_]flood_interior");
32
33 pt = gd_translate (API,flood->pt);
34
35 rgb = &(flood->color);
36 color = gdImageColorResolve (gd->image,rgb->r,rgb->g,rgb->b);
37
38 gdImageFillToBorder (gd->image,pt.x,pt.y,color,color);
39 }
40
wmf_gd_flood_exterior(wmfAPI * API,wmfFlood_t * flood)41 static void wmf_gd_flood_exterior (wmfAPI* API,wmfFlood_t* flood)
42 { wmf_gd_t* ddata = WMF_GD_GetData (API);
43
44 gd_t* gd = (gd_t*) ddata->gd_data;
45
46 wmfRGB* rgb;
47
48 gdPoint pt;
49
50 int color;
51
52 WMF_DEBUG (API,"wmf_[gd_]flood_exterior");
53
54 pt = gd_translate (API,flood->pt);
55
56 rgb = &(flood->color);
57 color = gdImageColorResolve (gd->image,rgb->r,rgb->g,rgb->b);
58
59 if (flood->type == FLOODFILLSURFACE)
60 { gdImageFill (gd->image,pt.x,pt.y,color);
61 }
62 else
63 { gdImageFillToBorder (gd->image,pt.x,pt.y,color,color);
64 }
65 }
66
wmf_gd_draw_pixel(wmfAPI * API,wmfDrawPixel_t * draw_pixel)67 static void wmf_gd_draw_pixel (wmfAPI* API,wmfDrawPixel_t* draw_pixel)
68 { wmf_gd_t* ddata = WMF_GD_GetData (API);
69
70 gd_t* gd = (gd_t*) ddata->gd_data;
71
72 gdPoint pt;
73
74 wmfRGB* rgb;
75
76 int color;
77
78 WMF_DEBUG (API,"wmf_[gd_]draw_pixel");
79
80 pt = gd_translate (API,draw_pixel->pt);
81
82 rgb = &(draw_pixel->color);
83
84 color = gdImageColorResolve (gd->image,rgb->r,rgb->g,rgb->b);
85
86 gdImageSetPixel (gd->image,pt.x,pt.y,color);
87 }
88
wmf_gd_draw_pie(wmfAPI * API,wmfDrawArc_t * draw_arc)89 static void wmf_gd_draw_pie (wmfAPI* API,wmfDrawArc_t* draw_arc)
90 { /* wmf_gd_t* ddata = WMF_GD_GetData (API); */
91
92 /* gd_t* gd = (gd_t*) ddata->gd_data; */
93
94 WMF_DEBUG (API,"wmf_[gd_]draw_pie");
95
96 gd_draw_arc (API,draw_arc,gd_arc_pie);
97 }
98
wmf_gd_draw_chord(wmfAPI * API,wmfDrawArc_t * draw_arc)99 static void wmf_gd_draw_chord (wmfAPI* API,wmfDrawArc_t* draw_arc)
100 { /* wmf_gd_t* ddata = WMF_GD_GetData (API); */
101
102 /* gd_t* gd = (gd_t*) ddata->gd_data; */
103
104 WMF_DEBUG (API,"wmf_[gd_]draw_chord");
105
106 gd_draw_arc (API,draw_arc,gd_arc_chord);
107 }
108
wmf_gd_draw_arc(wmfAPI * API,wmfDrawArc_t * draw_arc)109 static void wmf_gd_draw_arc (wmfAPI* API,wmfDrawArc_t* draw_arc)
110 { /* wmf_gd_t* ddata = WMF_GD_GetData (API); */
111
112 /* gd_t* gd = (gd_t*) ddata->gd_data; */
113
114 WMF_DEBUG (API,"wmf_[gd_]draw_arc");
115
116 gd_draw_arc (API,draw_arc,gd_arc_open);
117 }
118
wmf_gd_draw_ellipse(wmfAPI * API,wmfDrawArc_t * draw_arc)119 static void wmf_gd_draw_ellipse (wmfAPI* API,wmfDrawArc_t* draw_arc)
120 { /* wmf_gd_t* ddata = WMF_GD_GetData (API); */
121
122 /* gd_t* gd = (gd_t*) ddata->gd_data; */
123
124 WMF_DEBUG (API,"wmf_[gd_]draw_ellipse");
125
126 gd_draw_arc (API,draw_arc,gd_arc_ellipse);
127 }
128
gd_draw_arc(wmfAPI * API,wmfDrawArc_t * draw_arc,gd_arc_t finish)129 static void gd_draw_arc (wmfAPI* API,wmfDrawArc_t* draw_arc,gd_arc_t finish)
130 { wmf_gd_t* ddata = WMF_GD_GetData (API);
131
132 gd_t* gd = (gd_t*) ddata->gd_data;
133
134 gdPoint TL;
135 gdPoint BR;
136
137 gdPoint s_pt;
138 gdPoint e_pt;
139
140 int Ox;
141 int Oy;
142 int w;
143 int h;
144 int start = 0;
145 int end = 360;
146
147 int brushstyle;
148 int linestyle;
149
150 WMF_DEBUG (API,"~~~~~~~~gd_draw_arc");
151
152 TL = gd_translate (API,draw_arc->TL);
153 BR = gd_translate (API,draw_arc->BR);
154
155 Ox = (BR.x + TL.x) / 2; /* origin of ellipse */
156 Oy = (BR.y + TL.y) / 2;
157
158 w = (BR.x - TL.x); /* axes of ellipse */
159 h = (BR.y - TL.y);
160
161 if (finish != gd_arc_ellipse)
162 { start = (int) (atan2 (draw_arc->start.y,draw_arc->start.x) * 180 / PI);
163 end = (int) (atan2 (draw_arc->end.y ,draw_arc->end.x ) * 180 / PI);
164
165 if (start < 0)
166 { start += 360;
167 end += 360;
168 }
169 if (end < start) end += 360;
170
171 if (finish != gd_arc_open)
172 { s_pt = gd_translate (API,draw_arc->start);
173 s_pt.x += Ox;
174 s_pt.y += Oy;
175 e_pt = gd_translate (API,draw_arc->end);
176 e_pt.x += Ox;
177 e_pt.y += Oy;
178 }
179 }
180
181 if (TO_FILL (draw_arc))
182 { brushstyle = setbrushstyle (API,draw_arc->dc);
183
184 if (finish == gd_arc_ellipse)
185 { gdImageFilledArc (gd->image,Ox,Oy,w,h,start,end,brushstyle,gdChord);
186 }
187 else if (finish == gd_arc_open)
188 { /* Do nothing */
189 }
190 else if (finish == gd_arc_pie)
191 { gdImageFilledArc (gd->image,Ox,Oy,w,h,start,end,brushstyle,gdPie);
192 }
193 else if (finish == gd_arc_chord)
194 { gdImageFilledArc (gd->image,Ox,Oy,w,h,start,end,brushstyle,gdChord);
195 }
196 }
197 if (TO_DRAW (draw_arc))
198 { linestyle = setlinestyle (API,draw_arc->dc);
199
200 gdImageArc (gd->image,Ox,Oy,w,h,start,end,linestyle);
201
202 if (finish == gd_arc_ellipse)
203 { /* Do nothing */
204 }
205 else if (finish == gd_arc_open)
206 { /* Do nothing */
207 }
208 else if (finish == gd_arc_pie)
209 { gdImageLine (gd->image,e_pt.x,e_pt.y,Ox,Oy,linestyle);
210 gdImageLine (gd->image,Ox,Oy,s_pt.x,s_pt.y,linestyle);
211 }
212 else if (finish == gd_arc_chord)
213 { gdImageLine (gd->image,e_pt.x,e_pt.y,s_pt.x,s_pt.y,linestyle);
214 }
215 }
216 }
217
wmf_gd_draw_line(wmfAPI * API,wmfDrawLine_t * draw_line)218 static void wmf_gd_draw_line (wmfAPI* API,wmfDrawLine_t* draw_line)
219 { wmf_gd_t* ddata = WMF_GD_GetData (API);
220
221 gd_t* gd = (gd_t*) ddata->gd_data;
222
223 gdPoint from;
224 gdPoint to;
225
226 int linestyle;
227
228 WMF_DEBUG (API,"wmf_[gd_]draw_line");
229
230 if (TO_DRAW (draw_line))
231 { linestyle = setlinestyle (API,draw_line->dc);
232
233 from = gd_translate (API,draw_line->from);
234 to = gd_translate (API,draw_line->to );
235
236 gdImageLine (gd->image,from.x,from.y,to.x,to.y,linestyle);
237 }
238 }
239
wmf_gd_poly_line(wmfAPI * API,wmfPolyLine_t * poly_line)240 static void wmf_gd_poly_line (wmfAPI* API,wmfPolyLine_t* poly_line)
241 { wmf_gd_t* ddata = WMF_GD_GetData (API);
242
243 gd_t* gd = (gd_t*) ddata->gd_data;
244
245 gdPoint from;
246 gdPoint to;
247
248 int linestyle;
249
250 U16 i;
251
252 WMF_DEBUG (API,"wmf_[gd_]poly_line");
253
254 if (TO_DRAW (poly_line) && (poly_line->count > 1))
255 { linestyle = setlinestyle (API,poly_line->dc);
256
257 from = gd_translate (API,poly_line->pt[0]);
258
259 for (i = 1; i < poly_line->count; i++)
260 { to = gd_translate (API,poly_line->pt[i]);
261
262 gdImageLine (gd->image,from.x,from.y,to.x,to.y,linestyle);
263
264 from = to;
265 }
266 }
267 }
268
wmf_gd_draw_polygon(wmfAPI * API,wmfPolyLine_t * poly_line)269 static void wmf_gd_draw_polygon (wmfAPI* API,wmfPolyLine_t* poly_line)
270 { wmf_gd_t* ddata = WMF_GD_GetData (API);
271
272 gd_t* gd = (gd_t*) ddata->gd_data;
273
274 gdPoint* pt;
275
276 int brushstyle;
277 int linestyle;
278
279 U16 i;
280
281 WMF_DEBUG (API,"wmf_[gd_]draw_polygon");
282
283 if (poly_line->count < 3) return;
284
285 pt = (gdPoint*) wmf_malloc (API,poly_line->count * sizeof (gdPoint));
286
287 if (ERR (API))
288 { WMF_DEBUG (API,"bailing...");
289 return;
290 }
291
292 for (i = 0; i < poly_line->count; i++)
293 { pt[i] = gd_translate (API,poly_line->pt[i]);
294 }
295
296 if (TO_FILL (poly_line))
297 { brushstyle = setbrushstyle (API,poly_line->dc);
298
299 gdImageFilledPolygon (gd->image,pt,poly_line->count,brushstyle);
300 }
301 if (TO_DRAW (poly_line))
302 { linestyle = setlinestyle (API,poly_line->dc);
303
304 gdImagePolygon (gd->image,pt,poly_line->count,linestyle);
305 }
306
307 wmf_free (API,pt);
308 }
309
wmf_gd_draw_rectangle(wmfAPI * API,wmfDrawRectangle_t * draw_rectangle)310 static void wmf_gd_draw_rectangle (wmfAPI* API,wmfDrawRectangle_t* draw_rectangle)
311 { wmf_gd_t* ddata = WMF_GD_GetData (API);
312
313 gd_t* gd = (gd_t*) ddata->gd_data;
314
315 gdPoint TL;
316 gdPoint BR;
317
318 int brushstyle;
319 int linestyle;
320
321 WMF_DEBUG (API,"wmf_[gd_]draw_rectangle");
322
323 TL = gd_translate (API,draw_rectangle->TL);
324 BR = gd_translate (API,draw_rectangle->BR);
325
326 if (TO_FILL (draw_rectangle))
327 { brushstyle = setbrushstyle (API,draw_rectangle->dc);
328
329 gdImageFilledRectangle (gd->image,TL.x,TL.y,BR.x,BR.y,brushstyle);
330 }
331 if (TO_DRAW (draw_rectangle))
332 { linestyle = setlinestyle (API,draw_rectangle->dc);
333
334 gdImageRectangle (gd->image,TL.x,TL.y,BR.x,BR.y,linestyle);
335 }
336 }
337