2 * Copyright (C) 2007 Google (Evan Stade)
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This 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 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/debug.h"
34 #include "gdiplus_private.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus
);
38 static const REAL mm_per_inch
= 25.4;
39 static const REAL point_per_inch
= 72.0;
41 static Status WINAPI
NotificationHook(ULONG_PTR
*token
)
45 return InvalidParameter
;
50 static void WINAPI
NotificationUnhook(ULONG_PTR token
)
52 TRACE("%ld\n", token
);
55 /*****************************************************
58 BOOL WINAPI
DllMain(HINSTANCE hinst
, DWORD reason
, LPVOID reserved
)
60 TRACE("(%p, %d, %p)\n", hinst
, reason
, reserved
);
64 case DLL_PROCESS_ATTACH
:
65 DisableThreadLibraryCalls( hinst
);
68 case DLL_PROCESS_DETACH
:
69 free_installed_fonts();
75 /*****************************************************
76 * GdiplusStartup [GDIPLUS.@]
78 Status WINAPI
GdiplusStartup(ULONG_PTR
*token
, const struct GdiplusStartupInput
*input
,
79 struct GdiplusStartupOutput
*output
)
82 return InvalidParameter
;
84 TRACE("%p %p %p\n", token
, input
, output
);
85 TRACE("GdiplusStartupInput %d %p %d %d\n", input
->GdiplusVersion
,
86 input
->DebugEventCallback
, input
->SuppressBackgroundThread
,
87 input
->SuppressExternalCodecs
);
89 if(input
->GdiplusVersion
< 1 || input
->GdiplusVersion
> 2)
90 return UnsupportedGdiplusVersion
;
92 if(input
->SuppressBackgroundThread
){
94 return InvalidParameter
;
96 output
->NotificationHook
= NotificationHook
;
97 output
->NotificationUnhook
= NotificationUnhook
;
102 /* FIXME: DebugEventCallback ignored */
107 GpStatus WINAPI
GdiplusNotificationHook(ULONG_PTR
*token
)
109 FIXME("%p\n", token
);
110 return NotificationHook(token
);
113 void WINAPI
GdiplusNotificationUnhook(ULONG_PTR token
)
115 FIXME("%ld\n", token
);
116 NotificationUnhook(token
);
119 /*****************************************************
120 * GdiplusShutdown [GDIPLUS.@]
122 ULONG WINAPI
GdiplusShutdown_wrapper(ULONG_PTR token
)
124 /* Notice the slightly different prototype from the official
125 * signature which forces us to use the _wrapper suffix.
128 /* FIXME: no object tracking */
130 /* "bricksntiles" expects a return value of 0, which native
131 * coincidentally gives.
136 /*****************************************************
137 * GdipAlloc [GDIPLUS.@]
139 void* WINGDIPAPI
GdipAlloc(SIZE_T size
)
141 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
144 /*****************************************************
145 * GdipFree [GDIPLUS.@]
147 void WINGDIPAPI
GdipFree(void* ptr
)
149 HeapFree(GetProcessHeap(), 0, ptr
);
152 /* Calculates the bezier points needed to fill in the arc portion starting at
153 * angle start and ending at end. These two angles should be no more than 90
154 * degrees from each other. x1, y1, x2, y2 describes the bounding box (upper
155 * left and width and height). Angles must be in radians. write_first indicates
156 * that the first bezier point should be written out (usually this is false).
157 * pt is the array of GpPointFs that gets written to.
159 static void add_arc_part(GpPointF
* pt
, REAL x1
, REAL y1
, REAL x2
, REAL y2
,
160 REAL start
, REAL end
, BOOL write_first
)
162 REAL center_x
, center_y
, rad_x
, rad_y
, cos_start
, cos_end
,
163 sin_start
, sin_end
, a
, half
;
168 center_x
= x1
+ rad_x
;
169 center_y
= y1
+ rad_y
;
171 cos_start
= cos(start
);
173 sin_start
= sin(start
);
176 half
= (end
- start
) / 2.0;
177 a
= 4.0 / 3.0 * (1 - cos(half
)) / sin(half
);
183 pt
[1].X
= cos_start
- a
* sin_start
;
184 pt
[1].Y
= sin_start
+ a
* cos_start
;
188 pt
[2].X
= cos_end
+ a
* sin_end
;
189 pt
[2].Y
= sin_end
- a
* cos_end
;
191 /* expand the points back from the unit circle to the ellipse */
192 for(i
= (write_first
? 0 : 1); i
< 4; i
++){
193 pt
[i
].X
= pt
[i
].X
* rad_x
+ center_x
;
194 pt
[i
].Y
= pt
[i
].Y
* rad_y
+ center_y
;
198 /* We plot the curve as if it is on a circle then stretch the points. This
199 * adjusts the angles so that when we stretch the points they will end in the
200 * right place. This is only complicated because atan and atan2 do not behave
202 static void unstretch_angle(REAL
* angle
, REAL rad_x
, REAL rad_y
)
207 *angle
= deg2rad(*angle
);
209 if(fabs(cos(*angle
)) < 0.00001 || fabs(sin(*angle
)) < 0.00001)
212 stretched
= gdiplus_atan2(sin(*angle
) / fabs(rad_y
), cos(*angle
) / fabs(rad_x
));
213 revs_off
= gdip_round(*angle
/ (2.0 * M_PI
)) - gdip_round(stretched
/ (2.0 * M_PI
));
214 stretched
+= ((REAL
)revs_off
) * M_PI
* 2.0;
218 /* Stores the bezier points that correspond to the arc in points. If points is
219 * null, just return the number of points needed to represent the arc. */
220 INT
arc2polybezier(GpPointF
* points
, REAL x1
, REAL y1
, REAL x2
, REAL y2
,
221 REAL startAngle
, REAL sweepAngle
)
224 REAL end_angle
, start_angle
, endAngle
;
226 endAngle
= startAngle
+ sweepAngle
;
227 unstretch_angle(&startAngle
, x2
/ 2.0, y2
/ 2.0);
228 unstretch_angle(&endAngle
, x2
/ 2.0, y2
/ 2.0);
230 /* start_angle and end_angle are the iterative variables */
231 start_angle
= startAngle
;
233 for(i
= 0; i
< MAX_ARC_PTS
- 1; i
+= 3){
234 /* check if we've overshot the end angle */
235 if( sweepAngle
> 0.0 )
237 if (start_angle
>= endAngle
) break;
238 end_angle
= min(start_angle
+ M_PI_2
, endAngle
);
242 if (start_angle
<= endAngle
) break;
243 end_angle
= max(start_angle
- M_PI_2
, endAngle
);
247 add_arc_part(&points
[i
], x1
, y1
, x2
, y2
, start_angle
, end_angle
, i
== 0);
249 start_angle
+= M_PI_2
* (sweepAngle
< 0.0 ? -1.0 : 1.0);
252 if (i
== 0) return 0;
256 COLORREF
ARGB2COLORREF(ARGB color
)
259 Packing of these color structures:
262 FIXME:doesn't handle alpha channel
264 return ((color
& 0x0000ff) << 16) +
266 ((color
& 0xff0000) >> 16);
269 HBITMAP
ARGB2BMP(ARGB color
)
276 if ((color
& 0xff000000) == 0xff000000) return 0;
278 bi
.bmiHeader
.biSize
= sizeof(bi
.bmiHeader
);
279 bi
.bmiHeader
.biWidth
= 1;
280 bi
.bmiHeader
.biHeight
= 1;
281 bi
.bmiHeader
.biPlanes
= 1;
282 bi
.bmiHeader
.biBitCount
= 32;
283 bi
.bmiHeader
.biCompression
= BI_RGB
;
284 bi
.bmiHeader
.biSizeImage
= 0;
285 bi
.bmiHeader
.biXPelsPerMeter
= 0;
286 bi
.bmiHeader
.biYPelsPerMeter
= 0;
287 bi
.bmiHeader
.biClrUsed
= 0;
288 bi
.bmiHeader
.biClrImportant
= 0;
290 result
= CreateDIBSection(0, &bi
, DIB_RGB_COLORS
, (void*)&bits
, NULL
, 0);
292 bits
[0].rgbReserved
= alpha
= (color
>>24)&0xff;
293 bits
[0].rgbRed
= ((color
>>16)&0xff)*alpha
/255;
294 bits
[0].rgbGreen
= ((color
>>8)&0xff)*alpha
/255;
295 bits
[0].rgbBlue
= (color
&0xff)*alpha
/255;
300 /* Like atan2, but puts angle in correct quadrant if dx is 0. */
301 REAL
gdiplus_atan2(REAL dy
, REAL dx
)
303 if((dx
== 0.0) && (dy
!= 0.0))
304 return dy
> 0.0 ? M_PI_2
: -M_PI_2
;
306 return atan2(dy
, dx
);
309 GpStatus
hresult_to_status(HRESULT res
)
317 return InvalidParameter
;
323 /* converts a given unit to its value in pixels */
324 REAL
units_to_pixels(REAL units
, GpUnit unit
, REAL dpi
)
333 return units
* dpi
/ point_per_inch
;
337 return units
* dpi
/ 300.0; /* Per MSDN */
339 return units
* dpi
/ mm_per_inch
;
341 FIXME("Unhandled unit type: %d\n", unit
);
346 /* converts value in pixels to a given unit */
347 REAL
pixels_to_units(REAL pixels
, GpUnit unit
, REAL dpi
)
356 return pixels
* point_per_inch
/ dpi
;
360 return pixels
* 300.0 / dpi
;
362 return pixels
* mm_per_inch
/ dpi
;
364 FIXME("Unhandled unit type: %d\n", unit
);
369 REAL
units_scale(GpUnit from
, GpUnit to
, REAL dpi
)
371 REAL pixels
= units_to_pixels(1.0, from
, dpi
);
372 return pixels_to_units(pixels
, to
, dpi
);
375 /* Calculates Bezier points from cardinal spline points. */
376 void calc_curve_bezier(CONST GpPointF
*pts
, REAL tension
, REAL
*x1
,
377 REAL
*y1
, REAL
*x2
, REAL
*y2
)
381 /* calculate tangent */
382 xdiff
= pts
[2].X
- pts
[0].X
;
383 ydiff
= pts
[2].Y
- pts
[0].Y
;
385 /* apply tangent to get control points */
386 *x1
= pts
[1].X
- tension
* xdiff
;
387 *y1
= pts
[1].Y
- tension
* ydiff
;
388 *x2
= pts
[1].X
+ tension
* xdiff
;
389 *y2
= pts
[1].Y
+ tension
* ydiff
;
392 /* Calculates Bezier points from cardinal spline endpoints. */
393 void calc_curve_bezier_endp(REAL xend
, REAL yend
, REAL xadj
, REAL yadj
,
394 REAL tension
, REAL
*x
, REAL
*y
)
396 /* tangent at endpoints is the line from the endpoint to the adjacent point */
397 *x
= gdip_round(tension
* (xadj
- xend
) + xend
);
398 *y
= gdip_round(tension
* (yadj
- yend
) + yend
);
401 /* make sure path has enough space for len more points */
402 BOOL
lengthen_path(GpPath
*path
, INT len
)
404 /* initial allocation */
405 if(path
->datalen
== 0){
406 path
->datalen
= len
* 2;
408 path
->pathdata
.Points
= GdipAlloc(path
->datalen
* sizeof(PointF
));
409 if(!path
->pathdata
.Points
) return FALSE
;
411 path
->pathdata
.Types
= GdipAlloc(path
->datalen
);
412 if(!path
->pathdata
.Types
){
413 GdipFree(path
->pathdata
.Points
);
417 /* reallocation, double size of arrays */
418 else if(path
->datalen
- path
->pathdata
.Count
< len
){
419 while(path
->datalen
- path
->pathdata
.Count
< len
)
422 path
->pathdata
.Points
= HeapReAlloc(GetProcessHeap(), 0,
423 path
->pathdata
.Points
, path
->datalen
* sizeof(PointF
));
424 if(!path
->pathdata
.Points
) return FALSE
;
426 path
->pathdata
.Types
= HeapReAlloc(GetProcessHeap(), 0,
427 path
->pathdata
.Types
, path
->datalen
);
428 if(!path
->pathdata
.Types
) return FALSE
;
434 void convert_32bppARGB_to_32bppPARGB(UINT width
, UINT height
,
435 BYTE
*dst_bits
, INT dst_stride
, const BYTE
*src_bits
, INT src_stride
)
438 for (y
=0; y
<height
; y
++)
440 const BYTE
*src
=src_bits
+y
*src_stride
;
441 BYTE
*dst
=dst_bits
+y
*dst_stride
;
442 for (x
=0; x
<width
; x
++)
445 *dst
++ = (*src
++ * alpha
+ 127) / 255;
446 *dst
++ = (*src
++ * alpha
+ 127) / 255;
447 *dst
++ = (*src
++ * alpha
+ 127) / 255;
453 /* recursive deletion of GpRegion nodes */
454 void delete_element(region_element
* element
)
456 switch(element
->type
)
461 GdipDeletePath(element
->elementdata
.pathdata
.path
);
463 case RegionDataEmptyRect
:
464 case RegionDataInfiniteRect
:
467 delete_element(element
->elementdata
.combine
.left
);
468 delete_element(element
->elementdata
.combine
.right
);
469 GdipFree(element
->elementdata
.combine
.left
);
470 GdipFree(element
->elementdata
.combine
.right
);
475 const char *debugstr_rectf(CONST RectF
* rc
)
477 if (!rc
) return "(null)";
478 return wine_dbg_sprintf("(%0.2f,%0.2f,%0.2f,%0.2f)", rc
->X
, rc
->Y
, rc
->Width
, rc
->Height
);
481 const char *debugstr_pointf(CONST PointF
* pt
)
483 if (!pt
) return "(null)";
484 return wine_dbg_sprintf("(%0.2f,%0.2f)", pt
->X
, pt
->Y
);