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
:
70 free_installed_fonts();
76 /*****************************************************
77 * GdiplusStartup [GDIPLUS.@]
79 Status WINAPI
GdiplusStartup(ULONG_PTR
*token
, const struct GdiplusStartupInput
*input
,
80 struct GdiplusStartupOutput
*output
)
83 return InvalidParameter
;
85 TRACE("%p %p %p\n", token
, input
, output
);
86 TRACE("GdiplusStartupInput %d %p %d %d\n", input
->GdiplusVersion
,
87 input
->DebugEventCallback
, input
->SuppressBackgroundThread
,
88 input
->SuppressExternalCodecs
);
90 if(input
->GdiplusVersion
< 1 || input
->GdiplusVersion
> 2)
91 return UnsupportedGdiplusVersion
;
93 if(input
->SuppressBackgroundThread
){
95 return InvalidParameter
;
97 output
->NotificationHook
= NotificationHook
;
98 output
->NotificationUnhook
= NotificationUnhook
;
103 /* FIXME: DebugEventCallback ignored */
108 GpStatus WINAPI
GdiplusNotificationHook(ULONG_PTR
*token
)
110 FIXME("%p\n", token
);
111 return NotificationHook(token
);
114 void WINAPI
GdiplusNotificationUnhook(ULONG_PTR token
)
116 FIXME("%ld\n", token
);
117 NotificationUnhook(token
);
120 /*****************************************************
121 * GdiplusShutdown [GDIPLUS.@]
123 ULONG WINAPI
GdiplusShutdown_wrapper(ULONG_PTR token
)
125 /* Notice the slightly different prototype from the official
126 * signature which forces us to use the _wrapper suffix.
129 /* FIXME: no object tracking */
131 /* "bricksntiles" expects a return value of 0, which native
132 * coincidentally gives.
137 /*****************************************************
138 * GdipAlloc [GDIPLUS.@]
140 void* WINGDIPAPI
GdipAlloc(SIZE_T size
)
142 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
145 /*****************************************************
146 * GdipFree [GDIPLUS.@]
148 void WINGDIPAPI
GdipFree(void* ptr
)
150 HeapFree(GetProcessHeap(), 0, ptr
);
153 /* Calculates the bezier points needed to fill in the arc portion starting at
154 * angle start and ending at end. These two angles should be no more than 90
155 * degrees from each other. x1, y1, x2, y2 describes the bounding box (upper
156 * left and width and height). Angles must be in radians. write_first indicates
157 * that the first bezier point should be written out (usually this is false).
158 * pt is the array of GpPointFs that gets written to.
160 static void add_arc_part(GpPointF
* pt
, REAL x1
, REAL y1
, REAL x2
, REAL y2
,
161 REAL start
, REAL end
, BOOL write_first
)
163 REAL center_x
, center_y
, rad_x
, rad_y
, cos_start
, cos_end
,
164 sin_start
, sin_end
, a
, half
;
169 center_x
= x1
+ rad_x
;
170 center_y
= y1
+ rad_y
;
172 cos_start
= cos(start
);
174 sin_start
= sin(start
);
177 half
= (end
- start
) / 2.0;
178 a
= 4.0 / 3.0 * (1 - cos(half
)) / sin(half
);
184 pt
[1].X
= cos_start
- a
* sin_start
;
185 pt
[1].Y
= sin_start
+ a
* cos_start
;
189 pt
[2].X
= cos_end
+ a
* sin_end
;
190 pt
[2].Y
= sin_end
- a
* cos_end
;
192 /* expand the points back from the unit circle to the ellipse */
193 for(i
= (write_first
? 0 : 1); i
< 4; i
++){
194 pt
[i
].X
= pt
[i
].X
* rad_x
+ center_x
;
195 pt
[i
].Y
= pt
[i
].Y
* rad_y
+ center_y
;
199 /* We plot the curve as if it is on a circle then stretch the points. This
200 * adjusts the angles so that when we stretch the points they will end in the
201 * right place. This is only complicated because atan and atan2 do not behave
203 static void unstretch_angle(REAL
* angle
, REAL rad_x
, REAL rad_y
)
208 *angle
= deg2rad(*angle
);
210 if(fabs(cos(*angle
)) < 0.00001 || fabs(sin(*angle
)) < 0.00001)
213 stretched
= gdiplus_atan2(sin(*angle
) / fabs(rad_y
), cos(*angle
) / fabs(rad_x
));
214 revs_off
= gdip_round(*angle
/ (2.0 * M_PI
)) - gdip_round(stretched
/ (2.0 * M_PI
));
215 stretched
+= ((REAL
)revs_off
) * M_PI
* 2.0;
219 /* Stores the bezier points that correspond to the arc in points. If points is
220 * null, just return the number of points needed to represent the arc. */
221 INT
arc2polybezier(GpPointF
* points
, REAL x1
, REAL y1
, REAL x2
, REAL y2
,
222 REAL startAngle
, REAL sweepAngle
)
225 REAL end_angle
, start_angle
, endAngle
;
227 endAngle
= startAngle
+ sweepAngle
;
228 unstretch_angle(&startAngle
, x2
/ 2.0, y2
/ 2.0);
229 unstretch_angle(&endAngle
, x2
/ 2.0, y2
/ 2.0);
231 /* start_angle and end_angle are the iterative variables */
232 start_angle
= startAngle
;
234 for(i
= 0; i
< MAX_ARC_PTS
- 1; i
+= 3){
235 /* check if we've overshot the end angle */
236 if( sweepAngle
> 0.0 )
238 if (start_angle
>= endAngle
) break;
239 end_angle
= min(start_angle
+ M_PI_2
, endAngle
);
243 if (start_angle
<= endAngle
) break;
244 end_angle
= max(start_angle
- M_PI_2
, endAngle
);
248 add_arc_part(&points
[i
], x1
, y1
, x2
, y2
, start_angle
, end_angle
, i
== 0);
250 start_angle
+= M_PI_2
* (sweepAngle
< 0.0 ? -1.0 : 1.0);
253 if (i
== 0) return 0;
257 COLORREF
ARGB2COLORREF(ARGB color
)
260 Packing of these color structures:
263 FIXME:doesn't handle alpha channel
265 return ((color
& 0x0000ff) << 16) +
267 ((color
& 0xff0000) >> 16);
270 HBITMAP
ARGB2BMP(ARGB color
)
277 if ((color
& 0xff000000) == 0xff000000) return 0;
279 bi
.bmiHeader
.biSize
= sizeof(bi
.bmiHeader
);
280 bi
.bmiHeader
.biWidth
= 1;
281 bi
.bmiHeader
.biHeight
= 1;
282 bi
.bmiHeader
.biPlanes
= 1;
283 bi
.bmiHeader
.biBitCount
= 32;
284 bi
.bmiHeader
.biCompression
= BI_RGB
;
285 bi
.bmiHeader
.biSizeImage
= 0;
286 bi
.bmiHeader
.biXPelsPerMeter
= 0;
287 bi
.bmiHeader
.biYPelsPerMeter
= 0;
288 bi
.bmiHeader
.biClrUsed
= 0;
289 bi
.bmiHeader
.biClrImportant
= 0;
291 result
= CreateDIBSection(0, &bi
, DIB_RGB_COLORS
, (void*)&bits
, NULL
, 0);
293 bits
[0].rgbReserved
= alpha
= (color
>>24)&0xff;
294 bits
[0].rgbRed
= ((color
>>16)&0xff)*alpha
/255;
295 bits
[0].rgbGreen
= ((color
>>8)&0xff)*alpha
/255;
296 bits
[0].rgbBlue
= (color
&0xff)*alpha
/255;
301 /* Like atan2, but puts angle in correct quadrant if dx is 0. */
302 REAL
gdiplus_atan2(REAL dy
, REAL dx
)
304 if((dx
== 0.0) && (dy
!= 0.0))
305 return dy
> 0.0 ? M_PI_2
: -M_PI_2
;
307 return atan2(dy
, dx
);
310 GpStatus
hresult_to_status(HRESULT res
)
318 return InvalidParameter
;
324 /* converts a given unit to its value in pixels */
325 REAL
units_to_pixels(REAL units
, GpUnit unit
, REAL dpi
)
334 return units
* dpi
/ point_per_inch
;
338 return units
* dpi
/ 300.0; /* Per MSDN */
340 return units
* dpi
/ mm_per_inch
;
342 FIXME("Unhandled unit type: %d\n", unit
);
347 /* converts value in pixels to a given unit */
348 REAL
pixels_to_units(REAL pixels
, GpUnit unit
, REAL dpi
)
357 return pixels
* point_per_inch
/ dpi
;
361 return pixels
* 300.0 / dpi
;
363 return pixels
* mm_per_inch
/ dpi
;
365 FIXME("Unhandled unit type: %d\n", unit
);
370 REAL
units_scale(GpUnit from
, GpUnit to
, REAL dpi
)
372 REAL pixels
= units_to_pixels(1.0, from
, dpi
);
373 return pixels_to_units(pixels
, to
, dpi
);
376 /* Calculates Bezier points from cardinal spline points. */
377 void calc_curve_bezier(const GpPointF
*pts
, REAL tension
, REAL
*x1
,
378 REAL
*y1
, REAL
*x2
, REAL
*y2
)
382 /* calculate tangent */
383 xdiff
= pts
[2].X
- pts
[0].X
;
384 ydiff
= pts
[2].Y
- pts
[0].Y
;
386 /* apply tangent to get control points */
387 *x1
= pts
[1].X
- tension
* xdiff
;
388 *y1
= pts
[1].Y
- tension
* ydiff
;
389 *x2
= pts
[1].X
+ tension
* xdiff
;
390 *y2
= pts
[1].Y
+ tension
* ydiff
;
393 /* Calculates Bezier points from cardinal spline endpoints. */
394 void calc_curve_bezier_endp(REAL xend
, REAL yend
, REAL xadj
, REAL yadj
,
395 REAL tension
, REAL
*x
, REAL
*y
)
397 /* tangent at endpoints is the line from the endpoint to the adjacent point */
398 *x
= gdip_round(tension
* (xadj
- xend
) + xend
);
399 *y
= gdip_round(tension
* (yadj
- yend
) + yend
);
402 /* make sure path has enough space for len more points */
403 BOOL
lengthen_path(GpPath
*path
, INT len
)
405 /* initial allocation */
406 if(path
->datalen
== 0){
407 path
->datalen
= len
* 2;
409 path
->pathdata
.Points
= GdipAlloc(path
->datalen
* sizeof(PointF
));
410 if(!path
->pathdata
.Points
) return FALSE
;
412 path
->pathdata
.Types
= GdipAlloc(path
->datalen
);
413 if(!path
->pathdata
.Types
){
414 GdipFree(path
->pathdata
.Points
);
418 /* reallocation, double size of arrays */
419 else if(path
->datalen
- path
->pathdata
.Count
< len
){
420 while(path
->datalen
- path
->pathdata
.Count
< len
)
423 path
->pathdata
.Points
= HeapReAlloc(GetProcessHeap(), 0,
424 path
->pathdata
.Points
, path
->datalen
* sizeof(PointF
));
425 if(!path
->pathdata
.Points
) return FALSE
;
427 path
->pathdata
.Types
= HeapReAlloc(GetProcessHeap(), 0,
428 path
->pathdata
.Types
, path
->datalen
);
429 if(!path
->pathdata
.Types
) return FALSE
;
435 void convert_32bppARGB_to_32bppPARGB(UINT width
, UINT height
,
436 BYTE
*dst_bits
, INT dst_stride
, const BYTE
*src_bits
, INT src_stride
)
439 for (y
=0; y
<height
; y
++)
441 const BYTE
*src
=src_bits
+y
*src_stride
;
442 BYTE
*dst
=dst_bits
+y
*dst_stride
;
443 for (x
=0; x
<width
; x
++)
446 *dst
++ = (*src
++ * alpha
+ 127) / 255;
447 *dst
++ = (*src
++ * alpha
+ 127) / 255;
448 *dst
++ = (*src
++ * alpha
+ 127) / 255;
454 /* recursive deletion of GpRegion nodes */
455 void delete_element(region_element
* element
)
457 switch(element
->type
)
462 GdipDeletePath(element
->elementdata
.path
);
464 case RegionDataEmptyRect
:
465 case RegionDataInfiniteRect
:
468 delete_element(element
->elementdata
.combine
.left
);
469 delete_element(element
->elementdata
.combine
.right
);
470 GdipFree(element
->elementdata
.combine
.left
);
471 GdipFree(element
->elementdata
.combine
.right
);
476 const char *debugstr_rectf(const RectF
* rc
)
478 if (!rc
) return "(null)";
479 return wine_dbg_sprintf("(%0.2f,%0.2f,%0.2f,%0.2f)", rc
->X
, rc
->Y
, rc
->Width
, rc
->Height
);
482 const char *debugstr_pointf(const PointF
* pt
)
484 if (!pt
) return "(null)";
485 return wine_dbg_sprintf("(%0.2f,%0.2f)", pt
->X
, pt
->Y
);