1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "wingdi.h"
25
26 #define COBJMACROS
27 #include "objbase.h"
28 #include "olectl.h"
29 #include "ole2.h"
30
31 #include "gdiplus.h"
32 #include "gdiplus_private.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
36
37 /******************************************************************************
38 * GdipCloneBrush [GDIPLUS.@]
39 */
40 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
41 {
42 TRACE("(%p, %p)\n", brush, clone);
43
44 if(!brush || !clone)
45 return InvalidParameter;
46
47 switch(brush->bt){
48 case BrushTypeSolidColor:
49 *clone = GdipAlloc(sizeof(GpSolidFill));
50 if (!*clone) return OutOfMemory;
51
52 memcpy(*clone, brush, sizeof(GpSolidFill));
53
54 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
55 break;
56 case BrushTypePathGradient:{
57 GpPathGradient *src, *dest;
58 INT count;
59
60 *clone = GdipAlloc(sizeof(GpPathGradient));
61 if (!*clone) return OutOfMemory;
62
63 src = (GpPathGradient*) brush,
64 dest = (GpPathGradient*) *clone;
65 count = src->pathdata.Count;
66
67 memcpy(dest, src, sizeof(GpPathGradient));
68
69 dest->pathdata.Count = count;
70 dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
71 dest->pathdata.Types = GdipAlloc(count);
72
73 if(!dest->pathdata.Points || !dest->pathdata.Types){
74 GdipFree(dest->pathdata.Points);
75 GdipFree(dest->pathdata.Types);
76 GdipFree(dest);
77 return OutOfMemory;
78 }
79
80 memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
81 memcpy(dest->pathdata.Types, src->pathdata.Types, count);
82
83 /* blending */
84 count = src->blendcount;
85 dest->blendcount = count;
86 dest->blendfac = GdipAlloc(count * sizeof(REAL));
87 dest->blendpos = GdipAlloc(count * sizeof(REAL));
88
89 if(!dest->blendfac || !dest->blendpos){
90 GdipFree(dest->pathdata.Points);
91 GdipFree(dest->pathdata.Types);
92 GdipFree(dest->blendfac);
93 GdipFree(dest->blendpos);
94 GdipFree(dest);
95 return OutOfMemory;
96 }
97
98 memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
99 memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
100
101 break;
102 }
103 case BrushTypeLinearGradient:
104 *clone = GdipAlloc(sizeof(GpLineGradient));
105 if(!*clone) return OutOfMemory;
106
107 memcpy(*clone, brush, sizeof(GpLineGradient));
108
109 (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
110 break;
111 case BrushTypeTextureFill:
112 *clone = GdipAlloc(sizeof(GpTexture));
113 if(!*clone) return OutOfMemory;
114
115 memcpy(*clone, brush, sizeof(GpTexture));
116
117 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
118 break;
119 default:
120 ERR("not implemented for brush type %d\n", brush->bt);
121 return NotImplemented;
122 }
123
124 return Ok;
125 }
126
127 /******************************************************************************
128 * GdipCreateLineBrush [GDIPLUS.@]
129 */
130 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
131 GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
132 GpWrapMode wrap, GpLineGradient **line)
133 {
134 COLORREF col = ARGB2COLORREF(startcolor);
135
136 TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
137 startcolor, endcolor, wrap, line);
138
139 if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
140 return InvalidParameter;
141
142 *line = GdipAlloc(sizeof(GpLineGradient));
143 if(!*line) return OutOfMemory;
144
145 (*line)->brush.lb.lbStyle = BS_SOLID;
146 (*line)->brush.lb.lbColor = col;
147 (*line)->brush.lb.lbHatch = 0;
148 (*line)->brush.gdibrush = CreateSolidBrush(col);
149 (*line)->brush.bt = BrushTypeLinearGradient;
150
151 (*line)->startpoint.X = startpoint->X;
152 (*line)->startpoint.Y = startpoint->Y;
153 (*line)->endpoint.X = endpoint->X;
154 (*line)->endpoint.Y = endpoint->Y;
155 (*line)->startcolor = startcolor;
156 (*line)->endcolor = endcolor;
157 (*line)->wrap = wrap;
158 (*line)->gamma = FALSE;
159
160 return Ok;
161 }
162
163 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
164 GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
165 GpWrapMode wrap, GpLineGradient **line)
166 {
167 GpPointF stF;
168 GpPointF endF;
169
170 TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
171 startcolor, endcolor, wrap, line);
172
173 if(!startpoint || !endpoint)
174 return InvalidParameter;
175
176 stF.X = (REAL)startpoint->X;
177 stF.Y = (REAL)startpoint->Y;
178 endF.X = (REAL)endpoint->X;
179 endF.X = (REAL)endpoint->Y;
180
181 return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
182 }
183
184 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
185 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
186 GpLineGradient **line)
187 {
188 GpPointF start, end;
189
190 TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
191 wrap, line);
192
193 if(!line || !rect)
194 return InvalidParameter;
195
196 start.X = rect->X;
197 start.Y = rect->Y;
198 end.X = rect->X + rect->Width;
199 end.Y = rect->Y + rect->Height;
200
201 return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
202 }
203
204 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
205 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
206 GpLineGradient **line)
207 {
208 GpRectF rectF;
209
210 TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
211 wrap, line);
212
213 rectF.X = (REAL) rect->X;
214 rectF.Y = (REAL) rect->Y;
215 rectF.Width = (REAL) rect->Width;
216 rectF.Height = (REAL) rect->Height;
217
218 return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
219 }
220
221 /******************************************************************************
222 * GdipCreateLineBrushFromRectWithAngle [GDIPLUS.@]
223 *
224 * FIXME: angle value completely ignored. Don't know how to use it since native
225 * always set Brush rectangle to rect (independetly of this angle).
226 * Maybe it's used only on drawing.
227 */
228 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
229 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
230 GpLineGradient **line)
231 {
232 TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
233 wrap, line);
234
235 return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
236 wrap, line);
237 }
238
239 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
240 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
241 GpLineGradient **line)
242 {
243 TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
244 wrap, line);
245
246 return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
247 wrap, line);
248 }
249
250 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
251 INT count, GpWrapMode wrap, GpPathGradient **grad)
252 {
253 COLORREF col = ARGB2COLORREF(0xffffffff);
254
255 TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
256
257 if(!points || !grad)
258 return InvalidParameter;
259
260 if(count <= 0)
261 return OutOfMemory;
262
263 *grad = GdipAlloc(sizeof(GpPathGradient));
264 if (!*grad) return OutOfMemory;
265
266 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
267 if(!(*grad)->blendfac){
268 GdipFree(*grad);
269 return OutOfMemory;
270 }
271 (*grad)->blendfac[0] = 1.0;
272 (*grad)->blendpos = NULL;
273 (*grad)->blendcount = 1;
274
275 (*grad)->pathdata.Count = count;
276 (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
277 (*grad)->pathdata.Types = GdipAlloc(count);
278
279 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
280 GdipFree((*grad)->pathdata.Points);
281 GdipFree((*grad)->pathdata.Types);
282 GdipFree(*grad);
283 return OutOfMemory;
284 }
285
286 memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
287 memset((*grad)->pathdata.Types, PathPointTypeLine, count);
288
289 (*grad)->brush.lb.lbStyle = BS_SOLID;
290 (*grad)->brush.lb.lbColor = col;
291 (*grad)->brush.lb.lbHatch = 0;
292
293 (*grad)->brush.gdibrush = CreateSolidBrush(col);
294 (*grad)->brush.bt = BrushTypePathGradient;
295 (*grad)->centercolor = 0xffffffff;
296 (*grad)->wrap = wrap;
297 (*grad)->gamma = FALSE;
298 (*grad)->center.X = 0.0;
299 (*grad)->center.Y = 0.0;
300 (*grad)->focus.X = 0.0;
301 (*grad)->focus.Y = 0.0;
302
303 return Ok;
304 }
305
306 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
307 INT count, GpWrapMode wrap, GpPathGradient **grad)
308 {
309 GpPointF *pointsF;
310 GpStatus ret;
311 INT i;
312
313 TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
314
315 if(!points || !grad)
316 return InvalidParameter;
317
318 if(count <= 0)
319 return OutOfMemory;
320
321 pointsF = GdipAlloc(sizeof(GpPointF) * count);
322 if(!pointsF)
323 return OutOfMemory;
324
325 for(i = 0; i < count; i++){
326 pointsF[i].X = (REAL)points[i].X;
327 pointsF[i].Y = (REAL)points[i].Y;
328 }
329
330 ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
331 GdipFree(pointsF);
332
333 return ret;
334 }
335
336 /******************************************************************************
337 * GdipCreatePathGradientFromPath [GDIPLUS.@]
338 *
339 * FIXME: path gradient brushes not truly supported (drawn as solid brushes)
340 */
341 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
342 GpPathGradient **grad)
343 {
344 COLORREF col = ARGB2COLORREF(0xffffffff);
345
346 TRACE("(%p, %p)\n", path, grad);
347
348 if(!path || !grad)
349 return InvalidParameter;
350
351 *grad = GdipAlloc(sizeof(GpPathGradient));
352 if (!*grad) return OutOfMemory;
353
354 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
355 if(!(*grad)->blendfac){
356 GdipFree(*grad);
357 return OutOfMemory;
358 }
359 (*grad)->blendfac[0] = 1.0;
360 (*grad)->blendpos = NULL;
361 (*grad)->blendcount = 1;
362
363 (*grad)->pathdata.Count = path->pathdata.Count;
364 (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
365 (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
366
367 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
368 GdipFree((*grad)->pathdata.Points);
369 GdipFree((*grad)->pathdata.Types);
370 GdipFree(*grad);
371 return OutOfMemory;
372 }
373
374 memcpy((*grad)->pathdata.Points, path->pathdata.Points,
375 path->pathdata.Count * sizeof(PointF));
376 memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
377
378 (*grad)->brush.lb.lbStyle = BS_SOLID;
379 (*grad)->brush.lb.lbColor = col;
380 (*grad)->brush.lb.lbHatch = 0;
381
382 (*grad)->brush.gdibrush = CreateSolidBrush(col);
383 (*grad)->brush.bt = BrushTypePathGradient;
384 (*grad)->centercolor = 0xffffffff;
385 (*grad)->wrap = WrapModeClamp;
386 (*grad)->gamma = FALSE;
387 /* FIXME: this should be set to the "centroid" of the path by default */
388 (*grad)->center.X = 0.0;
389 (*grad)->center.Y = 0.0;
390 (*grad)->focus.X = 0.0;
391 (*grad)->focus.Y = 0.0;
392
393 return Ok;
394 }
395
396 /******************************************************************************
397 * GdipCreateSolidFill [GDIPLUS.@]
398 */
399 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
400 {
401 COLORREF col = ARGB2COLORREF(color);
402
403 TRACE("(%x, %p)\n", color, sf);
404
405 if(!sf) return InvalidParameter;
406
407 *sf = GdipAlloc(sizeof(GpSolidFill));
408 if (!*sf) return OutOfMemory;
409
410 (*sf)->brush.lb.lbStyle = BS_SOLID;
411 (*sf)->brush.lb.lbColor = col;
412 (*sf)->brush.lb.lbHatch = 0;
413
414 (*sf)->brush.gdibrush = CreateSolidBrush(col);
415 (*sf)->brush.bt = BrushTypeSolidColor;
416 (*sf)->color = color;
417
418 return Ok;
419 }
420
421 /******************************************************************************
422 * GdipCreateTexture [GDIPLUS.@]
423 *
424 * PARAMS
425 * image [I] image to use
426 * wrapmode [I] optional
427 * texture [O] pointer to the resulting texturebrush
428 *
429 * RETURNS
430 * SUCCESS: Ok
431 * FAILURE: element of GpStatus
432 */
433 GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
434 GpTexture **texture)
435 {
436 UINT width, height;
437 GpImageAttributes attributes;
438 GpStatus stat;
439
440 TRACE("%p, %d %p\n", image, wrapmode, texture);
441
442 if (!(image && texture))
443 return InvalidParameter;
444
445 stat = GdipGetImageWidth(image, &width);
446 if (stat != Ok) return stat;
447 stat = GdipGetImageHeight(image, &height);
448 if (stat != Ok) return stat;
449 attributes.wrap = wrapmode;
450
451 return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
452 texture);
453 }
454
455 /******************************************************************************
456 * GdipCreateTexture2 [GDIPLUS.@]
457 */
458 GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
459 REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
460 {
461 GpImageAttributes attributes;
462
463 TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
464 x, y, width, height, texture);
465
466 attributes.wrap = wrapmode;
467 return GdipCreateTextureIA(image, &attributes, x, y, width, height,
468 texture);
469 }
470
471 /******************************************************************************
472 * GdipCreateTextureIA [GDIPLUS.@]
473 *
474 * FIXME: imageattr ignored
475 */
476 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
477 GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
478 REAL height, GpTexture **texture)
479 {
480 HDC hdc;
481 OLE_HANDLE hbm;
482 HBITMAP old = NULL;
483 BITMAPINFO *pbmi;
484 BITMAPINFOHEADER *bmih;
485 INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
486 BOOL bm_is_selected;
487 BYTE *dibits, *buff, *textbits;
488 GpStatus status;
489
490 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
491 texture);
492
493 if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
494 return InvalidParameter;
495
496 if(image->type != ImageTypeBitmap){
497 FIXME("not implemented for image type %d\n", image->type);
498 return NotImplemented;
499 }
500
501 n_x = roundr(x);
502 n_y = roundr(y);
503 n_width = roundr(width);
504 n_height = roundr(height);
505
506 if(n_x + n_width > ((GpBitmap*)image)->width ||
507 n_y + n_height > ((GpBitmap*)image)->height)
508 return InvalidParameter;
509
510 IPicture_get_Handle(image->picture, &hbm);
511 if(!hbm) return GenericError;
512 IPicture_get_CurDC(image->picture, &hdc);
513 bm_is_selected = (hdc != 0);
514
515 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
516 if (!pbmi)
517 return OutOfMemory;
518 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
519 pbmi->bmiHeader.biBitCount = 0;
520
521 if(!bm_is_selected){
522 hdc = CreateCompatibleDC(0);
523 old = SelectObject(hdc, (HBITMAP)hbm);
524 }
525
526 /* fill out bmi */
527 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
528
529 bytespp = pbmi->bmiHeader.biBitCount / 8;
530 abs_height = abs(pbmi->bmiHeader.biHeight);
531
532 if(n_x > pbmi->bmiHeader.biWidth || n_x + n_width > pbmi->bmiHeader.biWidth ||
533 n_y > abs_height || n_y + n_height > abs_height){
534 GdipFree(pbmi);
535 return InvalidParameter;
536 }
537
538 dibits = GdipAlloc(pbmi->bmiHeader.biSizeImage);
539
540 if(dibits) /* this is not a good place to error out */
541 GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, pbmi, DIB_RGB_COLORS);
542
543 if(!bm_is_selected){
544 SelectObject(hdc, old);
545 DeleteDC(hdc);
546 }
547
548 if(!dibits){
549 GdipFree(pbmi);
550 return OutOfMemory;
551 }
552
553 image_stride = (pbmi->bmiHeader.biWidth * bytespp + 3) & ~3;
554 stride = (n_width * bytespp + 3) & ~3;
555 buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
556 if(!buff){
557 GdipFree(pbmi);
558 GdipFree(dibits);
559 return OutOfMemory;
560 }
561
562 bmih = (BITMAPINFOHEADER*)buff;
563 textbits = (BYTE*) (bmih + 1);
564 bmih->biSize = sizeof(BITMAPINFOHEADER);
565 bmih->biWidth = n_width;
566 bmih->biHeight = n_height;
567 bmih->biCompression = BI_RGB;
568 bmih->biSizeImage = stride * n_height;
569 bmih->biBitCount = pbmi->bmiHeader.biBitCount;
570 bmih->biClrUsed = 0;
571 bmih->biPlanes = 1;
572
573 /* image is flipped */
574 if(pbmi->bmiHeader.biHeight > 0){
575 dibits += pbmi->bmiHeader.biSizeImage;
576 image_stride *= -1;
577 textbits += stride * (n_height - 1);
578 stride *= -1;
579 }
580
581 GdipFree(pbmi);
582
583 for(i = 0; i < n_height; i++)
584 memcpy(&textbits[i * stride],
585 &dibits[n_x * bytespp + (n_y + i) * image_stride],
586 abs(stride));
587
588 *texture = GdipAlloc(sizeof(GpTexture));
589 if (!*texture){
590 GdipFree(dibits);
591 GdipFree(buff);
592 return OutOfMemory;
593 }
594
595 if((status = GdipCreateMatrix(&(*texture)->transform)) != Ok){
596 GdipFree(*texture);
597 GdipFree(dibits);
598 GdipFree(buff);
599 return status;
600 }
601
602 (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
603 (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
604 (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
605
606 (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
607 (*texture)->brush.bt = BrushTypeTextureFill;
608 (*texture)->wrap = imageattr->wrap;
609
610 GdipFree(dibits);
611 GdipFree(buff);
612
613 return Ok;
614 }
615
616 /******************************************************************************
617 * GdipCreateTextureIAI [GDIPLUS.@]
618 */
619 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
620 INT x, INT y, INT width, INT height, GpTexture **texture)
621 {
622 TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
623 texture);
624
625 return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
626 }
627
628 GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
629 INT x, INT y, INT width, INT height, GpTexture **texture)
630 {
631 GpImageAttributes imageattr;
632
633 TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
634 texture);
635
636 imageattr.wrap = wrapmode;
637
638 return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
639 }
640
641 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
642 {
643 TRACE("(%p, %p)\n", brush, type);
644
645 if(!brush || !type) return InvalidParameter;
646
647 *type = brush->bt;
648
649 return Ok;
650 }
651
652 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
653 {
654 TRACE("(%p)\n", brush);
655
656 if(!brush) return InvalidParameter;
657
658 switch(brush->bt)
659 {
660 case BrushTypePathGradient:
661 GdipFree(((GpPathGradient*) brush)->pathdata.Points);
662 GdipFree(((GpPathGradient*) brush)->pathdata.Types);
663 GdipFree(((GpPathGradient*) brush)->blendfac);
664 GdipFree(((GpPathGradient*) brush)->blendpos);
665 break;
666 case BrushTypeSolidColor:
667 case BrushTypeLinearGradient:
668 break;
669 case BrushTypeTextureFill:
670 GdipDeleteMatrix(((GpTexture*)brush)->transform);
671 break;
672 default:
673 break;
674 }
675
676 DeleteObject(brush->gdibrush);
677 GdipFree(brush);
678
679 return Ok;
680 }
681
682 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
683 BOOL *usinggamma)
684 {
685 TRACE("(%p, %p)\n", line, usinggamma);
686
687 if(!line || !usinggamma)
688 return InvalidParameter;
689
690 *usinggamma = line->gamma;
691
692 return Ok;
693 }
694
695 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
696 {
697 TRACE("(%p, %p)\n", brush, wrapmode);
698
699 if(!brush || !wrapmode)
700 return InvalidParameter;
701
702 *wrapmode = brush->wrap;
703
704 return Ok;
705 }
706
707 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
708 REAL *positions, INT count)
709 {
710 TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
711
712 if(!brush || !blend || !positions || count <= 0)
713 return InvalidParameter;
714
715 if(count < brush->blendcount)
716 return InsufficientBuffer;
717
718 memcpy(blend, brush->blendfac, count*sizeof(REAL));
719 if(brush->blendcount > 1){
720 memcpy(positions, brush->blendpos, count*sizeof(REAL));
721 }
722
723 return Ok;
724 }
725
726 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
727 {
728 TRACE("(%p, %p)\n", brush, count);
729
730 if(!brush || !count)
731 return InvalidParameter;
732
733 *count = brush->blendcount;
734
735 return Ok;
736 }
737
738 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
739 GpPointF *point)
740 {
741 TRACE("(%p, %p)\n", grad, point);
742
743 if(!grad || !point)
744 return InvalidParameter;
745
746 point->X = grad->center.X;
747 point->Y = grad->center.Y;
748
749 return Ok;
750 }
751
752 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
753 GpPoint *point)
754 {
755 GpStatus ret;
756 GpPointF ptf;
757
758 TRACE("(%p, %p)\n", grad, point);
759
760 if(!point)
761 return InvalidParameter;
762
763 ret = GdipGetPathGradientCenterPoint(grad,&ptf);
764
765 if(ret == Ok){
766 point->X = roundr(ptf.X);
767 point->Y = roundr(ptf.Y);
768 }
769
770 return ret;
771 }
772
773 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
774 REAL *x, REAL *y)
775 {
776 TRACE("(%p, %p, %p)\n", grad, x, y);
777
778 if(!grad || !x || !y)
779 return InvalidParameter;
780
781 *x = grad->focus.X;
782 *y = grad->focus.Y;
783
784 return Ok;
785 }
786
787 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
788 BOOL *gamma)
789 {
790 TRACE("(%p, %p)\n", grad, gamma);
791
792 if(!grad || !gamma)
793 return InvalidParameter;
794
795 *gamma = grad->gamma;
796
797 return Ok;
798 }
799
800 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
801 INT *count)
802 {
803 TRACE("(%p, %p)\n", grad, count);
804
805 if(!grad || !count)
806 return InvalidParameter;
807
808 *count = grad->pathdata.Count;
809
810 return Ok;
811 }
812
813 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
814 {
815 GpRectF r;
816 GpPath* path;
817 GpStatus stat;
818
819 TRACE("(%p, %p)\n", brush, rect);
820
821 if(!brush || !rect)
822 return InvalidParameter;
823
824 stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
825 brush->pathdata.Count, FillModeAlternate, &path);
826 if(stat != Ok) return stat;
827
828 stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
829 if(stat != Ok){
830 GdipDeletePath(path);
831 return stat;
832 }
833
834 memcpy(rect, &r, sizeof(GpRectF));
835
836 GdipDeletePath(path);
837
838 return Ok;
839 }
840
841 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
842 {
843 GpRectF rectf;
844 GpStatus stat;
845
846 TRACE("(%p, %p)\n", brush, rect);
847
848 if(!brush || !rect)
849 return InvalidParameter;
850
851 stat = GdipGetPathGradientRect(brush, &rectf);
852 if(stat != Ok) return stat;
853
854 rect->X = roundr(rectf.X);
855 rect->Y = roundr(rectf.Y);
856 rect->Width = roundr(rectf.Width);
857 rect->Height = roundr(rectf.Height);
858
859 return Ok;
860 }
861
862 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
863 *grad, ARGB *argb, INT *count)
864 {
865 static int calls;
866
867 if(!grad || !argb || !count || (*count < grad->pathdata.Count))
868 return InvalidParameter;
869
870 if(!(calls++))
871 FIXME("not implemented\n");
872
873 return NotImplemented;
874 }
875
876 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
877 GpWrapMode *wrapmode)
878 {
879 TRACE("(%p, %p)\n", brush, wrapmode);
880
881 if(!brush || !wrapmode)
882 return InvalidParameter;
883
884 *wrapmode = brush->wrap;
885
886 return Ok;
887 }
888
889 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
890 {
891 TRACE("(%p, %p)\n", sf, argb);
892
893 if(!sf || !argb)
894 return InvalidParameter;
895
896 *argb = sf->color;
897
898 return Ok;
899 }
900
901 /******************************************************************************
902 * GdipGetTextureTransform [GDIPLUS.@]
903 */
904 GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
905 {
906 TRACE("(%p, %p)\n", brush, matrix);
907
908 if(!brush || !matrix)
909 return InvalidParameter;
910
911 memcpy(matrix, brush->transform, sizeof(GpMatrix));
912
913 return Ok;
914 }
915
916 /******************************************************************************
917 * GdipGetTextureWrapMode [GDIPLUS.@]
918 */
919 GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
920 {
921 TRACE("(%p, %p)\n", brush, wrapmode);
922
923 if(!brush || !wrapmode)
924 return InvalidParameter;
925
926 *wrapmode = brush->wrap;
927
928 return Ok;
929 }
930
931 /******************************************************************************
932 * GdipResetTextureTransform [GDIPLUS.@]
933 */
934 GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush)
935 {
936 TRACE("(%p)\n", brush);
937
938 if(!brush)
939 return InvalidParameter;
940
941 return GdipSetMatrixElements(brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
942 }
943
944 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
945 GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
946 {
947 static int calls;
948
949 if(!brush || !blend || !positions || count <= 0)
950 return InvalidParameter;
951
952 if(!(calls++))
953 FIXME("not implemented\n");
954
955 return Ok;
956 }
957
958 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
959 BOOL usegamma)
960 {
961 TRACE("(%p, %d)\n", line, usegamma);
962
963 if(!line)
964 return InvalidParameter;
965
966 line->gamma = usegamma;
967
968 return Ok;
969 }
970
971 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
972 REAL scale)
973 {
974 static int calls;
975
976 if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
977 return InvalidParameter;
978
979 if(!(calls++))
980 FIXME("not implemented\n");
981
982 return NotImplemented;
983 }
984
985 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
986 GpWrapMode wrap)
987 {
988 TRACE("(%p, %d)\n", line, wrap);
989
990 if(!line || wrap == WrapModeClamp)
991 return InvalidParameter;
992
993 line->wrap = wrap;
994
995 return Ok;
996 }
997
998 GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend,
999 GDIPCONST REAL *pos, INT count)
1000 {
1001 static int calls;
1002
1003 if(!(calls++))
1004 FIXME("not implemented\n");
1005
1006 return NotImplemented;
1007 }
1008
1009 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
1010 ARGB argb)
1011 {
1012 TRACE("(%p, %x)\n", grad, argb);
1013
1014 if(!grad)
1015 return InvalidParameter;
1016
1017 grad->centercolor = argb;
1018 grad->brush.lb.lbColor = ARGB2COLORREF(argb);
1019
1020 DeleteObject(grad->brush.gdibrush);
1021 grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
1022
1023 return Ok;
1024 }
1025
1026 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
1027 GpPointF *point)
1028 {
1029 TRACE("(%p, %p)\n", grad, point);
1030
1031 if(!grad || !point)
1032 return InvalidParameter;
1033
1034 grad->center.X = point->X;
1035 grad->center.Y = point->Y;
1036
1037 return Ok;
1038 }
1039
1040 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
1041 GpPoint *point)
1042 {
1043 GpPointF ptf;
1044
1045 TRACE("(%p, %p)\n", grad, point);
1046
1047 if(!point)
1048 return InvalidParameter;
1049
1050 ptf.X = (REAL)point->X;
1051 ptf.Y = (REAL)point->Y;
1052
1053 return GdipSetPathGradientCenterPoint(grad,&ptf);
1054 }
1055
1056 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
1057 REAL x, REAL y)
1058 {
1059 TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
1060
1061 if(!grad)
1062 return InvalidParameter;
1063
1064 grad->focus.X = x;
1065 grad->focus.Y = y;
1066
1067 return Ok;
1068 }
1069
1070 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
1071 BOOL gamma)
1072 {
1073 TRACE("(%p, %d)\n", grad, gamma);
1074
1075 if(!grad)
1076 return InvalidParameter;
1077
1078 grad->gamma = gamma;
1079
1080 return Ok;
1081 }
1082
1083 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
1084 REAL focus, REAL scale)
1085 {
1086 static int calls;
1087
1088 if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1089 return InvalidParameter;
1090
1091 if(!(calls++))
1092 FIXME("not implemented\n");
1093
1094 return NotImplemented;
1095 }
1096
1097 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
1098 *grad, ARGB *argb, INT *count)
1099 {
1100 static int calls;
1101
1102 if(!grad || !argb || !count || (*count <= 0) ||
1103 (*count > grad->pathdata.Count))
1104 return InvalidParameter;
1105
1106 if(!(calls++))
1107 FIXME("not implemented\n");
1108
1109 return NotImplemented;
1110 }
1111
1112 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
1113 GpWrapMode wrap)
1114 {
1115 TRACE("(%p, %d)\n", grad, wrap);
1116
1117 if(!grad)
1118 return InvalidParameter;
1119
1120 grad->wrap = wrap;
1121
1122 return Ok;
1123 }
1124
1125 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
1126 {
1127 TRACE("(%p, %x)\n", sf, argb);
1128
1129 if(!sf)
1130 return InvalidParameter;
1131
1132 sf->color = argb;
1133 sf->brush.lb.lbColor = ARGB2COLORREF(argb);
1134
1135 DeleteObject(sf->brush.gdibrush);
1136 sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
1137
1138 return Ok;
1139 }
1140
1141 /******************************************************************************
1142 * GdipSetTextureTransform [GDIPLUS.@]
1143 */
1144 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
1145 GDIPCONST GpMatrix *matrix)
1146 {
1147 TRACE("(%p, %p)\n", texture, matrix);
1148
1149 if(!texture || !matrix)
1150 return InvalidParameter;
1151
1152 memcpy(texture->transform, matrix, sizeof(GpMatrix));
1153
1154 return Ok;
1155 }
1156
1157 /******************************************************************************
1158 * GdipSetTextureWrapMode [GDIPLUS.@]
1159 *
1160 * WrapMode not used, only stored
1161 */
1162 GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
1163 {
1164 TRACE("(%p, %d)\n", brush, wrapmode);
1165
1166 if(!brush)
1167 return InvalidParameter;
1168
1169 brush->wrap = wrapmode;
1170
1171 return Ok;
1172 }
1173
1174 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
1175 ARGB color2)
1176 {
1177 TRACE("(%p, %x, %x)\n", brush, color1, color2);
1178
1179 if(!brush)
1180 return InvalidParameter;
1181
1182 brush->startcolor = color1;
1183 brush->endcolor = color2;
1184
1185 return Ok;
1186 }
1187
1188 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
1189 {
1190 TRACE("(%p, %p)\n", brush, colors);
1191
1192 if(!brush || !colors)
1193 return InvalidParameter;
1194
1195 colors[0] = brush->startcolor;
1196 colors[1] = brush->endcolor;
1197
1198 return Ok;
1199 }
1200
1201 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
1202 REAL scale)
1203 {
1204 static int calls;
1205
1206 if(!(calls++))
1207 FIXME("not implemented\n");
1208
1209 return NotImplemented;
1210 }
1211
1212 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
1213 GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
1214 {
1215 static int calls;
1216
1217 if(!(calls++))
1218 FIXME("not implemented\n");
1219
1220 return NotImplemented;
1221 }
1222
1223 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
1224 GDIPCONST GpMatrix *matrix)
1225 {
1226 static int calls;
1227
1228 if(!(calls++))
1229 FIXME("not implemented\n");
1230
1231 return NotImplemented;
1232 }
1233
1234 GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
1235 REAL dx, REAL dy, GpMatrixOrder order)
1236 {
1237 FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
1238
1239 return NotImplemented;
1240 }
1241
1242 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
1243 {
1244 TRACE("(%p, %p)\n", brush, rect);
1245
1246 if(!brush || !rect)
1247 return InvalidParameter;
1248
1249 rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
1250 rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
1251
1252 rect->Width = fabs(brush->startpoint.X - brush->endpoint.X);
1253 rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
1254
1255 return Ok;
1256 }
1257
1258 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
1259 {
1260 GpRectF rectF;
1261 GpStatus ret;
1262
1263 TRACE("(%p, %p)\n", brush, rect);
1264
1265 if(!rect)
1266 return InvalidParameter;
1267
1268 ret = GdipGetLineRect(brush, &rectF);
1269
1270 if(ret == Ok){
1271 rect->X = roundr(rectF.X);
1272 rect->Y = roundr(rectF.Y);
1273 rect->Width = roundr(rectF.Width);
1274 rect->Height = roundr(rectF.Height);
1275 }
1276
1277 return ret;
1278 }
1279
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.