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