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 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
38 {
39 if(!brush || !clone)
40 return InvalidParameter;
41
42 switch(brush->bt){
43 case BrushTypeSolidColor:
44 *clone = GdipAlloc(sizeof(GpSolidFill));
45 if (!*clone) return OutOfMemory;
46
47 memcpy(*clone, brush, sizeof(GpSolidFill));
48
49 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
50 break;
51 case BrushTypePathGradient:{
52 GpPathGradient *src, *dest;
53 INT count;
54
55 *clone = GdipAlloc(sizeof(GpPathGradient));
56 if (!*clone) return OutOfMemory;
57
58 src = (GpPathGradient*) brush,
59 dest = (GpPathGradient*) *clone;
60 count = src->pathdata.Count;
61
62 memcpy(dest, src, sizeof(GpPathGradient));
63
64 dest->pathdata.Count = count;
65 dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
66 dest->pathdata.Types = GdipAlloc(count);
67
68 if(!dest->pathdata.Points || !dest->pathdata.Types){
69 GdipFree(dest->pathdata.Points);
70 GdipFree(dest->pathdata.Types);
71 GdipFree(dest);
72 return OutOfMemory;
73 }
74
75 memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
76 memcpy(dest->pathdata.Types, src->pathdata.Types, count);
77
78 /* blending */
79 count = src->blendcount;
80 dest->blendcount = count;
81 dest->blendfac = GdipAlloc(count * sizeof(REAL));
82 dest->blendpos = GdipAlloc(count * sizeof(REAL));
83
84 if(!dest->blendfac || !dest->blendpos){
85 GdipFree(dest->pathdata.Points);
86 GdipFree(dest->pathdata.Types);
87 GdipFree(dest->blendfac);
88 GdipFree(dest->blendpos);
89 GdipFree(dest);
90 return OutOfMemory;
91 }
92
93 memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
94 memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
95
96 break;
97 }
98 case BrushTypeLinearGradient:
99 *clone = GdipAlloc(sizeof(GpLineGradient));
100 if(!*clone) return OutOfMemory;
101
102 memcpy(*clone, brush, sizeof(GpLineGradient));
103
104 (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
105 break;
106 case BrushTypeTextureFill:
107 *clone = GdipAlloc(sizeof(GpTexture));
108 if(!*clone) return OutOfMemory;
109
110 memcpy(*clone, brush, sizeof(GpTexture));
111
112 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
113 break;
114 default:
115 ERR("not implemented for brush type %d\n", brush->bt);
116 return NotImplemented;
117 }
118
119 return Ok;
120 }
121
122 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
123 GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
124 GpWrapMode wrap, GpLineGradient **line)
125 {
126 COLORREF col = ARGB2COLORREF(startcolor);
127
128 if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
129 return InvalidParameter;
130
131 *line = GdipAlloc(sizeof(GpLineGradient));
132 if(!*line) return OutOfMemory;
133
134 (*line)->brush.lb.lbStyle = BS_SOLID;
135 (*line)->brush.lb.lbColor = col;
136 (*line)->brush.lb.lbHatch = 0;
137 (*line)->brush.gdibrush = CreateSolidBrush(col);
138 (*line)->brush.bt = BrushTypeLinearGradient;
139
140 (*line)->startpoint.X = startpoint->X;
141 (*line)->startpoint.Y = startpoint->Y;
142 (*line)->endpoint.X = endpoint->X;
143 (*line)->endpoint.Y = endpoint->Y;
144 (*line)->startcolor = startcolor;
145 (*line)->endcolor = endcolor;
146 (*line)->wrap = wrap;
147 (*line)->gamma = FALSE;
148
149 return Ok;
150 }
151
152 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
153 GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
154 GpWrapMode wrap, GpLineGradient **line)
155 {
156 GpPointF stF;
157 GpPointF endF;
158
159 if(!startpoint || !endpoint)
160 return InvalidParameter;
161
162 stF.X = (REAL)startpoint->X;
163 stF.Y = (REAL)startpoint->Y;
164 endF.X = (REAL)endpoint->X;
165 endF.X = (REAL)endpoint->Y;
166
167 return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
168 }
169
170 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
171 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
172 GpLineGradient **line)
173 {
174 GpPointF start, end;
175
176 if(!line || !rect)
177 return InvalidParameter;
178
179 start.X = rect->X;
180 start.Y = rect->Y;
181 end.X = rect->X + rect->Width;
182 end.Y = rect->Y + rect->Height;
183
184 return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
185 }
186
187 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
188 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
189 GpLineGradient **line)
190 {
191 GpRectF rectF;
192
193 rectF.X = (REAL) rect->X;
194 rectF.Y = (REAL) rect->Y;
195 rectF.Width = (REAL) rect->Width;
196 rectF.Height = (REAL) rect->Height;
197
198 return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
199 }
200
201 /* FIXME: angle value completely ignored. Don't know how to use it since native
202 always set Brush rectangle to rect (independetly of this angle).
203 Maybe it's used only on drawing. */
204 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
205 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
206 GpLineGradient **line)
207 {
208 return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
209 wrap, line);
210 }
211
212 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
213 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
214 GpLineGradient **line)
215 {
216 return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
217 wrap, line);
218 }
219
220 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
221 INT count, GpWrapMode wrap, GpPathGradient **grad)
222 {
223 COLORREF col = ARGB2COLORREF(0xffffffff);
224
225 if(!points || !grad)
226 return InvalidParameter;
227
228 if(count <= 0)
229 return OutOfMemory;
230
231 *grad = GdipAlloc(sizeof(GpPathGradient));
232 if (!*grad) return OutOfMemory;
233
234 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
235 if(!(*grad)->blendfac){
236 GdipFree(*grad);
237 return OutOfMemory;
238 }
239 (*grad)->blendfac[0] = 1.0;
240 (*grad)->blendpos = NULL;
241 (*grad)->blendcount = 1;
242
243 (*grad)->pathdata.Count = count;
244 (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
245 (*grad)->pathdata.Types = GdipAlloc(count);
246
247 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
248 GdipFree((*grad)->pathdata.Points);
249 GdipFree((*grad)->pathdata.Types);
250 GdipFree(*grad);
251 return OutOfMemory;
252 }
253
254 memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
255 memset((*grad)->pathdata.Types, PathPointTypeLine, count);
256
257 (*grad)->brush.lb.lbStyle = BS_SOLID;
258 (*grad)->brush.lb.lbColor = col;
259 (*grad)->brush.lb.lbHatch = 0;
260
261 (*grad)->brush.gdibrush = CreateSolidBrush(col);
262 (*grad)->brush.bt = BrushTypePathGradient;
263 (*grad)->centercolor = 0xffffffff;
264 (*grad)->wrap = wrap;
265 (*grad)->gamma = FALSE;
266 (*grad)->center.X = 0.0;
267 (*grad)->center.Y = 0.0;
268 (*grad)->focus.X = 0.0;
269 (*grad)->focus.Y = 0.0;
270
271 return Ok;
272 }
273
274 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
275 INT count, GpWrapMode wrap, GpPathGradient **grad)
276 {
277 GpPointF *pointsF;
278 GpStatus ret;
279 INT i;
280
281 if(!points || !grad)
282 return InvalidParameter;
283
284 if(count <= 0)
285 return OutOfMemory;
286
287 pointsF = GdipAlloc(sizeof(GpPointF) * count);
288 if(!pointsF)
289 return OutOfMemory;
290
291 for(i = 0; i < count; i++){
292 pointsF[i].X = (REAL)points[i].X;
293 pointsF[i].Y = (REAL)points[i].Y;
294 }
295
296 ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
297 GdipFree(pointsF);
298
299 return ret;
300 }
301
302 /* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
303 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
304 GpPathGradient **grad)
305 {
306 COLORREF col = ARGB2COLORREF(0xffffffff);
307
308 if(!path || !grad)
309 return InvalidParameter;
310
311 *grad = GdipAlloc(sizeof(GpPathGradient));
312 if (!*grad) return OutOfMemory;
313
314 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
315 if(!(*grad)->blendfac){
316 GdipFree(*grad);
317 return OutOfMemory;
318 }
319 (*grad)->blendfac[0] = 1.0;
320 (*grad)->blendpos = NULL;
321 (*grad)->blendcount = 1;
322
323 (*grad)->pathdata.Count = path->pathdata.Count;
324 (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
325 (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
326
327 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
328 GdipFree((*grad)->pathdata.Points);
329 GdipFree((*grad)->pathdata.Types);
330 GdipFree(*grad);
331 return OutOfMemory;
332 }
333
334 memcpy((*grad)->pathdata.Points, path->pathdata.Points,
335 path->pathdata.Count * sizeof(PointF));
336 memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
337
338 (*grad)->brush.lb.lbStyle = BS_SOLID;
339 (*grad)->brush.lb.lbColor = col;
340 (*grad)->brush.lb.lbHatch = 0;
341
342 (*grad)->brush.gdibrush = CreateSolidBrush(col);
343 (*grad)->brush.bt = BrushTypePathGradient;
344 (*grad)->centercolor = 0xffffffff;
345 (*grad)->wrap = WrapModeClamp;
346 (*grad)->gamma = FALSE;
347 /* FIXME: this should be set to the "centroid" of the path by default */
348 (*grad)->center.X = 0.0;
349 (*grad)->center.Y = 0.0;
350 (*grad)->focus.X = 0.0;
351 (*grad)->focus.Y = 0.0;
352
353 return Ok;
354 }
355
356 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
357 {
358 COLORREF col = ARGB2COLORREF(color);
359
360 if(!sf) return InvalidParameter;
361
362 *sf = GdipAlloc(sizeof(GpSolidFill));
363 if (!*sf) return OutOfMemory;
364
365 (*sf)->brush.lb.lbStyle = BS_SOLID;
366 (*sf)->brush.lb.lbColor = col;
367 (*sf)->brush.lb.lbHatch = 0;
368
369 (*sf)->brush.gdibrush = CreateSolidBrush(col);
370 (*sf)->brush.bt = BrushTypeSolidColor;
371 (*sf)->color = color;
372
373 return Ok;
374 }
375
376 /* FIXME: imageattr ignored */
377 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
378 GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
379 REAL height, GpTexture **texture)
380 {
381 HDC hdc;
382 OLE_HANDLE hbm;
383 HBITMAP old = NULL;
384 BITMAPINFO bmi;
385 BITMAPINFOHEADER *bmih;
386 INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
387 BOOL bm_is_selected;
388 BYTE *dibits, *buff, *textbits;
389
390 if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
391 return InvalidParameter;
392
393 if(image->type != ImageTypeBitmap){
394 FIXME("not implemented for image type %d\n", image->type);
395 return NotImplemented;
396 }
397
398 n_x = roundr(x);
399 n_y = roundr(y);
400 n_width = roundr(width);
401 n_height = roundr(height);
402
403 if(n_x + n_width > ((GpBitmap*)image)->width ||
404 n_y + n_height > ((GpBitmap*)image)->height)
405 return InvalidParameter;
406
407 IPicture_get_Handle(image->picture, &hbm);
408 if(!hbm) return GenericError;
409 IPicture_get_CurDC(image->picture, &hdc);
410 bm_is_selected = (hdc != 0);
411
412 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
413 bmi.bmiHeader.biBitCount = 0;
414
415 if(!bm_is_selected){
416 hdc = CreateCompatibleDC(0);
417 old = SelectObject(hdc, (HBITMAP)hbm);
418 }
419
420 /* fill out bmi */
421 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
422
423 bytespp = bmi.bmiHeader.biBitCount / 8;
424 abs_height = abs(bmi.bmiHeader.biHeight);
425
426 if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
427 n_y > abs_height || n_y + n_height > abs_height)
428 return InvalidParameter;
429
430 dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
431
432 if(dibits) /* this is not a good place to error out */
433 GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
434
435 if(!bm_is_selected){
436 SelectObject(hdc, old);
437 DeleteDC(hdc);
438 }
439
440 if(!dibits)
441 return OutOfMemory;
442
443 image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
444 stride = (n_width * bytespp + 3) & ~3;
445 buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
446 if(!buff){
447 GdipFree(dibits);
448 return OutOfMemory;
449 }
450
451 bmih = (BITMAPINFOHEADER*)buff;
452 textbits = (BYTE*) (bmih + 1);
453 bmih->biSize = sizeof(BITMAPINFOHEADER);
454 bmih->biWidth = n_width;
455 bmih->biHeight = n_height;
456 bmih->biCompression = BI_RGB;
457 bmih->biSizeImage = stride * n_height;
458 bmih->biBitCount = bmi.bmiHeader.biBitCount;
459 bmih->biClrUsed = 0;
460 bmih->biPlanes = 1;
461
462 /* image is flipped */
463 if(bmi.bmiHeader.biHeight > 0){
464 dibits += bmi.bmiHeader.biSizeImage;
465 image_stride *= -1;
466 textbits += stride * (n_height - 1);
467 stride *= -1;
468 }
469
470 for(i = 0; i < n_height; i++)
471 memcpy(&textbits[i * stride],
472 &dibits[n_x * bytespp + (n_y + i) * image_stride],
473 abs(stride));
474
475 *texture = GdipAlloc(sizeof(GpTexture));
476 if (!*texture) return OutOfMemory;
477
478 (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
479 (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
480 (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
481
482 (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
483 (*texture)->brush.bt = BrushTypeTextureFill;
484
485 GdipFree(dibits);
486 GdipFree(buff);
487
488 return Ok;
489 }
490
491 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
492 INT x, INT y, INT width, INT height, GpTexture **texture)
493 {
494 return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
495 }
496
497 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
498 {
499 if(!brush || !type) return InvalidParameter;
500
501 *type = brush->bt;
502
503 return Ok;
504 }
505
506 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
507 {
508 if(!brush) return InvalidParameter;
509
510 switch(brush->bt)
511 {
512 case BrushTypePathGradient:
513 GdipFree(((GpPathGradient*) brush)->pathdata.Points);
514 GdipFree(((GpPathGradient*) brush)->pathdata.Types);
515 GdipFree(((GpPathGradient*) brush)->blendfac);
516 GdipFree(((GpPathGradient*) brush)->blendpos);
517 break;
518 case BrushTypeSolidColor:
519 case BrushTypeLinearGradient:
520 case BrushTypeTextureFill:
521 default:
522 break;
523 }
524
525 DeleteObject(brush->gdibrush);
526 GdipFree(brush);
527
528 return Ok;
529 }
530
531 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
532 BOOL *usinggamma)
533 {
534 if(!line)
535 return InvalidParameter;
536
537 *usinggamma = line->gamma;
538
539 return Ok;
540 }
541
542 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
543 {
544 if(!brush || !wrapmode)
545 return InvalidParameter;
546
547 *wrapmode = brush->wrap;
548
549 return Ok;
550 }
551
552 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
553 REAL *positions, INT count)
554 {
555 if(!brush || !blend || !positions || count <= 0)
556 return InvalidParameter;
557
558 if(count < brush->blendcount)
559 return InsufficientBuffer;
560
561 memcpy(blend, brush->blendfac, count*sizeof(REAL));
562 if(brush->blendcount > 1){
563 memcpy(positions, brush->blendpos, count*sizeof(REAL));
564 }
565
566 return Ok;
567 }
568
569 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
570 {
571 if(!brush || !count)
572 return InvalidParameter;
573
574 *count = brush->blendcount;
575
576 return Ok;
577 }
578
579 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
580 GpPointF *point)
581 {
582 if(!grad || !point)
583 return InvalidParameter;
584
585 point->X = grad->center.X;
586 point->Y = grad->center.Y;
587
588 return Ok;
589 }
590
591 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
592 GpPoint *point)
593 {
594 GpStatus ret;
595 GpPointF ptf;
596
597 if(!point)
598 return InvalidParameter;
599
600 ret = GdipGetPathGradientCenterPoint(grad,&ptf);
601
602 if(ret == Ok){
603 point->X = roundr(ptf.X);
604 point->Y = roundr(ptf.Y);
605 }
606
607 return ret;
608 }
609
610 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
611 REAL *x, REAL *y)
612 {
613 if(!grad || !x || !y)
614 return InvalidParameter;
615
616 *x = grad->focus.X;
617 *y = grad->focus.Y;
618
619 return Ok;
620 }
621
622 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
623 BOOL *gamma)
624 {
625 if(!grad || !gamma)
626 return InvalidParameter;
627
628 *gamma = grad->gamma;
629
630 return Ok;
631 }
632
633 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
634 INT *count)
635 {
636 if(!grad || !count)
637 return InvalidParameter;
638
639 *count = grad->pathdata.Count;
640
641 return Ok;
642 }
643
644 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
645 {
646 GpRectF r;
647 GpPath* path;
648 GpStatus stat;
649
650 if(!brush || !rect)
651 return InvalidParameter;
652
653 stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
654 brush->pathdata.Count, FillModeAlternate, &path);
655 if(stat != Ok) return stat;
656
657 stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
658 if(stat != Ok){
659 GdipDeletePath(path);
660 return stat;
661 }
662
663 memcpy(rect, &r, sizeof(GpRectF));
664
665 GdipDeletePath(path);
666
667 return Ok;
668 }
669
670 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
671 {
672 GpRectF rectf;
673 GpStatus stat;
674
675 if(!brush || !rect)
676 return InvalidParameter;
677
678 stat = GdipGetPathGradientRect(brush, &rectf);
679 if(stat != Ok) return stat;
680
681 rect->X = roundr(rectf.X);
682 rect->Y = roundr(rectf.Y);
683 rect->Width = roundr(rectf.Width);
684 rect->Height = roundr(rectf.Height);
685
686 return Ok;
687 }
688
689 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
690 *grad, ARGB *argb, INT *count)
691 {
692 static int calls;
693
694 if(!grad || !argb || !count || (*count < grad->pathdata.Count))
695 return InvalidParameter;
696
697 if(!(calls++))
698 FIXME("not implemented\n");
699
700 return NotImplemented;
701 }
702
703 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
704 GpWrapMode *wrapmode)
705 {
706 if(!brush || !wrapmode)
707 return InvalidParameter;
708
709 *wrapmode = brush->wrap;
710
711 return Ok;
712 }
713
714 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
715 {
716 if(!sf || !argb)
717 return InvalidParameter;
718
719 *argb = sf->color;
720
721 return Ok;
722 }
723
724 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
725 GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
726 {
727 static int calls;
728
729 if(!brush || !blend || !positions || count <= 0)
730 return InvalidParameter;
731
732 if(!(calls++))
733 FIXME("not implemented\n");
734
735 return Ok;
736 }
737
738 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
739 BOOL usegamma)
740 {
741 if(!line)
742 return InvalidParameter;
743
744 line->gamma = usegamma;
745
746 return Ok;
747 }
748
749 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
750 REAL scale)
751 {
752 static int calls;
753
754 if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
755 return InvalidParameter;
756
757 if(!(calls++))
758 FIXME("not implemented\n");
759
760 return NotImplemented;
761 }
762
763 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
764 GpWrapMode wrap)
765 {
766 if(!line || wrap == WrapModeClamp)
767 return InvalidParameter;
768
769 line->wrap = wrap;
770
771 return Ok;
772 }
773
774 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
775 ARGB argb)
776 {
777 if(!grad)
778 return InvalidParameter;
779
780 grad->centercolor = argb;
781 grad->brush.lb.lbColor = ARGB2COLORREF(argb);
782
783 DeleteObject(grad->brush.gdibrush);
784 grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
785
786 return Ok;
787 }
788
789 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
790 GpPointF *point)
791 {
792 if(!grad || !point)
793 return InvalidParameter;
794
795 grad->center.X = point->X;
796 grad->center.Y = point->Y;
797
798 return Ok;
799 }
800
801 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
802 GpPoint *point)
803 {
804 GpPointF ptf;
805
806 if(!point)
807 return InvalidParameter;
808
809 ptf.X = (REAL)point->X;
810 ptf.Y = (REAL)point->Y;
811
812 return GdipSetPathGradientCenterPoint(grad,&ptf);
813 }
814
815 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
816 REAL x, REAL y)
817 {
818 if(!grad)
819 return InvalidParameter;
820
821 grad->focus.X = x;
822 grad->focus.Y = y;
823
824 return Ok;
825 }
826
827 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
828 BOOL gamma)
829 {
830 if(!grad)
831 return InvalidParameter;
832
833 grad->gamma = gamma;
834
835 return Ok;
836 }
837
838 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
839 REAL focus, REAL scale)
840 {
841 static int calls;
842
843 if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
844 return InvalidParameter;
845
846 if(!(calls++))
847 FIXME("not implemented\n");
848
849 return NotImplemented;
850 }
851
852 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
853 *grad, ARGB *argb, INT *count)
854 {
855 static int calls;
856
857 if(!grad || !argb || !count || (*count <= 0) ||
858 (*count > grad->pathdata.Count))
859 return InvalidParameter;
860
861 if(!(calls++))
862 FIXME("not implemented\n");
863
864 return NotImplemented;
865 }
866
867 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
868 GpWrapMode wrap)
869 {
870 if(!grad)
871 return InvalidParameter;
872
873 grad->wrap = wrap;
874
875 return Ok;
876 }
877
878 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
879 {
880 if(!sf)
881 return InvalidParameter;
882
883 sf->color = argb;
884 sf->brush.lb.lbColor = ARGB2COLORREF(argb);
885
886 DeleteObject(sf->brush.gdibrush);
887 sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
888
889 return Ok;
890 }
891
892 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
893 GDIPCONST GpMatrix *matrix)
894 {
895 static int calls;
896
897 if(!texture || !matrix)
898 return InvalidParameter;
899
900 if(!(calls++))
901 FIXME("not implemented\n");
902
903 return Ok;
904 }
905
906 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
907 ARGB color2)
908 {
909 if(!brush)
910 return InvalidParameter;
911
912 brush->startcolor = color1;
913 brush->endcolor = color2;
914
915 return Ok;
916 }
917
918 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
919 {
920 if(!brush || !colors)
921 return InvalidParameter;
922
923 colors[0] = brush->startcolor;
924 colors[1] = brush->endcolor;
925
926 return Ok;
927 }
928
929 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
930 REAL scale)
931 {
932 static int calls;
933
934 if(!(calls++))
935 FIXME("not implemented\n");
936
937 return NotImplemented;
938 }
939
940 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
941 GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
942 {
943 static int calls;
944
945 if(!(calls++))
946 FIXME("not implemented\n");
947
948 return NotImplemented;
949 }
950
951 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
952 GDIPCONST GpMatrix *matrix)
953 {
954 static int calls;
955
956 if(!(calls++))
957 FIXME("not implemented\n");
958
959 return NotImplemented;
960 }
961
962 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
963 {
964 if(!brush || !rect)
965 return InvalidParameter;
966
967 rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
968 rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
969
970 rect->Width = fabs(brush->startpoint.X - brush->endpoint.X);
971 rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
972
973 return Ok;
974 }
975
976 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
977 {
978 GpRectF rectF;
979 GpStatus ret;
980
981 if(!rect)
982 return InvalidParameter;
983
984 ret = GdipGetLineRect(brush, &rectF);
985
986 if(ret == Ok){
987 rect->X = roundr(rectF.X);
988 rect->Y = roundr(rectF.Y);
989 rect->Width = roundr(rectF.Width);
990 rect->Height = roundr(rectF.Height);
991 }
992
993 return ret;
994 }
995
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.