ReactOS 0.4.16-dev-340-g0540c21
Macros | Functions
pen.c File Reference
#include <math.h>
#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"
Include dependency graph for pen.c:

Go to the source code of this file.

Macros

#define expect(expected, got)   ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
 
#define expectf(expected, got)   ok(fabs(got - expected) < 0.1, "Expected %.2f, got %.2f\n", expected, got)
 

Functions

static void test_startup (void)
 
static void test_constructor_destructor (void)
 
static void test_constructor_destructor2 (void)
 
static void test_brushfill (void)
 
static void test_dasharray (void)
 
static void test_customcap (void)
 
static void test_penfilltype (void)
 
static void test_compoundarray (void)
 
static void get_pen_transform (GpPen *pen, REAL *values)
 
static void test_transform (void)
 
 START_TEST (pen)
 

Macro Definition Documentation

◆ expect

#define expect (   expected,
  got 
)    ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)

Definition at line 27 of file pen.c.

◆ expectf

#define expectf (   expected,
  got 
)    ok(fabs(got - expected) < 0.1, "Expected %.2f, got %.2f\n", expected, got)

Definition at line 28 of file pen.c.

Function Documentation

◆ get_pen_transform()

static void get_pen_transform ( GpPen *  pen,
REAL *  values 
)
static

Definition at line 392 of file pen.c.

393{
394 GpMatrix *matrix;
395 GpStatus status;
396
397 status = GdipCreateMatrix(&matrix);
398 expect(Ok, status);
399
400 status = GdipGetPenTransform(pen, matrix);
401 expect(Ok, status);
402 status = GdipGetMatrixElements(matrix, values);
403 expect(Ok, status);
404
405 GdipDeleteMatrix(matrix);
406}
GdipGetMatrixElements
GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix, REAL *out)
Definition: matrix.c:172
GdipDeleteMatrix
GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
Definition: matrix.c:160
GdipCreateMatrix
GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
Definition: matrix.c:140
GdipGetPenTransform
GpStatus WINGDIPAPI GdipGetPenTransform(GpPen *pen, GpMatrix *matrix)
Definition: pen.c:449
Status
Status
Definition: gdiplustypes.h:25
Ok
@ Ok
Definition: gdiplustypes.h:26
matrix
GLuint GLenum matrix
Definition: glext.h:9407
values
GLboolean GLenum GLenum GLvoid * values
Definition: glext.h:5666
expect
#define expect(expected, got)
Definition: pen.c:30
status
Definition: ps.c:97

Referenced by test_transform().

◆ START_TEST()

START_TEST ( pen  )

Definition at line 634 of file pen.c.

635{
636 struct GdiplusStartupInput gdiplusStartupInput;
637 ULONG_PTR gdiplusToken;
638 HMODULE hmsvcrt;
639 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
640
641 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
642 hmsvcrt = LoadLibraryA("msvcrt");
643 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
644 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
645
646 test_startup();
647
648 gdiplusStartupInput.GdiplusVersion = 1;
649 gdiplusStartupInput.DebugEventCallback = NULL;
650 gdiplusStartupInput.SuppressBackgroundThread = 0;
651 gdiplusStartupInput.SuppressExternalCodecs = 0;
652
653 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
654
655 test_constructor_destructor();
656 test_constructor_destructor2();
657 test_brushfill();
658 test_dasharray();
659 test_customcap();
660 test_penfilltype();
661 test_compoundarray();
662 test_transform();
663
664 GdiplusShutdown(gdiplusToken);
665}
_controlfp_s
int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
Definition: _controlfp_s.c:19
NULL
#define NULL
Definition: types.h:112
CDECL
#define CDECL
Definition: compat.h:29
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
cur
FxCollectionEntry * cur
Definition: fxresourceapi.cpp:412
GdiplusStartup
Status WINAPI GdiplusStartup(ULONG_PTR *token, const struct GdiplusStartupInput *input, struct GdiplusStartupOutput *output)
Definition: gdiplus.c:81
GdiplusShutdown
void WINAPI GdiplusShutdown(ULONG_PTR)
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
test_startup
static void test_startup(void)
Definition: pen.c:30
test_brushfill
static void test_brushfill(void)
Definition: pen.c:119
test_customcap
static void test_customcap(void)
Definition: pen.c:243
test_compoundarray
static void test_compoundarray(void)
Definition: pen.c:342
test_penfilltype
static void test_penfilltype(void)
Definition: pen.c:292
test_constructor_destructor2
static void test_constructor_destructor2(void)
Definition: pen.c:87
test_dasharray
static void test_dasharray(void)
Definition: pen.c:163
test_constructor_destructor
static void test_constructor_destructor(void)
Definition: pen.c:67
test_transform
static void test_transform(void)
Definition: pen.c:408
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ test_brushfill()

static void test_brushfill ( void  )
static

Definition at line 119 of file pen.c.

120{
121 GpStatus status;
122 GpPen *pen;
123 GpBrush *brush, *brush2;
124 GpBrushType type;
125 ARGB color = 0;
126
127 /* default solid */
128 GdipCreatePen1(0xdeadbeef, 4.5, UnitWorld, &pen);
129 status = GdipGetPenBrushFill(pen, &brush);
130 expect(Ok, status);
131 GdipGetBrushType(brush, &type);
132 expect(BrushTypeSolidColor, type);
133 GdipGetPenColor(pen, &color);
134 expect(0xdeadbeef, color);
135 GdipDeleteBrush(brush);
136
137 /* color controlled by brush */
138 GdipCreateSolidFill(0xabaddeed, (GpSolidFill**)&brush);
139 status = GdipSetPenBrushFill(pen, brush);
140 expect(Ok, status);
141 GdipGetPenColor(pen, &color);
142 expect(0xabaddeed, color);
143 GdipDeleteBrush(brush);
144 color = 0;
145
146 /* get returns a clone, not a reference */
147 GdipGetPenBrushFill(pen, &brush);
148 GdipSetSolidFillColor((GpSolidFill*)brush, 0xbeadfeed);
149 GdipGetPenBrushFill(pen, &brush2);
150 ok(brush != brush2, "Expected to get a clone, not a copy of the reference\n");
151 GdipGetSolidFillColor((GpSolidFill*)brush2, &color);
152 expect(0xabaddeed, color);
153 GdipDeleteBrush(brush);
154 GdipDeleteBrush(brush2);
155
156 /* brush cannot be NULL */
157 status = GdipSetPenBrushFill(pen, NULL);
158 expect(InvalidParameter, status);
159
160 GdipDeletePen(pen);
161}
ok
#define ok(value,...)
Definition: atltest.h:57
GdipDeleteBrush
GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
Definition: brush.c:994
GdipSetSolidFillColor
GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
Definition: brush.c:1925
GdipCreateSolidFill
GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
Definition: brush.c:757
GdipGetSolidFillColor
GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
Definition: brush.c:1273
GdipGetBrushType
GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
Definition: brush.c:950
GdipCreatePen1
GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, REAL width, GpUnit unit, GpPen **pen)
Definition: pen.c:136
GdipGetPenColor
GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb)
Definition: pen.c:217
GdipSetPenBrushFill
GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush)
Definition: pen.c:502
GdipDeletePen
GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen)
Definition: pen.c:192
GdipGetPenBrushFill
GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush)
Definition: pen.c:207
UnitWorld
@ UnitWorld
Definition: gdiplusenums.h:27
BrushType
BrushType
Definition: gdiplusenums.h:37
BrushTypeSolidColor
@ BrushTypeSolidColor
Definition: gdiplusenums.h:38
ARGB
DWORD ARGB
Definition: gdipluspixelformats.h:22
InvalidParameter
@ InvalidParameter
Definition: gdiplustypes.h:28
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
color
GLuint color
Definition: glext.h:6243

Referenced by START_TEST().

◆ test_compoundarray()

static void test_compoundarray ( void  )
static

Definition at line 342 of file pen.c.

343{
344 GpStatus status;
345 GpPen *pen;
346 static const REAL testvalues[] = {0.2, 0.4, 0.6, 0.8};
347 INT count;
348
349 status = GdipSetPenCompoundArray(NULL, testvalues, 4);
350 expect(InvalidParameter, status);
351
352 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
353 expect(Ok, status);
354
355 status = GdipGetPenCompoundCount(NULL, NULL);
356 expect(InvalidParameter, status);
357
358 status = GdipGetPenCompoundCount(pen, NULL);
359 expect(InvalidParameter, status);
360
361 count = 10;
362 status = GdipGetPenCompoundCount(pen, &count);
363todo_wine {
364 expect(Ok, status);
365 ok(count == 0, "Unexpected compound count %d\n", count);
366}
367 status = GdipSetPenCompoundArray(pen, NULL, 0);
368 expect(InvalidParameter, status);
369 status = GdipSetPenCompoundArray(pen, NULL, 4);
370 expect(InvalidParameter, status);
371 status = GdipSetPenCompoundArray(pen, testvalues, 3);
372 expect(InvalidParameter, status);
373 status = GdipSetPenCompoundArray(pen, testvalues, 0);
374 expect(InvalidParameter, status);
375 status = GdipSetPenCompoundArray(pen, testvalues, -2);
376 expect(InvalidParameter, status);
377
378 status = GdipSetPenCompoundArray(pen, testvalues, 4);
379 todo_wine expect(Ok, status);
380 status = GdipSetPenCompoundArray(pen, NULL, 0);
381 expect(InvalidParameter, status);
382
383 count = 0;
384 status = GdipGetPenCompoundCount(pen, &count);
385todo_wine {
386 expect(Ok, status);
387 ok(count == 4, "Unexpected compound count %d\n", count);
388}
389 GdipDeletePen(pen);
390}
REAL
float REAL
Definition: types.h:41
GdipGetPenCompoundCount
GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen *pen, INT *count)
Definition: pen.c:526
GdipSetPenCompoundArray
GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *dash, INT count)
Definition: pen.c:536
UnitPixel
@ UnitPixel
Definition: gdiplusenums.h:29
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
todo_wine
#define todo_wine
Definition: custom.c:89
INT
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ test_constructor_destructor()

static void test_constructor_destructor ( void  )
static

Definition at line 67 of file pen.c.

68{
69 GpStatus status;
70 GpPen *pen = NULL;
71
72 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, NULL);
73 expect(InvalidParameter, status);
74 ok(pen == NULL, "Expected pen to be NULL\n");
75
76 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
77 expect(Ok, status);
78 ok(pen != NULL, "Expected pen to be initialized\n");
79
80 status = GdipDeletePen(NULL);
81 expect(InvalidParameter, status);
82
83 status = GdipDeletePen(pen);
84 expect(Ok, status);
85}

Referenced by START_TEST().

◆ test_constructor_destructor2()

static void test_constructor_destructor2 ( void  )
static

Definition at line 87 of file pen.c.

88{
89 GpStatus status;
90 GpPen *pen = NULL;
91 GpBrush *brush = NULL;
92 GpPointF points[2];
93
94 status = GdipCreatePen2(NULL, 10.0f, UnitPixel, &pen);
95 expect(InvalidParameter, status);
96 ok(pen == NULL, "Expected pen to be NULL\n");
97
98 points[0].X = 7.0;
99 points[0].Y = 11.0;
100 points[1].X = 13.0;
101 points[1].Y = 17.0;
102
103 status = GdipCreateLineBrush(&points[0], &points[1], (ARGB)0xffff00ff,
104 (ARGB)0xff0000ff, WrapModeTile, (GpLineGradient **)&brush);
105 expect(Ok, status);
106 ok(brush != NULL, "Expected brush to be initialized\n");
107
108 status = GdipCreatePen2(brush, 10.0f, UnitPixel, &pen);
109 expect(Ok, status);
110 ok(pen != NULL, "Expected pen to be initialized\n");
111
112 status = GdipDeletePen(pen);
113 expect(Ok, status);
114
115 status = GdipDeleteBrush(brush);
116 expect(Ok, status);
117}
GdipCreateLineBrush
GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF *startpoint, GDIPCONST GpPointF *endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
Definition: brush.c:372
GdipCreatePen2
GpStatus WINGDIPAPI GdipCreatePen2(GpBrush *brush, REAL width, GpUnit unit, GpPen **pen)
Definition: pen.c:150
WrapModeTile
@ WrapModeTile
Definition: gdiplusenums.h:207
points
GLsizei const GLfloat * points
Definition: glext.h:8112

Referenced by START_TEST().

◆ test_customcap()

static void test_customcap ( void  )
static

Definition at line 243 of file pen.c.

244{
245 GpPen *pen;
246 GpStatus status;
247 GpCustomLineCap *custom;
248
249 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
250 expect(Ok, status);
251
252 /* NULL args */
253 status = GdipGetPenCustomStartCap(NULL, NULL);
254 expect(InvalidParameter, status);
255 status = GdipGetPenCustomStartCap(pen, NULL);
256 expect(InvalidParameter, status);
257 status = GdipGetPenCustomStartCap(NULL, &custom);
258 expect(InvalidParameter, status);
259
260 status = GdipGetPenCustomEndCap(NULL, NULL);
261 expect(InvalidParameter, status);
262 status = GdipGetPenCustomEndCap(pen, NULL);
263 expect(InvalidParameter, status);
264 status = GdipGetPenCustomEndCap(NULL, &custom);
265 expect(InvalidParameter, status);
266
267 /* native crashes on pen == NULL, custom != NULL */
268 status = GdipSetPenCustomStartCap(NULL, NULL);
269 expect(InvalidParameter, status);
270 status = GdipSetPenCustomStartCap(pen, NULL);
271 expect(InvalidParameter, status);
272
273 status = GdipSetPenCustomEndCap(NULL, NULL);
274 expect(InvalidParameter, status);
275 status = GdipSetPenCustomEndCap(pen, NULL);
276 expect(InvalidParameter, status);
277
278 /* get without setting previously */
279 custom = (GpCustomLineCap*)0xdeadbeef;
280 status = GdipGetPenCustomEndCap(pen, &custom);
281 expect(Ok, status);
282 ok(custom == NULL,"Expect CustomCap == NULL\n");
283
284 custom = (GpCustomLineCap*)0xdeadbeef;
285 status = GdipGetPenCustomStartCap(pen, &custom);
286 expect(Ok, status);
287 ok(custom == NULL,"Expect CustomCap == NULL\n");
288
289 GdipDeletePen(pen);
290}
GdipGetPenCustomEndCap
GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen *pen, GpCustomLineCap **customCap)
Definition: pen.c:230
GdipGetPenCustomStartCap
GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen *pen, GpCustomLineCap **customCap)
Definition: pen.c:245
GdipSetPenCustomEndCap
GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap *customCap)
Definition: pen.c:547
GdipSetPenCustomStartCap
GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap *customCap)
Definition: pen.c:566

Referenced by START_TEST().

◆ test_dasharray()

static void test_dasharray ( void  )
static

Definition at line 163 of file pen.c.

164{
165 GpPen *pen;
166 GpDashStyle style;
167 GpStatus status;
168 REAL dashes[12];
169
170 GdipCreatePen1(0xdeadbeef, 10.0, UnitWorld, &pen);
171 dashes[0] = 10.0;
172 dashes[1] = 11.0;
173 dashes[2] = 12.0;
174 dashes[3] = 13.0;
175 dashes[4] = 14.0;
176 dashes[5] = -100.0;
177 dashes[6] = -100.0;
178 dashes[7] = dashes[8] = dashes[9] = dashes[10] = dashes[11] = 0.0;
179
180 /* setting the array sets the type to custom */
181 GdipGetPenDashStyle(pen, &style);
182 expect(DashStyleSolid, style);
183 status = GdipSetPenDashArray(pen, dashes, 2);
184 expect(Ok, status);
185 GdipGetPenDashStyle(pen, &style);
186 expect(DashStyleCustom, style);
187
188 /* Getting the array on a non-custom pen returns invalid parameter (unless
189 * you are getting 0 elements).*/
190 GdipSetPenDashStyle(pen, DashStyleSolid);
191 status = GdipGetPenDashArray(pen, &dashes[5], 2);
192 expect(InvalidParameter, status);
193 status = GdipGetPenDashArray(pen, &dashes[5], 0);
194 expect(Ok, status);
195
196 /* What does setting DashStyleCustom do to the array length? */
197 GdipSetPenDashArray(pen, dashes, 2);
198 GdipSetPenDashStyle(pen, DashStyleCustom);
199 status = GdipGetPenDashArray(pen, &dashes[5], 2);
200 expect(Ok, status);
201 expectf(10.0, dashes[5]);
202 expectf(11.0, dashes[6]);
203
204 /* Set the array, then get with different sized buffers. */
205 status = GdipSetPenDashArray(pen, dashes, 5);
206 expect(Ok, status);
207 dashes[5] = -100.0;
208 dashes[6] = -100.0;
209 status = GdipGetPenDashArray(pen, &dashes[5], 1);
210 expect(Ok, status); /* not InsufficientBuffer! */
211 expectf(10.0, dashes[5]);
212 expectf(-100.0, dashes[6]);
213 dashes[5] = -100.0;
214 status = GdipGetPenDashArray(pen, &dashes[5], 6);
215 expect(InvalidParameter, status); /* not Ok! */
216 expectf(-100.0, dashes[5]);
217 expectf(-100.0, dashes[6]);
218
219 /* Some invalid array values. */
220 status = GdipSetPenDashArray(pen, &dashes[7], 5);
221 expect(InvalidParameter, status);
222 dashes[9] = -1.0;
223 status = GdipSetPenDashArray(pen, &dashes[7], 5);
224 expect(InvalidParameter, status);
225
226 /* Try to set with count = 0. */
227 GdipSetPenDashStyle(pen, DashStyleDot);
228 if (0) /* corrupts stack on 64-bit Vista */
229 {
230 status = GdipSetPenDashArray(pen, dashes, 0);
231 ok(status == OutOfMemory || status == InvalidParameter,
232 "Expected OutOfMemory or InvalidParameter, got %.8x\n", status);
233 }
234 status = GdipSetPenDashArray(pen, dashes, -1);
235 ok(status == OutOfMemory || status == InvalidParameter,
236 "Expected OutOfMemory or InvalidParameter, got %.8x\n", status);
237 GdipGetPenDashStyle(pen, &style);
238 expect(DashStyleDot, style);
239
240 GdipDeletePen(pen);
241}
style
Arabic default style
Definition: afstyles.h:94
GdipSetPenDashArray
GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash, INT count)
Definition: pen.c:585
GdipSetPenDashStyle
GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen *pen, GpDashStyle dash)
Definition: pen.c:650
GdipGetPenDashArray
GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count)
Definition: pen.c:260
GdipGetPenDashStyle
GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dash)
Definition: pen.c:312
DashStyle
DashStyle
Definition: gdiplusenums.h:177
DashStyleSolid
@ DashStyleSolid
Definition: gdiplusenums.h:178
DashStyleDot
@ DashStyleDot
Definition: gdiplusenums.h:180
DashStyleCustom
@ DashStyleCustom
Definition: gdiplusenums.h:183
OutOfMemory
@ OutOfMemory
Definition: gdiplustypes.h:29
expectf
#define expectf(expected, got)
Definition: pen.c:28

Referenced by START_TEST().

◆ test_penfilltype()

static void test_penfilltype ( void  )
static

Definition at line 292 of file pen.c.

293{
294 GpPen *pen;
295 GpSolidFill *solid;
296 GpLineGradient *line;
297 GpPointF a, b;
298 GpStatus status;
299 GpPenType type;
300
301 /* NULL */
302 status = GdipGetPenFillType(NULL, NULL);
303 expect(InvalidParameter, status);
304
305 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
306 expect(Ok, status);
307 status = GdipGetPenFillType(pen, NULL);
308 expect(InvalidParameter, status);
309
310 /* created with GdipCreatePen1() */
311 status = GdipGetPenFillType(pen, &type);
312 expect(Ok, status);
313 expect(PenTypeSolidColor, type);
314 GdipDeletePen(pen);
315
316 /* based on SolidBrush */
317 status = GdipCreateSolidFill((ARGB)0xffff00ff, &solid);
318 expect(Ok, status);
319 status = GdipCreatePen2((GpBrush*)solid, 10.0f, UnitPixel, &pen);
320 expect(Ok, status);
321 status = GdipGetPenFillType(pen, &type);
322 expect(Ok, status);
323 expect(PenTypeSolidColor, type);
324 GdipDeletePen(pen);
325 GdipDeleteBrush((GpBrush*)solid);
326
327 /* based on LinearGradientBrush */
328 a.X = a.Y = 0.0;
329 b.X = b.Y = 10.0;
330 status = GdipCreateLineBrush(&a, &b, (ARGB)0xffff00ff, (ARGB)0xffff0000,
331 WrapModeTile, &line);
332 expect(Ok, status);
333 status = GdipCreatePen2((GpBrush*)line, 10.0f, UnitPixel, &pen);
334 expect(Ok, status);
335 status = GdipGetPenFillType(pen, &type);
336 expect(Ok, status);
337 expect(PenTypeLinearGradient, type);
338 GdipDeletePen(pen);
339 GdipDeleteBrush((GpBrush*)line);
340}
GdipGetPenFillType
GpStatus WINGDIPAPI GdipGetPenFillType(GpPen *pen, GpPenType *type)
Definition: pen.c:336
PenType
PenType
Definition: gdiplusenums.h:95
PenTypeSolidColor
@ PenTypeSolidColor
Definition: gdiplusenums.h:96
PenTypeLinearGradient
@ PenTypeLinearGradient
Definition: gdiplusenums.h:100
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
a
#define a
Definition: ke_i.h:78
b
#define b
Definition: ke_i.h:79
line
Definition: parser.c:49

Referenced by START_TEST().

◆ test_startup()

static void test_startup ( void  )
static

Definition at line 30 of file pen.c.

31{
32 GpPen *pen = NULL;
33 Status status;
34 struct GdiplusStartupInput gdiplusStartupInput;
35 ULONG_PTR gdiplusToken;
36 int gpversion;
37
38 gdiplusStartupInput.DebugEventCallback = NULL;
39 gdiplusStartupInput.SuppressBackgroundThread = 0;
40 gdiplusStartupInput.SuppressExternalCodecs = 0;
41
42 for (gpversion=1; gpversion<256; gpversion++)
43 {
44 gdiplusStartupInput.GdiplusVersion = gpversion;
45 status = GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
46 ok(status == Ok || status == UnsupportedGdiplusVersion,
47 "GdiplusStartup returned %x\n", status);
48 GdiplusShutdown(gdiplusToken);
49 if (status != Ok)
50 {
51 gpversion--;
52 break;
53 }
54 }
55
56 ok(gpversion > 0 && gpversion <= 2, "unexpected gdiplus version %i\n", gpversion);
57 trace("gdiplus version is %i\n", gpversion);
58
59 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
60
61 todo_wine
62 expect(GdiplusNotInitialized, status);
63
64 GdipDeletePen(pen);
65}
trace
#define trace
Definition: atltest.h:70
GdiplusNotInitialized
@ GdiplusNotInitialized
Definition: gdiplustypes.h:44
UnsupportedGdiplusVersion
@ UnsupportedGdiplusVersion
Definition: gdiplustypes.h:43
GdiplusStartupInput::DebugEventCallback
DebugEventProc DebugEventCallback
Definition: gdiplusinit.h:35

Referenced by START_TEST().

◆ test_transform()

static void test_transform ( void  )
static

Definition at line 408 of file pen.c.

409{
410 GpStatus status;
411 GpPen *pen;
412 GpMatrix *matrix, *matrix2;
413 REAL values[6];
414
415 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
416 expect(Ok, status);
417
418 status = GdipCreateMatrix(&matrix);
419 expect(Ok, status);
420
421 status = GdipGetPenTransform(pen, matrix);
422 expect(Ok, status);
423
424 status = GdipGetMatrixElements(matrix, values);
425 expect(Ok, status);
426
427 expectf(1.0, values[0]);
428 expectf(0.0, values[1]);
429 expectf(0.0, values[2]);
430 expectf(1.0, values[3]);
431 expectf(0.0, values[4]);
432 expectf(0.0, values[5]);
433
434 GdipCreateMatrix2(3.0, -2.0, 5.0, 2.0, 6.0, 3.0, &matrix2);
435 status = GdipSetPenTransform(pen, matrix2);
436 expect(Ok, status);
437 GdipDeleteMatrix(matrix2);
438
439 status = GdipGetPenTransform(pen, matrix);
440 expect(Ok, status);
441 status = GdipGetMatrixElements(matrix, values);
442 expect(Ok, status);
443 expectf(3.0, values[0]);
444 expectf(-2.0, values[1]);
445 expectf(5.0, values[2]);
446 expectf(2.0, values[3]);
447 expectf(6.0, values[4]);
448 expectf(3.0, values[5]);
449
450 /* Translate */
451 status = GdipTranslatePenTransform(NULL, 1.0, -2.0, MatrixOrderAppend);
452 expect(InvalidParameter, status);
453
454 status = GdipTranslatePenTransform(pen, 1.0, -2.0, MatrixOrderAppend);
455 expect(Ok, status);
456
457 status = GdipGetPenTransform(pen, matrix);
458 expect(Ok, status);
459 status = GdipGetMatrixElements(matrix, values);
460 expect(Ok, status);
461 expectf(3.0, values[0]);
462 expectf(-2.0, values[1]);
463 expectf(5.0, values[2]);
464 expectf(2.0, values[3]);
465 expectf(7.0, values[4]);
466 expectf(1.0, values[5]);
467
468 status = GdipTranslatePenTransform(pen, -3.0, 5.0, MatrixOrderPrepend);
469 expect(Ok, status);
470
471 status = GdipGetPenTransform(pen, matrix);
472 expect(Ok, status);
473 status = GdipGetMatrixElements(matrix, values);
474 expect(Ok, status);
475 expectf(3.0, values[0]);
476 expectf(-2.0, values[1]);
477 expectf(5.0, values[2]);
478 expectf(2.0, values[3]);
479 expectf(23.0, values[4]);
480 expectf(17.0, values[5]);
481
482 status = GdipResetPenTransform(pen);
483 expect(Ok, status);
484
485 status = GdipGetPenTransform(pen, matrix);
486 expect(Ok, status);
487 status = GdipGetMatrixElements(matrix, values);
488 expect(Ok, status);
489
490 expectf(1.0, values[0]);
491 expectf(0.0, values[1]);
492 expectf(0.0, values[2]);
493 expectf(1.0, values[3]);
494 expectf(0.0, values[4]);
495 expectf(0.0, values[5]);
496
497 /* Scale */
498 status = GdipScalePenTransform(NULL, 1.0, 1.0, MatrixOrderPrepend);
499 expect(InvalidParameter, status);
500
501 status = GdipScalePenTransform(pen, 1.0, 1.0, MatrixOrderPrepend);
502 expect(Ok, status);
503
504 get_pen_transform(pen, values);
505 expectf(1.0, values[0]);
506 expectf(0.0, values[1]);
507 expectf(0.0, values[2]);
508 expectf(1.0, values[3]);
509 expectf(0.0, values[4]);
510 expectf(0.0, values[5]);
511
512 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderPrepend);
513 expect(Ok, status);
514
515 get_pen_transform(pen, values);
516 expectf(2.0, values[0]);
517 expectf(0.0, values[1]);
518 expectf(0.0, values[2]);
519 expectf(-10.0, values[3]);
520 expectf(0.0, values[4]);
521 expectf(0.0, values[5]);
522
523 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
524 expect(Ok, status);
525
526 get_pen_transform(pen, values);
527 expectf(4.0, values[0]);
528 expectf(0.0, values[1]);
529 expectf(0.0, values[2]);
530 expectf(100.0, values[3]);
531 expectf(0.0, values[4]);
532 expectf(0.0, values[5]);
533
534 status = GdipTranslatePenTransform(pen, 1.0, -2.0, MatrixOrderAppend);
535 expect(Ok, status);
536
537 get_pen_transform(pen, values);
538 expectf(4.0, values[0]);
539 expectf(0.0, values[1]);
540 expectf(0.0, values[2]);
541 expectf(100.0, values[3]);
542 expectf(1.0, values[4]);
543 expectf(-2.0, values[5]);
544
545 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderPrepend);
546 expect(Ok, status);
547
548 get_pen_transform(pen, values);
549 expectf(8.0, values[0]);
550 expectf(0.0, values[1]);
551 expectf(0.0, values[2]);
552 expectf(-1000.0, values[3]);
553 expectf(1.0, values[4]);
554 expectf(-2.0, values[5]);
555
556 /* Multiply */
557 status = GdipResetPenTransform(pen);
558 expect(Ok, status);
559
560 status = GdipSetMatrixElements(matrix, 2.0, 1.0, 1.0, 4.0, 1.0, 2.0);
561 expect(Ok, status);
562
563 status = GdipMultiplyPenTransform(NULL, matrix, MatrixOrderPrepend);
564 expect(InvalidParameter, status);
565
566 status = GdipMultiplyPenTransform(pen, matrix, MatrixOrderPrepend);
567 expect(Ok, status);
568
569 get_pen_transform(pen, values);
570 expectf(2.0, values[0]);
571 expectf(1.0, values[1]);
572 expectf(1.0, values[2]);
573 expectf(4.0, values[3]);
574 expectf(1.0, values[4]);
575 expectf(2.0, values[5]);
576
577 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
578 expect(Ok, status);
579
580 status = GdipMultiplyPenTransform(pen, matrix, MatrixOrderAppend);
581 expect(Ok, status);
582
583 get_pen_transform(pen, values);
584 expectf(-2.0, values[0]);
585 expectf(-36.0, values[1]);
586 expectf(-36.0, values[2]);
587 expectf(-158.0, values[3]);
588 expectf(-15.0, values[4]);
589 expectf(-76.0, values[5]);
590
591 /* Rotate */
592 status = GdipResetPenTransform(pen);
593 expect(Ok, status);
594
595 status = GdipSetMatrixElements(matrix, 2.0, 1.0, 1.0, 4.0, 1.0, 2.0);
596 expect(Ok, status);
597
598 status = GdipSetPenTransform(pen, matrix);
599 expect(Ok, status);
600
601 status = GdipRotatePenTransform(NULL, 10.0, MatrixOrderPrepend);
602 expect(InvalidParameter, status);
603
604 status = GdipRotatePenTransform(pen, 45.0, MatrixOrderPrepend);
605 expect(Ok, status);
606
607 get_pen_transform(pen, values);
608 expectf(2.12, values[0]);
609 expectf(3.54, values[1]);
610 expectf(-0.71, values[2]);
611 expectf(2.12, values[3]);
612 expectf(1.0, values[4]);
613 expectf(2.0, values[5]);
614
615 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
616 expect(Ok, status);
617
618 status = GdipRotatePenTransform(pen, 180.0, MatrixOrderAppend);
619 expect(Ok, status);
620
621 get_pen_transform(pen, values);
622 expectf(-4.24, values[0]);
623 expectf(35.36, values[1]);
624 expectf(1.41, values[2]);
625 expectf(21.21, values[3]);
626 expectf(-2.0, values[4]);
627 expectf(20.0, values[5]);
628
629 GdipDeletePen(pen);
630
631 GdipDeleteMatrix(matrix);
632}
GdipCreateMatrix2
GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy, GpMatrix **matrix)
Definition: matrix.c:61
GdipSetMatrixElements
GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
Definition: matrix.c:316
GdipScalePenTransform
GpStatus WINGDIPAPI GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy, GpMatrixOrder order)
Definition: pen.c:471
GdipMultiplyPenTransform
GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen *pen, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
Definition: pen.c:491
GdipResetPenTransform
GpStatus WINGDIPAPI GdipResetPenTransform(GpPen *pen)
Definition: pen.c:420
GdipTranslatePenTransform
GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen *pen, REAL dx, REAL dy, GpMatrixOrder order)
Definition: pen.c:461
GdipSetPenTransform
GpStatus WINGDIPAPI GdipSetPenTransform(GpPen *pen, GpMatrix *matrix)
Definition: pen.c:432
GdipRotatePenTransform
GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen *pen, REAL angle, GpMatrixOrder order)
Definition: pen.c:481
MatrixOrderAppend
@ MatrixOrderAppend
Definition: gdiplusenums.h:189
MatrixOrderPrepend
@ MatrixOrderPrepend
Definition: gdiplusenums.h:188
get_pen_transform
static void get_pen_transform(GpPen *pen, REAL *values)
Definition: pen.c:392

Referenced by START_TEST().