wininet: Initialize path buffer in InternetSetCookie.
[wine] / dlls / gdi32 / pen.c
1 /*
2  * GDI pen objects
3  *
4  * Copyright 1993 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "wine/wingdi16.h"
32 #include "gdi_private.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
36
37   /* GDI logical pen object */
38 typedef struct
39 {
40     GDIOBJHDR header;
41     EXTLOGPEN logpen;
42 } PENOBJ;
43
44
45 static HGDIOBJ PEN_SelectObject( HGDIOBJ handle, HDC hdc );
46 static INT PEN_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
47 static INT PEN_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
48
49 static const struct gdi_obj_funcs pen_funcs =
50 {
51     PEN_SelectObject,  /* pSelectObject */
52     PEN_GetObject16,   /* pGetObject16 */
53     PEN_GetObject,     /* pGetObjectA */
54     PEN_GetObject,     /* pGetObjectW */
55     NULL,              /* pUnrealizeObject */
56     GDI_FreeObject     /* pDeleteObject */
57 };
58
59
60 /***********************************************************************
61  *           CreatePen    (GDI32.@)
62  */
63 HPEN WINAPI CreatePen( INT style, INT width, COLORREF color )
64 {
65     LOGPEN logpen;
66
67     TRACE("%d %d %06x\n", style, width, color );
68
69     logpen.lopnStyle = style;
70     logpen.lopnWidth.x = width;
71     logpen.lopnWidth.y = 0;
72     logpen.lopnColor = color;
73
74     return CreatePenIndirect( &logpen );
75 }
76
77
78 /***********************************************************************
79  *           CreatePenIndirect    (GDI32.@)
80  */
81 HPEN WINAPI CreatePenIndirect( const LOGPEN * pen )
82 {
83     PENOBJ * penPtr;
84     HPEN hpen;
85
86     if (!(penPtr = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC, (HGDIOBJ *)&hpen,
87                                     &pen_funcs ))) return 0;
88     if (pen->lopnStyle == PS_USERSTYLE || pen->lopnStyle == PS_ALTERNATE)
89         penPtr->logpen.elpPenStyle = PS_SOLID;
90     else
91         penPtr->logpen.elpPenStyle = pen->lopnStyle;
92     if (pen->lopnStyle == PS_NULL)
93     {
94         penPtr->logpen.elpWidth = 1;
95         penPtr->logpen.elpColor = RGB(0, 0, 0);
96     }
97     else
98     {
99         penPtr->logpen.elpWidth = abs(pen->lopnWidth.x);
100         penPtr->logpen.elpColor = pen->lopnColor;
101     }
102     penPtr->logpen.elpBrushStyle = BS_SOLID;
103     penPtr->logpen.elpHatch = 0;
104     penPtr->logpen.elpNumEntries = 0;
105     penPtr->logpen.elpStyleEntry[0] = 0;
106
107     GDI_ReleaseObj( hpen );
108     return hpen;
109 }
110
111 /***********************************************************************
112  *           ExtCreatePen    (GDI32.@)
113  *
114  * FIXME: PS_USERSTYLE not handled
115  */
116
117 HPEN WINAPI ExtCreatePen( DWORD style, DWORD width,
118                               const LOGBRUSH * brush, DWORD style_count,
119                               const DWORD *style_bits )
120 {
121     PENOBJ * penPtr;
122     HPEN hpen;
123
124     if ((style & PS_STYLE_MASK) == PS_USERSTYLE)
125     {
126         if(((INT)style_count) <= 0)
127             return 0;
128
129         if ((style_count > 16) || !style_bits)
130         {
131             SetLastError(ERROR_INVALID_PARAMETER);
132             return 0;
133         }
134
135         if ((style & PS_TYPE_MASK) == PS_COSMETIC)
136         {
137             /* FIXME: PS_USERSTYLE workaround */
138             FIXME("PS_COSMETIC | PS_USERSTYLE not handled\n");
139             style = (style & ~PS_STYLE_MASK) | PS_SOLID;
140         }
141         else
142         {
143             UINT i;
144             BOOL has_neg = FALSE, all_zero = TRUE;
145
146             for(i = 0; (i < style_count) && !has_neg; i++)
147             {
148                 has_neg = has_neg || (((INT)(style_bits[i])) < 0);
149                 all_zero = all_zero && (style_bits[i] == 0);
150             }
151
152             if(all_zero || has_neg)
153             {
154                 SetLastError(ERROR_INVALID_PARAMETER);
155                 return 0;
156             }
157         }
158     }
159     else
160     {
161         if (style_count || style_bits)
162         {
163             SetLastError(ERROR_INVALID_PARAMETER);
164             return 0;
165         }
166     }
167
168     if ((style & PS_STYLE_MASK) == PS_NULL)
169         return CreatePen( PS_NULL, 0, brush->lbColor );
170
171     if ((style & PS_TYPE_MASK) == PS_GEOMETRIC)
172     {
173         /* PS_ALTERNATE is applicable only for cosmetic pens */
174         if ((style & PS_STYLE_MASK) == PS_ALTERNATE)
175         {
176             SetLastError(ERROR_INVALID_PARAMETER);
177             return 0;
178         }
179
180         if (brush->lbHatch && ((brush->lbStyle == BS_SOLID) || (brush->lbStyle == BS_HOLLOW)))
181         {
182             static int fixme_hatches_shown;
183             if (!fixme_hatches_shown++) FIXME("Hatches not implemented\n");
184         }
185     }
186     else
187     {
188         /* PS_INSIDEFRAME is applicable only for gemetric pens */
189         if ((style & PS_STYLE_MASK) == PS_INSIDEFRAME || width != 1)
190         {
191             SetLastError(ERROR_INVALID_PARAMETER);
192             return 0;
193         }
194     }
195
196     if (!(penPtr = GDI_AllocObject( sizeof(PENOBJ) +
197                                     style_count * sizeof(DWORD) - sizeof(penPtr->logpen.elpStyleEntry),
198                                     EXT_PEN_MAGIC, (HGDIOBJ *)&hpen,
199                                     &pen_funcs ))) return 0;
200
201     penPtr->logpen.elpPenStyle = style;
202     penPtr->logpen.elpWidth = abs(width);
203     penPtr->logpen.elpBrushStyle = brush->lbStyle;
204     penPtr->logpen.elpColor = brush->lbColor;
205     penPtr->logpen.elpHatch = brush->lbHatch;
206     penPtr->logpen.elpNumEntries = style_count;
207     memcpy(penPtr->logpen.elpStyleEntry, style_bits, style_count * sizeof(DWORD));
208     
209     GDI_ReleaseObj( hpen );
210
211     return hpen;
212 }
213
214
215 /***********************************************************************
216  *           PEN_SelectObject
217  */
218 static HGDIOBJ PEN_SelectObject( HGDIOBJ handle, HDC hdc )
219 {
220     HGDIOBJ ret = 0;
221     DC *dc = DC_GetDCPtr( hdc );
222
223     if (!dc) return 0;
224
225     if (dc->funcs->pSelectPen) handle = dc->funcs->pSelectPen( dc->physDev, handle );
226     if (handle)
227     {
228         ret = dc->hPen;
229         dc->hPen = handle;
230         GDI_inc_ref_count( handle );
231         GDI_dec_ref_count( ret );
232     }
233     DC_ReleaseDCPtr( dc );
234     return ret;
235 }
236
237
238 /***********************************************************************
239  *           PEN_GetObject16
240  */
241 static INT PEN_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
242 {
243     PENOBJ *pen = obj;
244     LOGPEN16 *logpen;
245
246     if (!buffer) return sizeof(LOGPEN16);
247
248     if (count < sizeof(LOGPEN16)) return 0;
249
250     logpen = buffer;
251     logpen->lopnStyle = pen->logpen.elpPenStyle;
252     logpen->lopnColor = pen->logpen.elpColor;
253     logpen->lopnWidth.x = pen->logpen.elpWidth;
254     logpen->lopnWidth.y = 0;
255
256     return sizeof(LOGPEN16);
257 }
258
259
260 /***********************************************************************
261  *           PEN_GetObject
262  */
263 static INT PEN_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
264 {
265     PENOBJ *pen = obj;
266
267     switch (GDIMAGIC(pen->header.wMagic))
268     {
269     case PEN_MAGIC:
270     {
271         LOGPEN *lp;
272
273         if (!buffer) return sizeof(LOGPEN);
274
275         if (count < sizeof(LOGPEN)) return 0;
276
277         if ((pen->logpen.elpPenStyle & PS_STYLE_MASK) == PS_NULL &&
278             count == sizeof(EXTLOGPEN))
279         {
280             EXTLOGPEN *elp = buffer;
281             memcpy(elp, &pen->logpen, sizeof(EXTLOGPEN));
282             elp->elpWidth = 0;
283             return sizeof(EXTLOGPEN);
284         }
285
286         lp = buffer;
287         lp->lopnStyle = pen->logpen.elpPenStyle;
288         lp->lopnColor = pen->logpen.elpColor;
289         lp->lopnWidth.x = pen->logpen.elpWidth;
290         lp->lopnWidth.y = 0;
291         return sizeof(LOGPEN);
292     }
293
294     case EXT_PEN_MAGIC:
295     {
296         INT size = sizeof(EXTLOGPEN) + pen->logpen.elpNumEntries * sizeof(DWORD) - sizeof(pen->logpen.elpStyleEntry);
297
298         if (!buffer) return size;
299
300         if (count < size) return 0;
301         memcpy(buffer, &pen->logpen, size);
302         return size;
303     }
304
305     default:
306         break;
307     }
308     assert(0);
309     return 0;
310 }