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 {
50 GpSolidFill *fill;
51 *clone = GdipAlloc(sizeof(GpSolidFill));
52 if (!*clone) return OutOfMemory;
53
54 fill = (GpSolidFill*)*clone;
55
56 memcpy(*clone, brush, sizeof(GpSolidFill));
57
58 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
59 fill->bmp = ARGB2BMP(fill->color);
60 break;
61 }
62 case BrushTypeHatchFill:
63 *clone = GdipAlloc(sizeof(GpHatch));
64 if (!*clone) return OutOfMemory;
65
66 memcpy(*clone, brush, sizeof(GpHatch));
67
68 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
69 break;
70 case BrushTypePathGradient:{
71 GpPathGradient *src, *dest;
72 INT count;
73
74 *clone = GdipAlloc(sizeof(GpPathGradient));
75 if (!*clone) return OutOfMemory;
76
77 src = (GpPathGradient*) brush,
78 dest = (GpPathGradient*) *clone;
79 count = src->pathdata.Count;
80
81 memcpy(dest, src, sizeof(GpPathGradient));
82
83 dest->pathdata.Count = count;
84 dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
85 dest->pathdata.Types = GdipAlloc(count);
86
87 if(!dest->pathdata.Points || !dest->pathdata.Types){
88 GdipFree(dest->pathdata.Points);
89 GdipFree(dest->pathdata.Types);
90 GdipFree(dest);
91 return OutOfMemory;
92 }
93
94 memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
95 memcpy(dest->pathdata.Types, src->pathdata.Types, count);
96
97 /* blending */
98 count = src->blendcount;
99 dest->blendcount = count;
100 dest->blendfac = GdipAlloc(count * sizeof(REAL));
101 dest->blendpos = GdipAlloc(count * sizeof(REAL));
102
103 if(!dest->blendfac || !dest->blendpos){
104 GdipFree(dest->pathdata.Points);
105 GdipFree(dest->pathdata.Types);
106 GdipFree(dest->blendfac);
107 GdipFree(dest->blendpos);
108 GdipFree(dest);
109 return OutOfMemory;
110 }
111
112 memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
113 memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
114
115 break;
116 }
117 case BrushTypeLinearGradient:{
118 GpLineGradient *dest, *src;
119 INT count;
120
121 dest = GdipAlloc(sizeof(GpLineGradient));
122 if(!dest) return OutOfMemory;
123
124 src = (GpLineGradient*)brush;
125
126 memcpy(dest, src, sizeof(GpLineGradient));
127
128 dest->brush.gdibrush = CreateSolidBrush(dest->brush.lb.lbColor);
129
130 count = dest->blendcount;
131 dest->blendfac = GdipAlloc(count * sizeof(REAL));
132 dest->blendpos = GdipAlloc(count * sizeof(REAL));
133
134 if (!dest->blendfac || !dest->blendpos)
135 {
136 GdipFree(dest->blendfac);
137 GdipFree(dest->blendpos);
138 DeleteObject(dest->brush.gdibrush);
139 GdipFree(dest);
140 return OutOfMemory;
141 }
142
143 memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
144 memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
145
146 *clone = &dest->brush;
147 break;
148 }
149 case BrushTypeTextureFill:
150 *clone = GdipAlloc(sizeof(GpTexture));
151 if(!*clone) return OutOfMemory;
152
153 memcpy(*clone, brush, sizeof(GpTexture));
154
155 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
156 break;
157 default:
158 ERR("not implemented for brush type %d\n", brush->bt);
159 return NotImplemented;
160 }
161
162 return Ok;
163 }
164
165 static LONG HatchStyleToHatch(HatchStyle hatchstyle)
166 {
167 switch (hatchstyle)
168 {
169 case HatchStyleHorizontal: return HS_HORIZONTAL;
170 case HatchStyleVertical: return HS_VERTICAL;
171 case HatchStyleForwardDiagonal: return HS_FDIAGONAL;
172 case HatchStyleBackwardDiagonal: return HS_BDIAGONAL;
173 case HatchStyleCross: return HS_CROSS;
174 case HatchStyleDiagonalCross: return HS_DIAGCROSS;
175 default: return 0;
176 }
177 }
178
179 /******************************************************************************
180 * GdipCreateHatchBrush [GDIPLUS.@]
181 */
182 GpStatus WINGDIPAPI GdipCreateHatchBrush(HatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
183 {
184 COLORREF fgcol = ARGB2COLORREF(forecol);
185
186 TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
187
188 if(!brush) return InvalidParameter;
189
190 *brush = GdipAlloc(sizeof(GpHatch));
191 if (!*brush) return OutOfMemory;
192
193 switch (hatchstyle)
194 {
195 case HatchStyleHorizontal:
196 case HatchStyleVertical:
197 case HatchStyleForwardDiagonal:
198 case HatchStyleBackwardDiagonal:
199 case HatchStyleCross:
200 case HatchStyleDiagonalCross:
201 /* Brushes that map to BS_HATCHED */
202 (*brush)->brush.lb.lbStyle = BS_HATCHED;
203 (*brush)->brush.lb.lbColor = fgcol;
204 (*brush)->brush.lb.lbHatch = HatchStyleToHatch(hatchstyle);
205 break;
206
207 default:
208 FIXME("Unimplemented hatch style %d\n", hatchstyle);
209
210 (*brush)->brush.lb.lbStyle = BS_SOLID;
211 (*brush)->brush.lb.lbColor = fgcol;
212 (*brush)->brush.lb.lbHatch = 0;
213 break;
214 }
215
216
217 (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
218 (*brush)->brush.bt = BrushTypeHatchFill;
219 (*brush)->forecol = forecol;
220 (*brush)->backcol = backcol;
221 (*brush)->hatchstyle = hatchstyle;
222
223 return Ok;
224 }
225
226 /******************************************************************************
227 * GdipCreateLineBrush [GDIPLUS.@]
228 */
229 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
230 GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
231 GpWrapMode wrap, GpLineGradient **line)
232 {
233 COLORREF col = ARGB2COLORREF(startcolor);
234
235 TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
236 startcolor, endcolor, wrap, line);
237
238 if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
239 return InvalidParameter;
240
241 *line = GdipAlloc(sizeof(GpLineGradient));
242 if(!*line) return OutOfMemory;
243
244 (*line)->brush.lb.lbStyle = BS_SOLID;
245 (*line)->brush.lb.lbColor = col;
246 (*line)->brush.lb.lbHatch = 0;
247 (*line)->brush.gdibrush = CreateSolidBrush(col);
248 (*line)->brush.bt = BrushTypeLinearGradient;
249
250 (*line)->startpoint.X = startpoint->X;
251 (*line)->startpoint.Y = startpoint->Y;
252 (*line)->endpoint.X = endpoint->X;
253 (*line)->endpoint.Y = endpoint->Y;
254 (*line)->startcolor = startcolor;
255 (*line)->endcolor = endcolor;
256 (*line)->wrap = wrap;
257 (*line)->gamma = FALSE;
258
259 (*line)->rect.X = (startpoint->X < endpoint->X ? startpoint->X: endpoint->X);
260 (*line)->rect.Y = (startpoint->Y < endpoint->Y ? startpoint->Y: endpoint->Y);
261 (*line)->rect.Width = fabs(startpoint->X - endpoint->X);
262 (*line)->rect.Height = fabs(startpoint->Y - endpoint->Y);
263
264 (*line)->blendcount = 1;
265 (*line)->blendfac = GdipAlloc(sizeof(REAL));
266 (*line)->blendpos = GdipAlloc(sizeof(REAL));
267
268 if (!(*line)->blendfac || !(*line)->blendpos)
269 {
270 GdipFree((*line)->blendfac);
271 GdipFree((*line)->blendpos);
272 DeleteObject((*line)->brush.gdibrush);
273 GdipFree(*line);
274 *line = NULL;
275 return OutOfMemory;
276 }
277
278 (*line)->blendfac[0] = 1.0f;
279 (*line)->blendpos[0] = 1.0f;
280
281 return Ok;
282 }
283
284 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
285 GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
286 GpWrapMode wrap, GpLineGradient **line)
287 {
288 GpPointF stF;
289 GpPointF endF;
290
291 TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
292 startcolor, endcolor, wrap, line);
293
294 if(!startpoint || !endpoint)
295 return InvalidParameter;
296
297 stF.X = (REAL)startpoint->X;
298 stF.Y = (REAL)startpoint->Y;
299 endF.X = (REAL)endpoint->X;
300 endF.X = (REAL)endpoint->Y;
301
302 return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
303 }
304
305 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
306 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
307 GpLineGradient **line)
308 {
309 GpPointF start, end;
310 GpStatus stat;
311
312 TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
313 wrap, line);
314
315 if(!line || !rect)
316 return InvalidParameter;
317
318 switch (mode)
319 {
320 case LinearGradientModeHorizontal:
321 start.X = rect->X;
322 start.Y = rect->Y;
323 end.X = rect->X + rect->Width;
324 end.Y = rect->Y;
325 break;
326 case LinearGradientModeVertical:
327 start.X = rect->X;
328 start.Y = rect->Y;
329 end.X = rect->X;
330 end.Y = rect->Y + rect->Height;
331 break;
332 case LinearGradientModeForwardDiagonal:
333 start.X = rect->X;
334 start.Y = rect->Y;
335 end.X = rect->X + rect->Width;
336 end.Y = rect->Y + rect->Height;
337 break;
338 case LinearGradientModeBackwardDiagonal:
339 start.X = rect->X + rect->Width;
340 start.Y = rect->Y;
341 end.X = rect->X;
342 end.Y = rect->Y + rect->Height;
343 break;
344 default:
345 return InvalidParameter;
346 }
347
348 stat = GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
349
350 if (stat == Ok)
351 (*line)->rect = *rect;
352
353 return stat;
354 }
355
356 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
357 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
358 GpLineGradient **line)
359 {
360 GpRectF rectF;
361
362 TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
363 wrap, line);
364
365 rectF.X = (REAL) rect->X;
366 rectF.Y = (REAL) rect->Y;
367 rectF.Width = (REAL) rect->Width;
368 rectF.Height = (REAL) rect->Height;
369
370 return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
371 }
372
373 /******************************************************************************
374 * GdipCreateLineBrushFromRectWithAngle [GDIPLUS.@]
375 *
376 * FIXME: angle value completely ignored. Don't know how to use it since native
377 * always set Brush rectangle to rect (independetly of this angle).
378 * Maybe it's used only on drawing.
379 */
380 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
381 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
382 GpLineGradient **line)
383 {
384 TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
385 wrap, line);
386
387 return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
388 wrap, line);
389 }
390
391 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
392 ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
393 GpLineGradient **line)
394 {
395 TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
396 wrap, line);
397
398 return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
399 wrap, line);
400 }
401
402 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
403 INT count, GpWrapMode wrap, GpPathGradient **grad)
404 {
405 COLORREF col = ARGB2COLORREF(0xffffffff);
406
407 TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
408
409 if(!points || !grad)
410 return InvalidParameter;
411
412 if(count <= 0)
413 return OutOfMemory;
414
415 *grad = GdipAlloc(sizeof(GpPathGradient));
416 if (!*grad) return OutOfMemory;
417
418 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
419 if(!(*grad)->blendfac){
420 GdipFree(*grad);
421 return OutOfMemory;
422 }
423 (*grad)->blendfac[0] = 1.0;
424 (*grad)->blendpos = NULL;
425 (*grad)->blendcount = 1;
426
427 (*grad)->pathdata.Count = count;
428 (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
429 (*grad)->pathdata.Types = GdipAlloc(count);
430
431 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
432 GdipFree((*grad)->pathdata.Points);
433 GdipFree((*grad)->pathdata.Types);
434 GdipFree(*grad);
435 return OutOfMemory;
436 }
437
438 memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
439 memset((*grad)->pathdata.Types, PathPointTypeLine, count);
440
441 (*grad)->brush.lb.lbStyle = BS_SOLID;
442 (*grad)->brush.lb.lbColor = col;
443 (*grad)->brush.lb.lbHatch = 0;
444
445 (*grad)->brush.gdibrush = CreateSolidBrush(col);
446 (*grad)->brush.bt = BrushTypePathGradient;
447 (*grad)->centercolor = 0xffffffff;
448 (*grad)->wrap = wrap;
449 (*grad)->gamma = FALSE;
450 (*grad)->center.X = 0.0;
451 (*grad)->center.Y = 0.0;
452 (*grad)->focus.X = 0.0;
453 (*grad)->focus.Y = 0.0;
454
455 return Ok;
456 }
457
458 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
459 INT count, GpWrapMode wrap, GpPathGradient **grad)
460 {
461 GpPointF *pointsF;
462 GpStatus ret;
463 INT i;
464
465 TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
466
467 if(!points || !grad)
468 return InvalidParameter;
469
470 if(count <= 0)
471 return OutOfMemory;
472
473 pointsF = GdipAlloc(sizeof(GpPointF) * count);
474 if(!pointsF)
475 return OutOfMemory;
476
477 for(i = 0; i < count; i++){
478 pointsF[i].X = (REAL)points[i].X;
479 pointsF[i].Y = (REAL)points[i].Y;
480 }
481
482 ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
483 GdipFree(pointsF);
484
485 return ret;
486 }
487
488 /******************************************************************************
489 * GdipCreatePathGradientFromPath [GDIPLUS.@]
490 *
491 * FIXME: path gradient brushes not truly supported (drawn as solid brushes)
492 */
493 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
494 GpPathGradient **grad)
495 {
496 COLORREF col = ARGB2COLORREF(0xffffffff);
497
498 TRACE("(%p, %p)\n", path, grad);
499
500 if(!path || !grad)
501 return InvalidParameter;
502
503 *grad = GdipAlloc(sizeof(GpPathGradient));
504 if (!*grad) return OutOfMemory;
505
506 (*grad)->blendfac = GdipAlloc(sizeof(REAL));
507 if(!(*grad)->blendfac){
508 GdipFree(*grad);
509 return OutOfMemory;
510 }
511 (*grad)->blendfac[0] = 1.0;
512 (*grad)->blendpos = NULL;
513 (*grad)->blendcount = 1;
514
515 (*grad)->pathdata.Count = path->pathdata.Count;
516 (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
517 (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
518
519 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
520 GdipFree((*grad)->pathdata.Points);
521 GdipFree((*grad)->pathdata.Types);
522 GdipFree(*grad);
523 return OutOfMemory;
524 }
525
526 memcpy((*grad)->pathdata.Points, path->pathdata.Points,
527 path->pathdata.Count * sizeof(PointF));
528 memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
529
530 (*grad)->brush.lb.lbStyle = BS_SOLID;
531 (*grad)->brush.lb.lbColor = col;
532 (*grad)->brush.lb.lbHatch = 0;
533
534 (*grad)->brush.gdibrush = CreateSolidBrush(col);
535 (*grad)->brush.bt = BrushTypePathGradient;
536 (*grad)->centercolor = 0xffffffff;
537 (*grad)->wrap = WrapModeClamp;
538 (*grad)->gamma = FALSE;
539 /* FIXME: this should be set to the "centroid" of the path by default */
540 (*grad)->center.X = 0.0;
541 (*grad)->center.Y = 0.0;
542 (*grad)->focus.X = 0.0;
543 (*grad)->focus.Y = 0.0;
544
545 return Ok;
546 }
547
548 /******************************************************************************
549 * GdipCreateSolidFill [GDIPLUS.@]
550 */
551 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
552 {
553 COLORREF col = ARGB2COLORREF(color);
554
555 TRACE("(%x, %p)\n", color, sf);
556
557 if(!sf) return InvalidParameter;
558
559 *sf = GdipAlloc(sizeof(GpSolidFill));
560 if (!*sf) return OutOfMemory;
561
562 (*sf)->brush.lb.lbStyle = BS_SOLID;
563 (*sf)->brush.lb.lbColor = col;
564 (*sf)->brush.lb.lbHatch = 0;
565
566 (*sf)->brush.gdibrush = CreateSolidBrush(col);
567 (*sf)->brush.bt = BrushTypeSolidColor;
568 (*sf)->color = color;
569 (*sf)->bmp = ARGB2BMP(color);
570
571 return Ok;
572 }
573
574 /******************************************************************************
575 * GdipCreateTexture [GDIPLUS.@]
576 *
577 * PARAMS
578 * image [I] image to use
579 * wrapmode [I] optional
580 * texture [O] pointer to the resulting texturebrush
581 *
582 * RETURNS
583 * SUCCESS: Ok
584 * FAILURE: element of GpStatus
585 */
586 GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
587 GpTexture **texture)
588 {
589 UINT width, height;
590 GpImageAttributes attributes;
591 GpStatus stat;
592
593 TRACE("%p, %d %p\n", image, wrapmode, texture);
594
595 if (!(image && texture))
596 return InvalidParameter;
597
598 stat = GdipGetImageWidth(image, &width);
599 if (stat != Ok) return stat;
600 stat = GdipGetImageHeight(image, &height);
601 if (stat != Ok) return stat;
602 attributes.wrap = wrapmode;
603
604 return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
605 texture);
606 }
607
608 /******************************************************************************
609 * GdipCreateTexture2 [GDIPLUS.@]
610 */
611 GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
612 REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
613 {
614 GpImageAttributes attributes;
615
616 TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
617 x, y, width, height, texture);
618
619 attributes.wrap = wrapmode;
620 return GdipCreateTextureIA(image, &attributes, x, y, width, height,
621 texture);
622 }
623
624 /******************************************************************************
625 * GdipCreateTextureIA [GDIPLUS.@]
626 *
627 * FIXME: imageattr ignored
628 */
629 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
630 GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
631 REAL height, GpTexture **texture)
632 {
633 HDC hdc;
634 HBITMAP hbm, old = NULL;
635 BITMAPINFO *pbmi;
636 BITMAPINFOHEADER *bmih;
637 INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
638 BOOL bm_is_selected;
639 BYTE *dibits, *buff, *textbits;
640 GpStatus status;
641
642 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
643 texture);
644
645 if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
646 return InvalidParameter;
647
648 if(image->type != ImageTypeBitmap){
649 FIXME("not implemented for image type %d\n", image->type);
650 return NotImplemented;
651 }
652
653 n_x = roundr(x);
654 n_y = roundr(y);
655 n_width = roundr(width);
656 n_height = roundr(height);
657
658 if(n_x + n_width > ((GpBitmap*)image)->width ||
659 n_y + n_height > ((GpBitmap*)image)->height)
660 return InvalidParameter;
661
662 IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbm);
663 if(!hbm) return GenericError;
664 IPicture_get_CurDC(image->picture, &hdc);
665 bm_is_selected = (hdc != 0);
666
667 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
668 if (!pbmi)
669 return OutOfMemory;
670 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
671 pbmi->bmiHeader.biBitCount = 0;
672
673 if(!bm_is_selected){
674 hdc = CreateCompatibleDC(0);
675 old = SelectObject(hdc, hbm);
676 }
677
678 /* fill out bmi */
679 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
680
681 bytespp = pbmi->bmiHeader.biBitCount / 8;
682 abs_height = abs(pbmi->bmiHeader.biHeight);
683
684 if(n_x > pbmi->bmiHeader.biWidth || n_x + n_width > pbmi->bmiHeader.biWidth ||
685 n_y > abs_height || n_y + n_height > abs_height){
686 GdipFree(pbmi);
687 return InvalidParameter;
688 }
689
690 dibits = GdipAlloc(pbmi->bmiHeader.biSizeImage);
691
692 if(dibits) /* this is not a good place to error out */
693 GetDIBits(hdc, hbm, 0, abs_height, dibits, pbmi, DIB_RGB_COLORS);
694
695 if(!bm_is_selected){
696 SelectObject(hdc, old);
697 DeleteDC(hdc);
698 }
699
700 if(!dibits){
701 GdipFree(pbmi);
702 return OutOfMemory;
703 }
704
705 image_stride = (pbmi->bmiHeader.biWidth * bytespp + 3) & ~3;
706 stride = (n_width * bytespp + 3) & ~3;
707 buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
708 if(!buff){
709 GdipFree(pbmi);
710 GdipFree(dibits);
711 return OutOfMemory;
712 }
713
714 bmih = (BITMAPINFOHEADER*)buff;
715 textbits = (BYTE*) (bmih + 1);
716 bmih->biSize = sizeof(BITMAPINFOHEADER);
717 bmih->biWidth = n_width;
718 bmih->biHeight = n_height;
719 bmih->biCompression = BI_RGB;
720 bmih->biSizeImage = stride * n_height;
721 bmih->biBitCount = pbmi->bmiHeader.biBitCount;
722 bmih->biClrUsed = 0;
723 bmih->biPlanes = 1;
724
725 /* image is flipped */
726 if(pbmi->bmiHeader.biHeight > 0){
727 dibits += pbmi->bmiHeader.biSizeImage;
728 image_stride *= -1;
729 textbits += stride * (n_height - 1);
730 stride *= -1;
731 }
732
733 GdipFree(pbmi);
734
735 for(i = 0; i < n_height; i++)
736 memcpy(&textbits[i * stride],
737 &dibits[n_x * bytespp + (n_y + i) * image_stride],
738 abs(stride));
739
740 *texture = GdipAlloc(sizeof(GpTexture));
741 if (!*texture){
742 GdipFree(dibits);
743 GdipFree(buff);
744 return OutOfMemory;
745 }
746
747 if((status = GdipCreateMatrix(&(*texture)->transform)) != Ok){
748 GdipFree(*texture);
749 GdipFree(dibits);
750 GdipFree(buff);
751 return status;
752 }
753
754 (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
755 (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
756 (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
757
758 (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
759 (*texture)->brush.bt = BrushTypeTextureFill;
760 (*texture)->wrap = imageattr->wrap;
761
762 GdipFree(dibits);
763 GdipFree(buff);
764
765 return Ok;
766 }
767
768 /******************************************************************************
769 * GdipCreateTextureIAI [GDIPLUS.@]
770 */
771 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
772 INT x, INT y, INT width, INT height, GpTexture **texture)
773 {
774 TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
775 texture);
776
777 return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
778 }
779
780 GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
781 INT x, INT y, INT width, INT height, GpTexture **texture)
782 {
783 GpImageAttributes imageattr;
784
785 TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
786 texture);
787
788 imageattr.wrap = wrapmode;
789
790 return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
791 }
792
793 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
794 {
795 TRACE("(%p, %p)\n", brush, type);
796
797 if(!brush || !type) return InvalidParameter;
798
799 *type = brush->bt;
800
801 return Ok;
802 }
803
804 GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB *backcol)
805 {
806 TRACE("(%p, %p)\n", brush, backcol);
807
808 if(!brush || !backcol) return InvalidParameter;
809
810 *backcol = brush->backcol;
811
812 return Ok;
813 }
814
815 GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB *forecol)
816 {
817 TRACE("(%p, %p)\n", brush, forecol);
818
819 if(!brush || !forecol) return InvalidParameter;
820
821 *forecol = brush->forecol;
822
823 return Ok;
824 }
825
826 GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, HatchStyle *hatchstyle)
827 {
828 TRACE("(%p, %p)\n", brush, hatchstyle);
829
830 if(!brush || !hatchstyle) return InvalidParameter;
831
832 *hatchstyle = brush->hatchstyle;
833
834 return Ok;
835 }
836
837 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
838 {
839 TRACE("(%p)\n", brush);
840
841 if(!brush) return InvalidParameter;
842
843 switch(brush->bt)
844 {
845 case BrushTypePathGradient:
846 GdipFree(((GpPathGradient*) brush)->pathdata.Points);
847 GdipFree(((GpPathGradient*) brush)->pathdata.Types);
848 GdipFree(((GpPathGradient*) brush)->blendfac);
849 GdipFree(((GpPathGradient*) brush)->blendpos);
850 break;
851 case BrushTypeSolidColor:
852 if (((GpSolidFill*)brush)->bmp)
853 DeleteObject(((GpSolidFill*)brush)->bmp);
854 break;
855 case BrushTypeLinearGradient:
856 GdipFree(((GpLineGradient*)brush)->blendfac);
857 GdipFree(((GpLineGradient*)brush)->blendpos);
858 break;
859 case BrushTypeTextureFill:
860 GdipDeleteMatrix(((GpTexture*)brush)->transform);
861 break;
862 default:
863 break;
864 }
865
866 DeleteObject(brush->gdibrush);
867 GdipFree(brush);
868
869 return Ok;
870 }
871
872 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
873 BOOL *usinggamma)
874 {
875 TRACE("(%p, %p)\n", line, usinggamma);
876
877 if(!line || !usinggamma)
878 return InvalidParameter;
879
880 *usinggamma = line->gamma;
881
882 return Ok;
883 }
884
885 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
886 {
887 TRACE("(%p, %p)\n", brush, wrapmode);
888
889 if(!brush || !wrapmode)
890 return InvalidParameter;
891
892 *wrapmode = brush->wrap;
893
894 return Ok;
895 }
896
897 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
898 REAL *positions, INT count)
899 {
900 TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
901
902 if(!brush || !blend || !positions || count <= 0)
903 return InvalidParameter;
904
905 if(count < brush->blendcount)
906 return InsufficientBuffer;
907
908 memcpy(blend, brush->blendfac, count*sizeof(REAL));
909 if(brush->blendcount > 1){
910 memcpy(positions, brush->blendpos, count*sizeof(REAL));
911 }
912
913 return Ok;
914 }
915
916 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
917 {
918 TRACE("(%p, %p)\n", brush, count);
919
920 if(!brush || !count)
921 return InvalidParameter;
922
923 *count = brush->blendcount;
924
925 return Ok;
926 }
927
928 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
929 GpPointF *point)
930 {
931 TRACE("(%p, %p)\n", grad, point);
932
933 if(!grad || !point)
934 return InvalidParameter;
935
936 point->X = grad->center.X;
937 point->Y = grad->center.Y;
938
939 return Ok;
940 }
941
942 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
943 GpPoint *point)
944 {
945 GpStatus ret;
946 GpPointF ptf;
947
948 TRACE("(%p, %p)\n", grad, point);
949
950 if(!point)
951 return InvalidParameter;
952
953 ret = GdipGetPathGradientCenterPoint(grad,&ptf);
954
955 if(ret == Ok){
956 point->X = roundr(ptf.X);
957 point->Y = roundr(ptf.Y);
958 }
959
960 return ret;
961 }
962
963 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
964 REAL *x, REAL *y)
965 {
966 TRACE("(%p, %p, %p)\n", grad, x, y);
967
968 if(!grad || !x || !y)
969 return InvalidParameter;
970
971 *x = grad->focus.X;
972 *y = grad->focus.Y;
973
974 return Ok;
975 }
976
977 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
978 BOOL *gamma)
979 {
980 TRACE("(%p, %p)\n", grad, gamma);
981
982 if(!grad || !gamma)
983 return InvalidParameter;
984
985 *gamma = grad->gamma;
986
987 return Ok;
988 }
989
990 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
991 INT *count)
992 {
993 TRACE("(%p, %p)\n", grad, count);
994
995 if(!grad || !count)
996 return InvalidParameter;
997
998 *count = grad->pathdata.Count;
999
1000 return Ok;
1001 }
1002
1003 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
1004 {
1005 GpRectF r;
1006 GpPath* path;
1007 GpStatus stat;
1008
1009 TRACE("(%p, %p)\n", brush, rect);
1010
1011 if(!brush || !rect)
1012 return InvalidParameter;
1013
1014 stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
1015 brush->pathdata.Count, FillModeAlternate, &path);
1016 if(stat != Ok) return stat;
1017
1018 stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
1019 if(stat != Ok){
1020 GdipDeletePath(path);
1021 return stat;
1022 }
1023
1024 memcpy(rect, &r, sizeof(GpRectF));
1025
1026 GdipDeletePath(path);
1027
1028 return Ok;
1029 }
1030
1031 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
1032 {
1033 GpRectF rectf;
1034 GpStatus stat;
1035
1036 TRACE("(%p, %p)\n", brush, rect);
1037
1038 if(!brush || !rect)
1039 return InvalidParameter;
1040
1041 stat = GdipGetPathGradientRect(brush, &rectf);
1042 if(stat != Ok) return stat;
1043
1044 rect->X = roundr(rectf.X);
1045 rect->Y = roundr(rectf.Y);
1046 rect->Width = roundr(rectf.Width);
1047 rect->Height = roundr(rectf.Height);
1048
1049 return Ok;
1050 }
1051
1052 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
1053 *grad, ARGB *argb, INT *count)
1054 {
1055 static int calls;
1056
1057 if(!grad || !argb || !count || (*count < grad->pathdata.Count))
1058 return InvalidParameter;
1059
1060 if(!(calls++))
1061 FIXME("not implemented\n");
1062
1063 return NotImplemented;
1064 }
1065
1066 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
1067 GpWrapMode *wrapmode)
1068 {
1069 TRACE("(%p, %p)\n", brush, wrapmode);
1070
1071 if(!brush || !wrapmode)
1072 return InvalidParameter;
1073
1074 *wrapmode = brush->wrap;
1075
1076 return Ok;
1077 }
1078
1079 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
1080 {
1081 TRACE("(%p, %p)\n", sf, argb);
1082
1083 if(!sf || !argb)
1084 return InvalidParameter;
1085
1086 *argb = sf->color;
1087
1088 return Ok;
1089 }
1090
1091 /******************************************************************************
1092 * GdipGetTextureTransform [GDIPLUS.@]
1093 */
1094 GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
1095 {
1096 TRACE("(%p, %p)\n", brush, matrix);
1097
1098 if(!brush || !matrix)
1099 return InvalidParameter;
1100
1101 memcpy(matrix, brush->transform, sizeof(GpMatrix));
1102
1103 return Ok;
1104 }
1105
1106 /******************************************************************************
1107 * GdipGetTextureWrapMode [GDIPLUS.@]
1108 */
1109 GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
1110 {
1111 TRACE("(%p, %p)\n", brush, wrapmode);
1112
1113 if(!brush || !wrapmode)
1114 return InvalidParameter;
1115
1116 *wrapmode = brush->wrap;
1117
1118 return Ok;
1119 }
1120
1121 /******************************************************************************
1122 * GdipMultiplyTextureTransform [GDIPLUS.@]
1123 */
1124 GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture* brush,
1125 GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
1126 {
1127 TRACE("(%p, %p, %d)\n", brush, matrix, order);
1128
1129 if(!brush || !matrix)
1130 return InvalidParameter;
1131
1132 return GdipMultiplyMatrix(brush->transform, matrix, order);
1133 }
1134
1135 /******************************************************************************
1136 * GdipResetTextureTransform [GDIPLUS.@]
1137 */
1138 GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush)
1139 {
1140 TRACE("(%p)\n", brush);
1141
1142 if(!brush)
1143 return InvalidParameter;
1144
1145 return GdipSetMatrixElements(brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1146 }
1147
1148 /******************************************************************************
1149 * GdipScaleTextureTransform [GDIPLUS.@]
1150 */
1151 GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture* brush,
1152 REAL sx, REAL sy, GpMatrixOrder order)
1153 {
1154 TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
1155
1156 if(!brush)
1157 return InvalidParameter;
1158
1159 return GdipScaleMatrix(brush->transform, sx, sy, order);
1160 }
1161
1162 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
1163 GDIPCONST REAL *factors, GDIPCONST REAL* positions, INT count)
1164 {
1165 REAL *new_blendfac, *new_blendpos;
1166
1167 TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
1168
1169 if(!brush || !factors || !positions || count <= 0 ||
1170 (count >= 2 && (positions[0] != 0.0f || positions[count-1] != 1.0f)))
1171 return InvalidParameter;
1172
1173 new_blendfac = GdipAlloc(count * sizeof(REAL));
1174 new_blendpos = GdipAlloc(count * sizeof(REAL));
1175
1176 if (!new_blendfac || !new_blendpos)
1177 {
1178 GdipFree(new_blendfac);
1179 GdipFree(new_blendpos);
1180 return OutOfMemory;
1181 }
1182
1183 memcpy(new_blendfac, factors, count * sizeof(REAL));
1184 memcpy(new_blendpos, positions, count * sizeof(REAL));
1185
1186 GdipFree(brush->blendfac);
1187 GdipFree(brush->blendpos);
1188
1189 brush->blendcount = count;
1190 brush->blendfac = new_blendfac;
1191 brush->blendpos = new_blendpos;
1192
1193 return Ok;
1194 }
1195
1196 GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient *brush, REAL *factors,
1197 REAL *positions, INT count)
1198 {
1199 TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
1200
1201 if (!brush || !factors || !positions || count <= 0)
1202 return InvalidParameter;
1203
1204 if (count < brush->blendcount)
1205 return InsufficientBuffer;
1206
1207 memcpy(factors, brush->blendfac, brush->blendcount * sizeof(REAL));
1208 memcpy(positions, brush->blendpos, brush->blendcount * sizeof(REAL));
1209
1210 return Ok;
1211 }
1212
1213 GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient *brush, INT *count)
1214 {
1215 TRACE("(%p, %p)\n", brush, count);
1216
1217 if (!brush || !count)
1218 return InvalidParameter;
1219
1220 *count = brush->blendcount;
1221
1222 return Ok;
1223 }
1224
1225 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
1226 BOOL usegamma)
1227 {
1228 TRACE("(%p, %d)\n", line, usegamma);
1229
1230 if(!line)
1231 return InvalidParameter;
1232
1233 line->gamma = usegamma;
1234
1235 return Ok;
1236 }
1237
1238 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
1239 REAL scale)
1240 {
1241 REAL factors[33];
1242 REAL positions[33];
1243 int num_points = 0;
1244 int i;
1245 const int precision = 16;
1246 REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
1247 REAL min_erf;
1248 REAL scale_erf;
1249
1250 TRACE("(%p, %0.2f, %0.2f)\n", line, focus, scale);
1251
1252 if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1253 return InvalidParameter;
1254
1255 /* we want 2 standard deviations */
1256 erf_range = 2.0 / sqrt(2);
1257
1258 /* calculate the constants we need to normalize the error function to be
1259 between 0.0 and scale over the range we need */
1260 min_erf = erf(-erf_range);
1261 scale_erf = scale / (-2.0 * min_erf);
1262
1263 if (focus != 0.0)
1264 {
1265 positions[0] = 0.0;
1266 factors[0] = 0.0;
1267 for (i=1; i<precision; i++)
1268 {
1269 positions[i] = focus * i / precision;
1270 factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
1271 }
1272 num_points += precision;
1273 }
1274
1275 positions[num_points] = focus;
1276 factors[num_points] = scale;
1277 num_points += 1;
1278
1279 if (focus != 1.0)
1280 {
1281 for (i=1; i<precision; i++)
1282 {
1283 positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
1284 factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
1285 }
1286 num_points += precision;
1287 positions[num_points-1] = 1.0;
1288 factors[num_points-1] = 0.0;
1289 }
1290
1291 return GdipSetLineBlend(line, factors, positions, num_points);
1292 }
1293
1294 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
1295 GpWrapMode wrap)
1296 {
1297 TRACE("(%p, %d)\n", line, wrap);
1298
1299 if(!line || wrap == WrapModeClamp)
1300 return InvalidParameter;
1301
1302 line->wrap = wrap;
1303
1304 return Ok;
1305 }
1306
1307 GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend,
1308 GDIPCONST REAL *pos, INT count)
1309 {
1310 static int calls;
1311
1312 if(!(calls++))
1313 FIXME("not implemented\n");
1314
1315 return NotImplemented;
1316 }
1317
1318 GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush,
1319 GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
1320 {
1321 FIXME("(%p,%p,%p,%i): stub\n", brush, blend, pos, count);
1322 return NotImplemented;
1323 }
1324
1325 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
1326 ARGB argb)
1327 {
1328 TRACE("(%p, %x)\n", grad, argb);
1329
1330 if(!grad)
1331 return InvalidParameter;
1332
1333 grad->centercolor = argb;
1334 grad->brush.lb.lbColor = ARGB2COLORREF(argb);
1335
1336 DeleteObject(grad->brush.gdibrush);
1337 grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
1338
1339 return Ok;
1340 }
1341
1342 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
1343 GpPointF *point)
1344 {
1345 TRACE("(%p, %p)\n", grad, point);
1346
1347 if(!grad || !point)
1348 return InvalidParameter;
1349
1350 grad->center.X = point->X;
1351 grad->center.Y = point->Y;
1352
1353 return Ok;
1354 }
1355
1356 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
1357 GpPoint *point)
1358 {
1359 GpPointF ptf;
1360
1361 TRACE("(%p, %p)\n", grad, point);
1362
1363 if(!point)
1364 return InvalidParameter;
1365
1366 ptf.X = (REAL)point->X;
1367 ptf.Y = (REAL)point->Y;
1368
1369 return GdipSetPathGradientCenterPoint(grad,&ptf);
1370 }
1371
1372 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
1373 REAL x, REAL y)
1374 {
1375 TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
1376
1377 if(!grad)
1378 return InvalidParameter;
1379
1380 grad->focus.X = x;
1381 grad->focus.Y = y;
1382
1383 return Ok;
1384 }
1385
1386 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
1387 BOOL gamma)
1388 {
1389 TRACE("(%p, %d)\n", grad, gamma);
1390
1391 if(!grad)
1392 return InvalidParameter;
1393
1394 grad->gamma = gamma;
1395
1396 return Ok;
1397 }
1398
1399 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
1400 REAL focus, REAL scale)
1401 {
1402 static int calls;
1403
1404 if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1405 return InvalidParameter;
1406
1407 if(!(calls++))
1408 FIXME("not implemented\n");
1409
1410 return NotImplemented;
1411 }
1412
1413 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
1414 *grad, ARGB *argb, INT *count)
1415 {
1416 static int calls;
1417
1418 if(!grad || !argb || !count || (*count <= 0) ||
1419 (*count > grad->pathdata.Count))
1420 return InvalidParameter;
1421
1422 if(!(calls++))
1423 FIXME("not implemented\n");
1424
1425 return NotImplemented;
1426 }
1427
1428 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
1429 GpWrapMode wrap)
1430 {
1431 TRACE("(%p, %d)\n", grad, wrap);
1432
1433 if(!grad)
1434 return InvalidParameter;
1435
1436 grad->wrap = wrap;
1437
1438 return Ok;
1439 }
1440
1441 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
1442 {
1443 TRACE("(%p, %x)\n", sf, argb);
1444
1445 if(!sf)
1446 return InvalidParameter;
1447
1448 sf->color = argb;
1449 sf->brush.lb.lbColor = ARGB2COLORREF(argb);
1450
1451 DeleteObject(sf->brush.gdibrush);
1452 sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
1453
1454 return Ok;
1455 }
1456
1457 /******************************************************************************
1458 * GdipSetTextureTransform [GDIPLUS.@]
1459 */
1460 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
1461 GDIPCONST GpMatrix *matrix)
1462 {
1463 TRACE("(%p, %p)\n", texture, matrix);
1464
1465 if(!texture || !matrix)
1466 return InvalidParameter;
1467
1468 memcpy(texture->transform, matrix, sizeof(GpMatrix));
1469
1470 return Ok;
1471 }
1472
1473 /******************************************************************************
1474 * GdipSetTextureWrapMode [GDIPLUS.@]
1475 *
1476 * WrapMode not used, only stored
1477 */
1478 GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
1479 {
1480 TRACE("(%p, %d)\n", brush, wrapmode);
1481
1482 if(!brush)
1483 return InvalidParameter;
1484
1485 brush->wrap = wrapmode;
1486
1487 return Ok;
1488 }
1489
1490 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
1491 ARGB color2)
1492 {
1493 TRACE("(%p, %x, %x)\n", brush, color1, color2);
1494
1495 if(!brush)
1496 return InvalidParameter;
1497
1498 brush->startcolor = color1;
1499 brush->endcolor = color2;
1500
1501 return Ok;
1502 }
1503
1504 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
1505 {
1506 TRACE("(%p, %p)\n", brush, colors);
1507
1508 if(!brush || !colors)
1509 return InvalidParameter;
1510
1511 colors[0] = brush->startcolor;
1512 colors[1] = brush->endcolor;
1513
1514 return Ok;
1515 }
1516
1517 /******************************************************************************
1518 * GdipRotateTextureTransform [GDIPLUS.@]
1519 */
1520 GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle,
1521 GpMatrixOrder order)
1522 {
1523 TRACE("(%p, %.2f, %d)\n", brush, angle, order);
1524
1525 if(!brush)
1526 return InvalidParameter;
1527
1528 return GdipRotateMatrix(brush->transform, angle, order);
1529 }
1530
1531 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
1532 REAL scale)
1533 {
1534 static int calls;
1535
1536 if(!(calls++))
1537 FIXME("not implemented\n");
1538
1539 return NotImplemented;
1540 }
1541
1542 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
1543 GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
1544 {
1545 static int calls;
1546
1547 if(!(calls++))
1548 FIXME("not implemented\n");
1549
1550 return NotImplemented;
1551 }
1552
1553 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
1554 GDIPCONST GpMatrix *matrix)
1555 {
1556 static int calls;
1557
1558 if(!(calls++))
1559 FIXME("not implemented\n");
1560
1561 return NotImplemented;
1562 }
1563
1564 GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
1565 REAL dx, REAL dy, GpMatrixOrder order)
1566 {
1567 FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
1568
1569 return NotImplemented;
1570 }
1571
1572 /******************************************************************************
1573 * GdipTranslateTextureTransform [GDIPLUS.@]
1574 */
1575 GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy,
1576 GpMatrixOrder order)
1577 {
1578 TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
1579
1580 if(!brush)
1581 return InvalidParameter;
1582
1583 return GdipTranslateMatrix(brush->transform, dx, dy, order);
1584 }
1585
1586 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
1587 {
1588 TRACE("(%p, %p)\n", brush, rect);
1589
1590 if(!brush || !rect)
1591 return InvalidParameter;
1592
1593 *rect = brush->rect;
1594
1595 return Ok;
1596 }
1597
1598 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
1599 {
1600 GpRectF rectF;
1601 GpStatus ret;
1602
1603 TRACE("(%p, %p)\n", brush, rect);
1604
1605 if(!rect)
1606 return InvalidParameter;
1607
1608 ret = GdipGetLineRect(brush, &rectF);
1609
1610 if(ret == Ok){
1611 rect->X = roundr(rectF.X);
1612 rect->Y = roundr(rectF.Y);
1613 rect->Width = roundr(rectF.Width);
1614 rect->Height = roundr(rectF.Height);
1615 }
1616
1617 return ret;
1618 }
1619
1620 GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient* brush,
1621 REAL angle, GpMatrixOrder order)
1622 {
1623 static int calls;
1624
1625 if(!brush)
1626 return InvalidParameter;
1627
1628 if(!(calls++))
1629 FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
1630
1631 return NotImplemented;
1632 }
1633
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.