ReactOS 0.4.17-dev-218-g5635d24
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)   expect_(__LINE__, expected, got)
 
#define expectf(expected, got)   ok(fabs(got - expected) < 0.1, "Expected %.2f, got %.2f\n", expected, got)
 

Functions

static void expect_ (unsigned line, DWORD expected, DWORD got)
 
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 
)    expect_(__LINE__, 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 32 of file pen.c.

Function Documentation

◆ expect_()

static void expect_ ( unsigned  line,
DWORD  expected,
DWORD  got 
)
inlinestatic

Definition at line 28 of file pen.c.

29{
30 ok_(__FILE__, line)(expected == got, "Expected %.8ld, got %.8ld\n", expected, got);
31}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
expected
BOOL expected
Definition: store.c:2000
line
Definition: parser.c:49

◆ get_pen_transform()

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

Definition at line 428 of file pen.c.

429{
430 GpMatrix *matrix;
431 GpStatus status;
432
433 status = GdipCreateMatrix(&matrix);
434 expect(Ok, status);
435
436 status = GdipGetPenTransform(pen, matrix);
437 expect(Ok, status);
438 status = GdipGetMatrixElements(matrix, values);
439 expect(Ok, status);
440
441 GdipDeleteMatrix(matrix);
442}
GdipGetMatrixElements
GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix, REAL *out)
Definition: matrix.c:168
GdipDeleteMatrix
GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
Definition: matrix.c:156
GdipCreateMatrix
GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
Definition: matrix.c:136
GdipGetPenTransform
GpStatus WINGDIPAPI GdipGetPenTransform(GpPen *pen, GpMatrix *matrix)
Definition: pen.c:466
Status
Status
Definition: gdiplustypes.h:24
Ok
@ Ok
Definition: gdiplustypes.h:25
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 691 of file pen.c.

692{
693 struct GdiplusStartupInput gdiplusStartupInput;
694 ULONG_PTR gdiplusToken;
695 HMODULE hmsvcrt;
696 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
697
698 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
699 hmsvcrt = LoadLibraryA("msvcrt");
700 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
701 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
702
703 test_startup();
704
705 gdiplusStartupInput.GdiplusVersion = 1;
706 gdiplusStartupInput.DebugEventCallback = NULL;
707 gdiplusStartupInput.SuppressBackgroundThread = 0;
708 gdiplusStartupInput.SuppressExternalCodecs = 0;
709
710 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
711
712 test_constructor_destructor();
713 test_constructor_destructor2();
714 test_brushfill();
715 test_dasharray();
716 test_customcap();
717 test_penfilltype();
718 test_compoundarray();
719 test_transform();
720
721 GdiplusShutdown(gdiplusToken);
722}
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
_controlfp_s
_ACRTIMP errno_t __cdecl _controlfp_s(unsigned int *, unsigned int, unsigned int)
Definition: math.c:1304
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:83
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:34
test_brushfill
static void test_brushfill(void)
Definition: pen.c:123
test_customcap
static void test_customcap(void)
Definition: pen.c:250
test_compoundarray
static void test_compoundarray(void)
Definition: pen.c:349
test_penfilltype
static void test_penfilltype(void)
Definition: pen.c:299
test_constructor_destructor2
static void test_constructor_destructor2(void)
Definition: pen.c:91
test_dasharray
static void test_dasharray(void)
Definition: pen.c:167
test_constructor_destructor
static void test_constructor_destructor(void)
Definition: pen.c:71
test_transform
static void test_transform(void)
Definition: pen.c:444
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ test_brushfill()

static void test_brushfill ( void  )
static

Definition at line 123 of file pen.c.

124{
125 GpStatus status;
126 GpPen *pen;
127 GpBrush *brush, *brush2;
128 GpBrushType type;
129 ARGB color = 0;
130
131 /* default solid */
132 GdipCreatePen1(0xdeadbeef, 4.5, UnitWorld, &pen);
133 status = GdipGetPenBrushFill(pen, &brush);
134 expect(Ok, status);
135 GdipGetBrushType(brush, &type);
136 expect(BrushTypeSolidColor, type);
137 GdipGetPenColor(pen, &color);
138 expect(0xdeadbeef, color);
139 GdipDeleteBrush(brush);
140
141 /* color controlled by brush */
142 GdipCreateSolidFill(0xabaddeed, (GpSolidFill**)&brush);
143 status = GdipSetPenBrushFill(pen, brush);
144 expect(Ok, status);
145 GdipGetPenColor(pen, &color);
146 expect(0xabaddeed, color);
147 GdipDeleteBrush(brush);
148 color = 0;
149
150 /* get returns a clone, not a reference */
151 GdipGetPenBrushFill(pen, &brush);
152 GdipSetSolidFillColor((GpSolidFill*)brush, 0xbeadfeed);
153 GdipGetPenBrushFill(pen, &brush2);
154 ok(brush != brush2, "Expected to get a clone, not a copy of the reference\n");
155 GdipGetSolidFillColor((GpSolidFill*)brush2, &color);
156 expect(0xabaddeed, color);
157 GdipDeleteBrush(brush);
158 GdipDeleteBrush(brush2);
159
160 /* brush cannot be NULL */
161 status = GdipSetPenBrushFill(pen, NULL);
162 expect(InvalidParameter, status);
163
164 GdipDeletePen(pen);
165}
ok
#define ok(value,...)
Definition: atltest.h:57
GdipDeleteBrush
GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
Definition: brush.c:1020
GdipSetSolidFillColor
GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
Definition: brush.c:1951
GdipCreateSolidFill
GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
Definition: brush.c:783
GdipGetSolidFillColor
GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
Definition: brush.c:1299
GdipGetBrushType
GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
Definition: brush.c:976
GdipCreatePen1
GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, REAL width, GpUnit unit, GpPen **pen)
Definition: pen.c:146
GdipGetPenColor
GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb)
Definition: pen.c:230
GdipSetPenBrushFill
GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush)
Definition: pen.c:519
GdipDeletePen
GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen)
Definition: pen.c:204
GdipGetPenBrushFill
GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush)
Definition: pen.c:220
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:27
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 349 of file pen.c.

350{
351 GpStatus status;
352 GpPen *pen;
353 REAL *returnvalues;
354 static const REAL testvalues[] = {0.2, 0.4, 0.6, 0.8};
355 static const REAL notSortedValues[] = {0.2, 0.6, 0.4, 0.8};
356 static const REAL negativeValues[] = {-1.2, 0.4, 0.6, 0.8};
357 static const REAL tooLargeValues[] = {0.2, 0.4, 0.6, 2.8};
358 INT count;
359
360 status = GdipSetPenCompoundArray(NULL, testvalues, 4);
361 expect(InvalidParameter, status);
362
363 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
364 expect(Ok, status);
365
366 status = GdipGetPenCompoundCount(NULL, NULL);
367 expect(InvalidParameter, status);
368
369 status = GdipGetPenCompoundCount(pen, NULL);
370 expect(InvalidParameter, status);
371
372 count = 10;
373 status = GdipGetPenCompoundCount(pen, &count);
374 expect(Ok, status);
375 ok(count == 0, "Unexpected compound count %d\n", count);
376
377 status = GdipSetPenCompoundArray(pen, NULL, 0);
378 expect(InvalidParameter, status);
379 status = GdipSetPenCompoundArray(pen, NULL, 4);
380 expect(InvalidParameter, status);
381 status = GdipSetPenCompoundArray(pen, testvalues, 3);
382 expect(InvalidParameter, status);
383 status = GdipSetPenCompoundArray(pen, testvalues, 0);
384 expect(InvalidParameter, status);
385 status = GdipSetPenCompoundArray(pen, testvalues, -2);
386 expect(InvalidParameter, status);
387
388 status = GdipSetPenCompoundArray(pen, notSortedValues, 4);
389 expect(InvalidParameter, status);
390 status = GdipSetPenCompoundArray(pen, negativeValues, 4);
391 expect(InvalidParameter, status);
392 status = GdipSetPenCompoundArray(pen, tooLargeValues, 4);
393 expect(InvalidParameter, status);
394
395 status = GdipSetPenCompoundArray(pen, testvalues, 4);
396 expect(Ok, status);
397 status = GdipSetPenCompoundArray(pen, NULL, 0);
398 expect(InvalidParameter, status);
399
400 count = 0;
401 status = GdipGetPenCompoundCount(pen, &count);
402 expect(Ok, status);
403 ok(count == 4, "Unexpected compound count %d\n", count);
404
405 returnvalues = calloc(5, sizeof(REAL));
406 /* When count larger than stored array return error */
407 status = GdipGetPenCompoundArray(pen, returnvalues, 40);
408 expect(InvalidParameter, status);
409 status = GdipGetPenCompoundArray(NULL, returnvalues, 4);
410 expect(InvalidParameter, status);
411 /* When count is zero, it should do nothing */
412 status = GdipGetPenCompoundArray(pen, returnvalues, 0);
413 expect(Ok, status);
414 ok(returnvalues[0] == 0.0, "Unexpected compound array %f\n", returnvalues[0]);
415
416 status = GdipGetPenCompoundArray(pen, returnvalues, 4);
417 expect(Ok, status);
418 ok(memcmp(returnvalues, testvalues, 4 * sizeof(REAL)) == 0, "Unexpected compound array\n");
419
420 status = GdipGetPenCompoundArray(pen, returnvalues, -10);
421 expect(Ok, status);
422 ok(memcmp(returnvalues, testvalues, 4 * sizeof(REAL)) == 0, "Unexpected compound array\n");
423
424 free(returnvalues);
425 GdipDeletePen(pen);
426}
free
#define free
Definition: debug_ros.c:5
REAL
float REAL
Definition: types.h:41
GdipSetPenCompoundArray
GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *compoundarray, INT count)
Definition: pen.c:564
GdipGetPenCompoundArray
GpStatus WINGDIPAPI GdipGetPenCompoundArray(GpPen *pen, REAL *compoundarray, INT count)
Definition: pen.c:543
GdipGetPenCompoundCount
GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen *pen, INT *count)
Definition: pen.c:554
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2802
UnitPixel
@ UnitPixel
Definition: gdiplusenums.h:29
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
calloc
#define calloc
Definition: rosglue.h:14
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 71 of file pen.c.

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

Referenced by START_TEST().

◆ test_constructor_destructor2()

static void test_constructor_destructor2 ( void  )
static

Definition at line 91 of file pen.c.

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

Referenced by START_TEST().

◆ test_customcap()

static void test_customcap ( void  )
static

Definition at line 250 of file pen.c.

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

Referenced by START_TEST().

◆ test_dasharray()

static void test_dasharray ( void  )
static

Definition at line 167 of file pen.c.

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

Referenced by START_TEST().

◆ test_penfilltype()

static void test_penfilltype ( void  )
static

Definition at line 299 of file pen.c.

300{
301 GpPen *pen;
302 GpSolidFill *solid;
303 GpLineGradient *line;
304 GpPointF a, b;
305 GpStatus status;
306 GpPenType type;
307
308 /* NULL */
309 status = GdipGetPenFillType(NULL, NULL);
310 expect(InvalidParameter, status);
311
312 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
313 expect(Ok, status);
314 status = GdipGetPenFillType(pen, NULL);
315 expect(InvalidParameter, status);
316
317 /* created with GdipCreatePen1() */
318 status = GdipGetPenFillType(pen, &type);
319 expect(Ok, status);
320 expect(PenTypeSolidColor, type);
321 GdipDeletePen(pen);
322
323 /* based on SolidBrush */
324 status = GdipCreateSolidFill((ARGB)0xffff00ff, &solid);
325 expect(Ok, status);
326 status = GdipCreatePen2((GpBrush*)solid, 10.0f, UnitPixel, &pen);
327 expect(Ok, status);
328 status = GdipGetPenFillType(pen, &type);
329 expect(Ok, status);
330 expect(PenTypeSolidColor, type);
331 GdipDeletePen(pen);
332 GdipDeleteBrush((GpBrush*)solid);
333
334 /* based on LinearGradientBrush */
335 a.X = a.Y = 0.0;
336 b.X = b.Y = 10.0;
337 status = GdipCreateLineBrush(&a, &b, (ARGB)0xffff00ff, (ARGB)0xffff0000,
338 WrapModeTile, &line);
339 expect(Ok, status);
340 status = GdipCreatePen2((GpBrush*)line, 10.0f, UnitPixel, &pen);
341 expect(Ok, status);
342 status = GdipGetPenFillType(pen, &type);
343 expect(Ok, status);
344 expect(PenTypeLinearGradient, type);
345 GdipDeletePen(pen);
346 GdipDeleteBrush((GpBrush*)line);
347}
GdipGetPenFillType
GpStatus WINGDIPAPI GdipGetPenFillType(GpPen *pen, GpPenType *type)
Definition: pen.c:349
PenType
PenType
Definition: gdiplusenums.h:94
PenTypeSolidColor
@ PenTypeSolidColor
Definition: gdiplusenums.h:95
PenTypeLinearGradient
@ PenTypeLinearGradient
Definition: gdiplusenums.h:99
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

Referenced by START_TEST().

◆ test_startup()

static void test_startup ( void  )
static

Definition at line 34 of file pen.c.

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

Referenced by START_TEST().

◆ test_transform()

static void test_transform ( void  )
static

Definition at line 444 of file pen.c.

445{
446 GpStatus status;
447 GpPen *pen;
448 GpMatrix *matrix, *matrix2, *not_invertible_matrix;
449 REAL values[6];
450
451 /* Check default Pen Transformation */
452 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
453 expect(Ok, status);
454
455 status = GdipCreateMatrix(&matrix);
456 expect(Ok, status);
457
458 status = GdipGetPenTransform(pen, matrix);
459 expect(Ok, status);
460
461 status = GdipGetMatrixElements(matrix, values);
462 expect(Ok, status);
463
464 expectf(1.0, values[0]);
465 expectf(0.0, values[1]);
466 expectf(0.0, values[2]);
467 expectf(1.0, values[3]);
468 expectf(0.0, values[4]);
469 expectf(0.0, values[5]);
470
471 /* Setting Pen Tranformation to Not invertible matrix, should return InvalidParameter */
472 GdipCreateMatrix2(3.0, 3.0, 2.0, 2.0, 6.0, 3.0, &not_invertible_matrix);
473
474 status = GdipSetPenTransform(pen, not_invertible_matrix);
475 expect(InvalidParameter, status);
476 GdipDeleteMatrix(not_invertible_matrix);
477
478 status = GdipGetPenTransform(pen, matrix);
479 expect(Ok, status);
480 status = GdipGetMatrixElements(matrix, values);
481 expect(Ok, status);
482
483 expectf(1.0, values[0]);
484 expectf(0.0, values[1]);
485 expectf(0.0, values[2]);
486 expectf(1.0, values[3]);
487 expectf(0.0, values[4]);
488 expectf(0.0, values[5]);
489
490 /* Setting Pen Tranformation to invertible matrix, should be successfull */
491 GdipCreateMatrix2(3.0, -2.0, 5.0, 2.0, 6.0, 3.0, &matrix2);
492 status = GdipSetPenTransform(pen, matrix2);
493 expect(Ok, status);
494 GdipDeleteMatrix(matrix2);
495
496 status = GdipGetPenTransform(pen, matrix);
497 expect(Ok, status);
498 status = GdipGetMatrixElements(matrix, values);
499 expect(Ok, status);
500 expectf(3.0, values[0]);
501 expectf(-2.0, values[1]);
502 expectf(5.0, values[2]);
503 expectf(2.0, values[3]);
504 expectf(6.0, values[4]);
505 expectf(3.0, values[5]);
506
507 /* Translate */
508 status = GdipTranslatePenTransform(NULL, 1.0, -2.0, MatrixOrderAppend);
509 expect(InvalidParameter, status);
510
511 status = GdipTranslatePenTransform(pen, 1.0, -2.0, MatrixOrderAppend);
512 expect(Ok, status);
513
514 status = GdipGetPenTransform(pen, matrix);
515 expect(Ok, status);
516 status = GdipGetMatrixElements(matrix, values);
517 expect(Ok, status);
518 expectf(3.0, values[0]);
519 expectf(-2.0, values[1]);
520 expectf(5.0, values[2]);
521 expectf(2.0, values[3]);
522 expectf(7.0, values[4]);
523 expectf(1.0, values[5]);
524
525 status = GdipTranslatePenTransform(pen, -3.0, 5.0, MatrixOrderPrepend);
526 expect(Ok, status);
527
528 status = GdipGetPenTransform(pen, matrix);
529 expect(Ok, status);
530 status = GdipGetMatrixElements(matrix, values);
531 expect(Ok, status);
532 expectf(3.0, values[0]);
533 expectf(-2.0, values[1]);
534 expectf(5.0, values[2]);
535 expectf(2.0, values[3]);
536 expectf(23.0, values[4]);
537 expectf(17.0, values[5]);
538
539 status = GdipResetPenTransform(pen);
540 expect(Ok, status);
541
542 status = GdipGetPenTransform(pen, matrix);
543 expect(Ok, status);
544 status = GdipGetMatrixElements(matrix, values);
545 expect(Ok, status);
546
547 expectf(1.0, values[0]);
548 expectf(0.0, values[1]);
549 expectf(0.0, values[2]);
550 expectf(1.0, values[3]);
551 expectf(0.0, values[4]);
552 expectf(0.0, values[5]);
553
554 /* Scale */
555 status = GdipScalePenTransform(NULL, 1.0, 1.0, MatrixOrderPrepend);
556 expect(InvalidParameter, status);
557
558 status = GdipScalePenTransform(pen, 1.0, 1.0, MatrixOrderPrepend);
559 expect(Ok, status);
560
561 get_pen_transform(pen, values);
562 expectf(1.0, values[0]);
563 expectf(0.0, values[1]);
564 expectf(0.0, values[2]);
565 expectf(1.0, values[3]);
566 expectf(0.0, values[4]);
567 expectf(0.0, values[5]);
568
569 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderPrepend);
570 expect(Ok, status);
571
572 get_pen_transform(pen, values);
573 expectf(2.0, values[0]);
574 expectf(0.0, values[1]);
575 expectf(0.0, values[2]);
576 expectf(-10.0, values[3]);
577 expectf(0.0, values[4]);
578 expectf(0.0, values[5]);
579
580 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
581 expect(Ok, status);
582
583 get_pen_transform(pen, values);
584 expectf(4.0, values[0]);
585 expectf(0.0, values[1]);
586 expectf(0.0, values[2]);
587 expectf(100.0, values[3]);
588 expectf(0.0, values[4]);
589 expectf(0.0, values[5]);
590
591 status = GdipTranslatePenTransform(pen, 1.0, -2.0, MatrixOrderAppend);
592 expect(Ok, status);
593
594 get_pen_transform(pen, values);
595 expectf(4.0, values[0]);
596 expectf(0.0, values[1]);
597 expectf(0.0, values[2]);
598 expectf(100.0, values[3]);
599 expectf(1.0, values[4]);
600 expectf(-2.0, values[5]);
601
602 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderPrepend);
603 expect(Ok, status);
604
605 get_pen_transform(pen, values);
606 expectf(8.0, values[0]);
607 expectf(0.0, values[1]);
608 expectf(0.0, values[2]);
609 expectf(-1000.0, values[3]);
610 expectf(1.0, values[4]);
611 expectf(-2.0, values[5]);
612
613 /* Multiply */
614 status = GdipResetPenTransform(pen);
615 expect(Ok, status);
616
617 status = GdipSetMatrixElements(matrix, 2.0, 1.0, 1.0, 4.0, 1.0, 2.0);
618 expect(Ok, status);
619
620 status = GdipMultiplyPenTransform(NULL, matrix, MatrixOrderPrepend);
621 expect(InvalidParameter, status);
622
623 status = GdipMultiplyPenTransform(pen, matrix, MatrixOrderPrepend);
624 expect(Ok, status);
625
626 get_pen_transform(pen, values);
627 expectf(2.0, values[0]);
628 expectf(1.0, values[1]);
629 expectf(1.0, values[2]);
630 expectf(4.0, values[3]);
631 expectf(1.0, values[4]);
632 expectf(2.0, values[5]);
633
634 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
635 expect(Ok, status);
636
637 status = GdipMultiplyPenTransform(pen, matrix, MatrixOrderAppend);
638 expect(Ok, status);
639
640 get_pen_transform(pen, values);
641 expectf(-2.0, values[0]);
642 expectf(-36.0, values[1]);
643 expectf(-36.0, values[2]);
644 expectf(-158.0, values[3]);
645 expectf(-15.0, values[4]);
646 expectf(-76.0, values[5]);
647
648 /* Rotate */
649 status = GdipResetPenTransform(pen);
650 expect(Ok, status);
651
652 status = GdipSetMatrixElements(matrix, 2.0, 1.0, 1.0, 4.0, 1.0, 2.0);
653 expect(Ok, status);
654
655 status = GdipSetPenTransform(pen, matrix);
656 expect(Ok, status);
657
658 status = GdipRotatePenTransform(NULL, 10.0, MatrixOrderPrepend);
659 expect(InvalidParameter, status);
660
661 status = GdipRotatePenTransform(pen, 45.0, MatrixOrderPrepend);
662 expect(Ok, status);
663
664 get_pen_transform(pen, values);
665 expectf(2.12, values[0]);
666 expectf(3.54, values[1]);
667 expectf(-0.71, values[2]);
668 expectf(2.12, values[3]);
669 expectf(1.0, values[4]);
670 expectf(2.0, values[5]);
671
672 status = GdipScalePenTransform(pen, 2.0, -10.0, MatrixOrderAppend);
673 expect(Ok, status);
674
675 status = GdipRotatePenTransform(pen, 180.0, MatrixOrderAppend);
676 expect(Ok, status);
677
678 get_pen_transform(pen, values);
679 expectf(-4.24, values[0]);
680 expectf(35.36, values[1]);
681 expectf(1.41, values[2]);
682 expectf(21.21, values[3]);
683 expectf(-2.0, values[4]);
684 expectf(20.0, values[5]);
685
686 GdipDeletePen(pen);
687
688 GdipDeleteMatrix(matrix);
689}
GdipCreateMatrix2
GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy, GpMatrix **matrix)
Definition: matrix.c:59
GdipSetMatrixElements
GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
Definition: matrix.c:318
GdipScalePenTransform
GpStatus WINGDIPAPI GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy, GpMatrixOrder order)
Definition: pen.c:488
GdipMultiplyPenTransform
GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen *pen, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
Definition: pen.c:508
GdipResetPenTransform
GpStatus WINGDIPAPI GdipResetPenTransform(GpPen *pen)
Definition: pen.c:433
GdipTranslatePenTransform
GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen *pen, REAL dx, REAL dy, GpMatrixOrder order)
Definition: pen.c:478
GdipSetPenTransform
GpStatus WINGDIPAPI GdipSetPenTransform(GpPen *pen, GpMatrix *matrix)
Definition: pen.c:445
GdipRotatePenTransform
GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen *pen, REAL angle, GpMatrixOrder order)
Definition: pen.c:498
MatrixOrderAppend
@ MatrixOrderAppend
Definition: gdiplusenums.h:188
MatrixOrderPrepend
@ MatrixOrderPrepend
Definition: gdiplusenums.h:187
get_pen_transform
static void get_pen_transform(GpPen *pen, REAL *values)
Definition: pen.c:428

Referenced by START_TEST().