static void test_rect(void) { GpStatus status; GpPath *path; GpRectF rects[2]; GdipCreatePath(FillModeAlternate, &path); status = GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0); expect(Ok, status); status = GdipAddPathRectangle(path, 100.0, 50.0, 120.0, 30.0); expect(Ok, status); ok_path(path, rect_path, sizeof(rect_path)/sizeof(path_test_t), FALSE); GdipDeletePath(path); GdipCreatePath(FillModeAlternate, &path); rects[0].X = 5.0; rects[0].Y = 5.0; rects[0].Width = 100.0; rects[0].Height = 50.0; rects[1].X = 100.0; rects[1].Y = 50.0; rects[1].Width = 120.0; rects[1].Height = 30.0; status = GdipAddPathRectangles(path, (GDIPCONST GpRectF*)&rects, 2); expect(Ok, status); ok_path(path, rect_path, sizeof(rect_path)/sizeof(path_test_t), FALSE); GdipDeletePath(path); }
static void test_empty_rect(void) { GpPath *path; GpStatus status; BOOL result; status = GdipCreatePath(FillModeAlternate, &path); expect(Ok, status); status = GdipAddPathRectangle(path, 0.0, 0.0, -5.0, 5.0); expect(Ok, status); status = GdipIsVisiblePathPoint(path, -2.0, 2.0, NULL, &result); expect(Ok, status); expect(FALSE, status); status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, -5.0); expect(Ok, status); status = GdipAddPathRectangle(path, 0.0, 0.0, 0.0, 5.0); expect(Ok, status); status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, 0.0); expect(Ok, status); GdipDeletePath(path); }
static void test_scale(void) { GpCustomLineCap *custom; GpPath *path; REAL scale; GpStatus stat; stat = GdipCreatePath(FillModeAlternate, &path); expect(Ok, stat); stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0); expect(Ok, stat); stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom); expect(Ok, stat); /* NULL args */ stat = GdipGetCustomLineCapWidthScale(NULL, NULL); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapWidthScale(NULL, &scale); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapWidthScale(custom, NULL); expect(InvalidParameter, stat); /* valid args */ scale = (REAL)0xdeadbeef; stat = GdipGetCustomLineCapWidthScale(custom, &scale); expect(Ok, stat); expectf(1.0, scale); GdipDeleteCustomLineCap(custom); GdipDeletePath(path); }
static void test_inset(void) { GpCustomLineCap *custom; GpPath *path; REAL inset; GpStatus stat; stat = GdipCreatePath(FillModeAlternate, &path); expect(Ok, stat); stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0); expect(Ok, stat); stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom); expect(Ok, stat); /* NULL args */ stat = GdipGetCustomLineCapBaseInset(NULL, NULL); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapBaseInset(NULL, &inset); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapBaseInset(custom, NULL); expect(InvalidParameter, stat); /* valid args */ inset = (REAL)0xdeadbeef; stat = GdipGetCustomLineCapBaseInset(custom, &inset); expect(Ok, stat); expectf(0.0, inset); GdipDeleteCustomLineCap(custom); GdipDeletePath(path); }
/* Transforms GpRegion elements with given matrix */ static GpStatus transform_region_element(region_element* element, GpMatrix *matrix) { GpStatus stat; switch(element->type) { case RegionDataEmptyRect: case RegionDataInfiniteRect: return Ok; case RegionDataRect: { /* We can't transform a rectangle, so convert it to a path. */ GpRegion *new_region; GpPath *path; stat = GdipCreatePath(FillModeAlternate, &path); if (stat == Ok) { stat = GdipAddPathRectangle(path, element->elementdata.rect.X, element->elementdata.rect.Y, element->elementdata.rect.Width, element->elementdata.rect.Height); if (stat == Ok) stat = GdipCreateRegionPath(path, &new_region); GdipDeletePath(path); } if (stat == Ok) { /* Steal the element from the created region. */ memcpy(element, &new_region->node, sizeof(region_element)); heap_free(new_region); } else return stat; } /* Fall-through to do the actual conversion. */ case RegionDataPath: if (!element->elementdata.path->pathdata.Count) return Ok; stat = GdipTransformMatrixPoints(matrix, element->elementdata.path->pathdata.Points, element->elementdata.path->pathdata.Count); return stat; default: stat = transform_region_element(element->elementdata.combine.left, matrix); if (stat == Ok) stat = transform_region_element(element->elementdata.combine.right, matrix); return stat; } }
static void test_constructor_destructor(void) { GpCustomLineCap *custom; GpPath *path, *path2; GpStatus stat; stat = GdipCreatePath(FillModeAlternate, &path); expect(Ok, stat); stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0); expect(Ok, stat); stat = GdipCreatePath(FillModeAlternate, &path2); expect(Ok, stat); stat = GdipAddPathRectangle(path2, 5.0, 5.0, 10.0, 10.0); expect(Ok, stat); /* NULL args */ stat = GdipCreateCustomLineCap(NULL, NULL, LineCapFlat, 0.0, NULL); expect(InvalidParameter, stat); stat = GdipCreateCustomLineCap(path, NULL, LineCapFlat, 0.0, NULL); expect(InvalidParameter, stat); stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, NULL); expect(InvalidParameter, stat); stat = GdipCreateCustomLineCap(NULL, NULL, LineCapFlat, 0.0, &custom); expect(InvalidParameter, stat); stat = GdipDeleteCustomLineCap(NULL); expect(InvalidParameter, stat); /* valid args */ stat = GdipCreateCustomLineCap(NULL, path2, LineCapFlat, 0.0, &custom); expect(Ok, stat); stat = GdipDeleteCustomLineCap(custom); expect(Ok, stat); /* it's strange but native returns NotImplemented on stroke == NULL */ stat = GdipCreateCustomLineCap(path, NULL, LineCapFlat, 10.0, &custom); todo_wine expect(NotImplemented, stat); GdipDeletePath(path2); GdipDeletePath(path); }
static void test_isvisible(void) { GpPath *path; GpGraphics *graphics = NULL; HDC hdc = GetDC(0); BOOL result; GpStatus status; status = GdipCreateFromHDC(hdc, &graphics); expect(Ok, status); status = GdipCreatePath(FillModeAlternate, &path); expect(Ok, status); /* NULL */ status = GdipIsVisiblePathPoint(NULL, 0.0, 0.0, NULL, NULL); expect(InvalidParameter, status); status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, NULL); expect(InvalidParameter, status); status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, NULL); expect(InvalidParameter, status); status = GdipIsVisiblePathPoint(path, 0.0, 0.0, graphics, NULL); expect(InvalidParameter, status); /* empty path */ result = TRUE; status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, &result); expect(Ok, status); expect(FALSE, result); /* rect */ status = GdipAddPathRectangle(path, 0.0, 0.0, 10.0, 10.0); expect(Ok, status); result = FALSE; status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, &result); expect(Ok, status); expect(TRUE, result); result = TRUE; status = GdipIsVisiblePathPoint(path, 11.0, 11.0, NULL, &result); expect(Ok, status); expect(FALSE, result); /* not affected by clipping */ status = GdipSetClipRect(graphics, 5.0, 5.0, 5.0, 5.0, CombineModeReplace); expect(Ok, status); result = FALSE; status = GdipIsVisiblePathPoint(path, 0.0, 0.0, graphics, &result); expect(Ok, status); expect(TRUE, result); GdipDeletePath(path); GdipDeleteGraphics(graphics); ReleaseDC(0, hdc); }
static void test_linejoin(void) { GpCustomLineCap *custom; GpPath *path; GpLineJoin join; GpStatus stat; stat = GdipCreatePath(FillModeAlternate, &path); expect(Ok, stat); stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0); expect(Ok, stat); stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom); expect(Ok, stat); /* NULL args */ stat = GdipGetCustomLineCapStrokeJoin(NULL, NULL); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapStrokeJoin(custom, NULL); expect(InvalidParameter, stat); stat = GdipGetCustomLineCapStrokeJoin(NULL, &join); expect(InvalidParameter, stat); stat = GdipSetCustomLineCapStrokeJoin(NULL, LineJoinBevel); expect(InvalidParameter, stat); /* LineJoinMiter is default */ stat = GdipGetCustomLineCapStrokeJoin(custom, &join); expect(Ok, stat); expect(LineJoinMiter, join); /* set/get */ stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinBevel); expect(Ok, stat); stat = GdipGetCustomLineCapStrokeJoin(custom, &join); expect(Ok, stat); expect(LineJoinBevel, join); stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinRound); expect(Ok, stat); stat = GdipGetCustomLineCapStrokeJoin(custom, &join); expect(Ok, stat); expect(LineJoinRound, join); stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinMiterClipped); expect(Ok, stat); stat = GdipGetCustomLineCapStrokeJoin(custom, &join); expect(Ok, stat); expect(LineJoinMiterClipped, join); GdipDeleteCustomLineCap(custom); GdipDeletePath(path); }
static void test_lastpoint(void) { GpStatus status; GpPath *path; GpPointF ptf; GdipCreatePath(FillModeAlternate, &path); status = GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0); expect(Ok, status); /* invalid args */ status = GdipGetPathLastPoint(NULL, &ptf); expect(InvalidParameter, status); status = GdipGetPathLastPoint(path, NULL); expect(InvalidParameter, status); status = GdipGetPathLastPoint(NULL, NULL); expect(InvalidParameter, status); status = GdipGetPathLastPoint(path, &ptf); expect(Ok, status); expect(TRUE, (ptf.X == 5.0) && (ptf.Y == 55.0)); GdipDeletePath(path); }
/****************************************************************************** * GdipCreateRegionHrgn [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region) { DWORD size; LPRGNDATA buf; LPRECT rect; GpStatus stat; GpPath* path; GpRegion* local; DWORD i; TRACE("(%p, %p)\n", hrgn, region); if(!region || !(size = GetRegionData(hrgn, 0, NULL))) return InvalidParameter; buf = heap_alloc_zero(size); if(!buf) return OutOfMemory; if(!GetRegionData(hrgn, size, buf)){ heap_free(buf); return GenericError; } if(buf->rdh.nCount == 0){ if((stat = GdipCreateRegion(&local)) != Ok){ heap_free(buf); return stat; } if((stat = GdipSetEmpty(local)) != Ok){ heap_free(buf); GdipDeleteRegion(local); return stat; } *region = local; heap_free(buf); return Ok; } if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){ heap_free(buf); return stat; } rect = (LPRECT)buf->Buffer; for(i = 0; i < buf->rdh.nCount; i++){ if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top, (REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){ heap_free(buf); GdipDeletePath(path); return stat; } rect++; } stat = GdipCreateRegionPath(path, region); heap_free(buf); GdipDeletePath(path); return stat; }
static GpStatus get_region_hrgn(struct region_element *element, GpGraphics *graphics, HRGN *hrgn) { switch (element->type) { case RegionDataInfiniteRect: *hrgn = NULL; return Ok; case RegionDataEmptyRect: *hrgn = CreateRectRgn(0, 0, 0, 0); return *hrgn ? Ok : OutOfMemory; case RegionDataPath: return get_path_hrgn(element->elementdata.path, graphics, hrgn); case RegionDataRect: { GpPath* path; GpStatus stat; GpRectF* rc = &element->elementdata.rect; stat = GdipCreatePath(FillModeAlternate, &path); if (stat != Ok) return stat; stat = GdipAddPathRectangle(path, rc->X, rc->Y, rc->Width, rc->Height); if (stat == Ok) stat = get_path_hrgn(path, graphics, hrgn); GdipDeletePath(path); return stat; } case CombineModeIntersect: case CombineModeUnion: case CombineModeXor: case CombineModeExclude: case CombineModeComplement: { HRGN left, right; GpStatus stat; int ret; stat = get_region_hrgn(element->elementdata.combine.left, graphics, &left); if (stat != Ok) { *hrgn = NULL; return stat; } if (left == NULL) { /* existing region is infinite */ switch (element->type) { case CombineModeIntersect: return get_region_hrgn(element->elementdata.combine.right, graphics, hrgn); case CombineModeXor: case CombineModeExclude: left = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22); break; case CombineModeUnion: case CombineModeComplement: *hrgn = NULL; return Ok; } } stat = get_region_hrgn(element->elementdata.combine.right, graphics, &right); if (stat != Ok) { DeleteObject(left); *hrgn = NULL; return stat; } if (right == NULL) { /* new region is infinite */ switch (element->type) { case CombineModeIntersect: *hrgn = left; return Ok; case CombineModeXor: case CombineModeComplement: right = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22); break; case CombineModeUnion: case CombineModeExclude: DeleteObject(left); *hrgn = NULL; return Ok; } } switch (element->type) { case CombineModeIntersect: ret = CombineRgn(left, left, right, RGN_AND); break; case CombineModeUnion: ret = CombineRgn(left, left, right, RGN_OR); break; case CombineModeXor: ret = CombineRgn(left, left, right, RGN_XOR); break; case CombineModeExclude: ret = CombineRgn(left, left, right, RGN_DIFF); break; case CombineModeComplement: ret = CombineRgn(left, right, left, RGN_DIFF); break; default: ret = ERROR; } DeleteObject(right); if (ret == ERROR) { DeleteObject(left); *hrgn = NULL; return GenericError; } *hrgn = left; return Ok; } default: FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element->type); *hrgn = NULL; return NotImplemented; } }
GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y, INT width, INT height) { return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height); }
static void test_getregiondata(void) { GpStatus status; GpRegion *region, *region2; RegionDataPoint *point; UINT needed; DWORD buf[100]; GpRect rect; GpPath *path; memset(buf, 0xee, sizeof(buf)); status = GdipCreateRegion(®ion); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); expect_dword(buf, 12); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_INFINITE_RECT); status = GdipSetEmpty(region); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); expect_dword(buf, 12); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_EMPTY_RECT); status = GdipSetInfinite(region); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(20, needed); expect_dword(buf, 12); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_INFINITE_RECT); status = GdipDeleteRegion(region); ok(status == Ok, "status %08x\n", status); rect.X = 10; rect.Y = 20; rect.Width = 100; rect.Height = 200; status = GdipCreateRegionRectI(&rect, ®ion); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(36, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(36, needed); expect_dword(buf, 28); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_RECT); expect_float(buf + 5, 10.0); expect_float(buf + 6, 20.0); expect_float(buf + 7, 100.0); expect_float(buf + 8, 200.0); rect.X = 50; rect.Y = 30; rect.Width = 10; rect.Height = 20; status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect); ok(status == Ok, "status %08x\n", status); rect.X = 100; rect.Y = 300; rect.Width = 30; rect.Height = 50; status = GdipCombineRegionRectI(region, &rect, CombineModeXor); ok(status == Ok, "status %08x\n", status); rect.X = 200; rect.Y = 100; rect.Width = 133; rect.Height = 266; status = GdipCreateRegionRectI(&rect, ®ion2); ok(status == Ok, "status %08x\n", status); rect.X = 20; rect.Y = 10; rect.Width = 40; rect.Height = 66; status = GdipCombineRegionRectI(region2, &rect, CombineModeUnion); ok(status == Ok, "status %08x\n", status); status = GdipCombineRegionRegion(region, region2, CombineModeComplement); ok(status == Ok, "status %08x\n", status); rect.X = 400; rect.Y = 500; rect.Width = 22; rect.Height = 55; status = GdipCombineRegionRectI(region, &rect, CombineModeExclude); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(156, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(156, needed); expect_dword(buf, 148); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 10); expect_dword(buf + 4, CombineModeExclude); expect_dword(buf + 5, CombineModeComplement); expect_dword(buf + 6, CombineModeXor); expect_dword(buf + 7, CombineModeIntersect); expect_dword(buf + 8, RGNDATA_RECT); expect_float(buf + 9, 10.0); expect_float(buf + 10, 20.0); expect_float(buf + 11, 100.0); expect_float(buf + 12, 200.0); expect_dword(buf + 13, RGNDATA_RECT); expect_float(buf + 14, 50.0); expect_float(buf + 15, 30.0); expect_float(buf + 16, 10.0); expect_float(buf + 17, 20.0); expect_dword(buf + 18, RGNDATA_RECT); expect_float(buf + 19, 100.0); expect_float(buf + 20, 300.0); expect_float(buf + 21, 30.0); expect_float(buf + 22, 50.0); expect_dword(buf + 23, CombineModeUnion); expect_dword(buf + 24, RGNDATA_RECT); expect_float(buf + 25, 200.0); expect_float(buf + 26, 100.0); expect_float(buf + 27, 133.0); expect_float(buf + 28, 266.0); expect_dword(buf + 29, RGNDATA_RECT); expect_float(buf + 30, 20.0); expect_float(buf + 31, 10.0); expect_float(buf + 32, 40.0); expect_float(buf + 33, 66.0); expect_dword(buf + 34, RGNDATA_RECT); expect_float(buf + 35, 400.0); expect_float(buf + 36, 500.0); expect_float(buf + 37, 22.0); expect_float(buf + 38, 55.0); status = GdipDeleteRegion(region2); ok(status == Ok, "status %08x\n", status); status = GdipDeleteRegion(region); ok(status == Ok, "status %08x\n", status); /* Try some paths */ status = GdipCreatePath(FillModeAlternate, &path); ok(status == Ok, "status %08x\n", status); GdipAddPathRectangle(path, 12.5, 13.0, 14.0, 15.0); status = GdipCreateRegionPath(path, ®ion); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(72, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(72, needed); expect_dword(buf, 64); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_PATH); expect_dword(buf + 5, 0x00000030); expect_magic((DWORD*)(buf + 6)); expect_dword(buf + 7, 0x00000004); expect_dword(buf + 8, 0x00000000); expect_float(buf + 9, 12.5); expect_float(buf + 10, 13.0); expect_float(buf + 11, 26.5); expect_float(buf + 12, 13.0); expect_float(buf + 13, 26.5); expect_float(buf + 14, 28.0); expect_float(buf + 15, 12.5); expect_float(buf + 16, 28.0); expect_dword(buf + 17, 0x81010100); rect.X = 50; rect.Y = 30; rect.Width = 10; rect.Height = 20; status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect); ok(status == Ok, "status %08x\n", status); status = GdipGetRegionDataSize(region, &needed); ok(status == Ok, "status %08x\n", status); expect(96, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); ok(status == Ok, "status %08x\n", status); expect(96, needed); expect_dword(buf, 88); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 2); expect_dword(buf + 4, CombineModeIntersect); expect_dword(buf + 5, RGNDATA_PATH); expect_dword(buf + 6, 0x00000030); expect_magic((DWORD*)(buf + 7)); expect_dword(buf + 8, 0x00000004); expect_dword(buf + 9, 0x00000000); expect_float(buf + 10, 12.5); expect_float(buf + 11, 13.0); expect_float(buf + 12, 26.5); expect_float(buf + 13, 13.0); expect_float(buf + 14, 26.5); expect_float(buf + 15, 28.0); expect_float(buf + 16, 12.5); expect_float(buf + 17, 28.0); expect_dword(buf + 18, 0x81010100); expect_dword(buf + 19, RGNDATA_RECT); expect_float(buf + 20, 50.0); expect_float(buf + 21, 30.0); expect_float(buf + 22, 10.0); expect_float(buf + 23, 20.0); status = GdipDeleteRegion(region); ok(status == Ok, "status %08x\n", status); status = GdipDeletePath(path); ok(status == Ok, "status %08x\n", status); /* Test an empty path */ status = GdipCreatePath(FillModeAlternate, &path); expect(Ok, status); status = GdipCreateRegionPath(path, ®ion); expect(Ok, status); status = GdipGetRegionDataSize(region, &needed); expect(Ok, status); expect(36, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); expect(Ok, status); expect(36, needed); expect_dword(buf, 28); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_PATH); /* Second signature for pathdata */ expect_dword(buf + 5, 12); expect_magic((DWORD*)(buf + 6)); expect_dword(buf + 7, 0); expect_dword(buf + 8, 0x00004000); status = GdipDeleteRegion(region); expect(Ok, status); /* Test a simple triangle of INTs */ status = GdipAddPathLine(path, 5, 6, 7, 8); expect(Ok, status); status = GdipAddPathLine(path, 8, 1, 5, 6); expect(Ok, status); status = GdipClosePathFigure(path); expect(Ok, status); status = GdipCreateRegionPath(path, ®ion); expect(Ok, status); status = GdipGetRegionDataSize(region, &needed); expect(Ok, status); expect(56, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); expect(Ok, status); expect(56, needed); expect_dword(buf, 48); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3 , 0); expect_dword(buf + 4 , RGNDATA_PATH); expect_dword(buf + 5, 32); expect_magic((DWORD*)(buf + 6)); expect_dword(buf + 7, 4); expect_dword(buf + 8, 0x00004000); /* ?? */ point = (RegionDataPoint*)buf + 9; expect(5, point[0].X); expect(6, point[0].Y); expect(7, point[1].X); /* buf + 10 */ expect(8, point[1].Y); expect(8, point[2].X); /* buf + 11 */ expect(1, point[2].Y); expect(5, point[3].X); /* buf + 12 */ expect(6, point[3].Y); expect_dword(buf + 13, 0x81010100); /* 0x01010100 if we don't close the path */ status = GdipDeletePath(path); expect(Ok, status); status = GdipDeleteRegion(region); expect(Ok, status); /* Test a floating-point triangle */ status = GdipCreatePath(FillModeAlternate, &path); expect(Ok, status); status = GdipAddPathLine(path, 5.6, 6.2, 7.2, 8.9); expect(Ok, status); status = GdipAddPathLine(path, 8.1, 1.6, 5.6, 6.2); expect(Ok, status); status = GdipCreateRegionPath(path, ®ion); expect(Ok, status); status = GdipGetRegionDataSize(region, &needed); expect(Ok, status); expect(72, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); expect(Ok, status); expect(72, needed); expect_dword(buf, 64); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 0); expect_dword(buf + 4, RGNDATA_PATH); expect_dword(buf + 5, 48); expect_magic((DWORD*)(buf + 6)); expect_dword(buf + 7, 4); expect_dword(buf + 8, 0); expect_float(buf + 9, 5.6); expect_float(buf + 10, 6.2); expect_float(buf + 11, 7.2); expect_float(buf + 12, 8.9); expect_float(buf + 13, 8.1); expect_float(buf + 14, 1.6); expect_float(buf + 15, 5.6); expect_float(buf + 16, 6.2); status = GdipDeletePath(path); expect(Ok, status); status = GdipDeleteRegion(region); expect(Ok, status); /* Test for a path with > 4 points, and CombineRegionPath */ GdipCreatePath(FillModeAlternate, &path); status = GdipAddPathLine(path, 50, 70.2, 60, 102.8); expect(Ok, status); status = GdipAddPathLine(path, 55.4, 122.4, 40.4, 60.2); expect(Ok, status); status = GdipAddPathLine(path, 45.6, 20.2, 50, 70.2); expect(Ok, status); rect.X = 20; rect.Y = 25; rect.Width = 60; rect.Height = 120; status = GdipCreateRegionRectI(&rect, ®ion); expect(Ok, status); status = GdipCombineRegionPath(region, path, CombineModeUnion); expect(Ok, status); status = GdipGetRegionDataSize(region, &needed); expect(Ok, status); expect(116, needed); status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed); expect(Ok, status); expect(116, needed); expect_dword(buf, 108); trace("buf[1] = %08x\n", buf[1]); expect_magic((DWORD*)(buf + 2)); expect_dword(buf + 3, 2); expect_dword(buf + 4, CombineModeUnion); expect_dword(buf + 5, RGNDATA_RECT); expect_float(buf + 6, 20); expect_float(buf + 7, 25); expect_float(buf + 8, 60); expect_float(buf + 9, 120); expect_dword(buf + 10, RGNDATA_PATH); expect_dword(buf + 11, 68); expect_magic((DWORD*)(buf + 12)); expect_dword(buf + 13, 6); expect_float(buf + 14, 0x0); expect_float(buf + 15, 50); expect_float(buf + 16, 70.2); expect_float(buf + 17, 60); expect_float(buf + 18, 102.8); expect_float(buf + 19, 55.4); expect_float(buf + 20, 122.4); expect_float(buf + 21, 40.4); expect_float(buf + 22, 60.2); expect_float(buf + 23, 45.6); expect_float(buf + 24, 20.2); expect_float(buf + 25, 50); expect_float(buf + 26, 70.2); expect_dword(buf + 27, 0x01010100); expect_dword(buf + 28, 0x00000101); status = GdipDeletePath(path); expect(Ok, status); status = GdipDeleteRegion(region); expect(Ok, status); }