graphics.c File Reference

#include <math.h>
#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"

Include dependency graph for graphics.c:

Go to the source code of this file.

Classes
struct	node

Macros
#define	expect(expected, got)   ok((got) == (expected), "Expected %d, got %d\n", (INT)(expected), (INT)(got))
#define	expectf_(expected, got, precision)   ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))
#define	expectf(expected, got)   expectf_((expected), (got), 0.001)
#define	BLUE_COLOR   (0xff0000ff)
#define	is_blue_color(color)   ( ((color) & 0x00ffffff) == 0xff )
#define	get_bitmap_pixel(x, y)   pixel[(y)*(width) + (x)]

Typedefs
typedef struct node	node

Functions
static	GpStatus (WINAPI *pGdipGraphicsSetAbort)(GpGraphics *
static void	set_rect_empty (RectF *rc)
static REAL	units_to_pixels (REAL units, GpUnit unit, REAL dpi)
static REAL	pixels_to_units (REAL pixels, GpUnit unit, REAL dpi)
static REAL	units_scale (GpUnit from, GpUnit to, REAL dpi)
static GpGraphics *	create_graphics (REAL res_x, REAL res_y, GpUnit unit, REAL scale, GpImage **image)
static void	test_constructor_destructor (void)
static void	log_state (GraphicsState data, node **log)
static void	check_no_duplicates (node *log)
static void	test_save_restore (void)
static void	test_GdipFillClosedCurve2 (void)
static void	test_GdipFillClosedCurve2I (void)
static void	test_GdipDrawArc (void)
static void	test_GdipDrawArcI (void)
static void	test_BeginContainer2 (void)
static void	test_GdipDrawBezierI (void)
static void	test_GdipDrawCurve3 (void)
static void	test_GdipDrawCurve3I (void)
static void	test_GdipDrawCurve2 (void)
static void	test_GdipDrawCurve2I (void)
static void	test_GdipDrawCurve (void)
static void	test_GdipDrawCurveI (void)
static void	test_GdipDrawLineI (void)
static void	test_GdipDrawImagePointsRect (void)
static void	test_GdipDrawLinesI (void)
static void	test_GdipFillClosedCurve (void)
static void	test_GdipFillClosedCurveI (void)
static void	test_GdipFillPath (void)
static void	test_Get_Release_DC (void)
static void	test_transformpoints (void)
static void	test_get_set_clip (void)
static void	test_clip_xform (void)
static void	test_isempty (void)
static void	test_clear (void)
static void	test_textcontrast (void)
static void	test_GdipDrawString (void)
static void	test_GdipGetVisibleClipBounds_screen (void)
static void	test_GdipGetVisibleClipBounds_window (void)
static void	test_GdipGetVisibleClipBounds (void)
static void	test_fromMemoryBitmap (void)
static void	test_GdipIsVisiblePoint (void)
static void	test_GdipIsVisibleRect (void)
static void	test_GdipGetNearestColor (void)
static void	test_string_functions (void)
static void	test_get_set_interpolation (void)
static void	test_get_set_textrenderinghint (void)
static void	test_getdc_scaled (void)
static void	test_GdipMeasureString (void)
static void	test_transform (void)
static void	test_pen_thickness (void)
static void	test_font_height_scaling (void)
static void	test_measure_string (void)
static void	test_measured_extra_space (void)
static void	test_alpha_hdc (void)
static void	test_bitmapfromgraphics (void)
static void	test_clipping (void)
static void	test_clipping_2 (void)
static void	test_GdipFillRectangles (void)
static void	test_GdipGetVisibleClipBounds_memoryDC (void)
static void	test_container_rects (void)
static void	test_GdipGraphicsSetAbort (void)
static DWORD *	GetBitmapPixelBuffer (HDC hdc, HBITMAP hbmp, int width, int height)
static void	test_GdipFillRectanglesOnMemoryDCSolidBrush (void)
static void	test_GdipFillRectanglesOnMemoryDCTextureBrush (void)
static void	test_GdipFillRectanglesOnBitmapTextureBrush (void)
static void	test_GdipDrawImagePointsRectOnMemoryDC (void)
static void	test_cliphrgn_transform (void)
static void	test_hdc_caching (void)
	START_TEST (graphics)

Variables
static GdiplusAbort *static const REAL	mm_per_inch = 25.4
static const REAL	point_per_inch = 72.0
static HWND	hwnd

Macro Definition Documentation

BLUE_COLOR

#define BLUE_COLOR   (0xff0000ff)

Definition at line 6349 of file graphics.c.

expect

#define expect	(		expected,
			got
	)		ok((got) == (expected), "Expected %d, got %d\n", (INT)(expected), (INT)(got))

Definition at line 28 of file graphics.c.

expectf

#define expectf	(		expected,
			got
	)		expectf_((expected), (got), 0.001)

Definition at line 30 of file graphics.c.

expectf_

#define expectf_	(		expected,
			got,
			precision
	)		ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))

Definition at line 29 of file graphics.c.

get_bitmap_pixel

#define get_bitmap_pixel	(		x,
			y
	)		pixel[(y)*(width) + (x)]

Definition at line 6351 of file graphics.c.

is_blue_color

#define is_blue_color

(

color

)

( ((color) & 0x00ffffff) == 0xff )

Definition at line 6350 of file graphics.c.

Typedef Documentation

node

typedef struct node node

Function Documentation

check_no_duplicates()

static void check_no_duplicates ( node *  log )

static

Definition at line 186 of file graphics.c.

{
    INT dups = 0;
    node * temp = NULL;
    node * temp2 = NULL;
    node * orig = log;
 
    if(!log)
        goto end;
 
    do{
        temp = log;
        while((temp = temp->next)){
            if(log->data == temp->data){
                dups++;
                break;
            }
            if(dups > 0)
                break;
        }
    }while((log = log->next));
 
    temp = orig;
    do{
        temp2 = temp->next;
        HeapFree(GetProcessHeap(), 0, temp);
        temp = temp2;
    }while(temp);
 
end:
    expect(0, dups);
}

Referenced by test_save_restore().

create_graphics()

static GpGraphics * create_graphics ( REAL  res_x, REAL  res_y, GpUnit  unit, REAL  scale, GpImage **  image  )

static

Definition at line 96 of file graphics.c.

{
    GpStatus status;
    union
    {
        GpBitmap *bitmap;
        GpImage *image;
    } u;
    GpGraphics *graphics = NULL;
    REAL res;
 
    status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, NULL, &u.bitmap);
    expect(Ok, status);
 
    status = GdipBitmapSetResolution(u.bitmap, res_x, res_y);
    expect(Ok, status);
    status = GdipGetImageHorizontalResolution(u.image, &res);
    expect(Ok, status);
    expectf(res_x, res);
    status = GdipGetImageVerticalResolution(u.image, &res);
    expect(Ok, status);
    expectf(res_y, res);
 
    status = GdipGetImageGraphicsContext(u.image, &graphics);
    expect(Ok, status);
 
    *image = u.image;
 
    status = GdipGetDpiX(graphics, &res);
    expect(Ok, status);
    expectf(res_x, res);
    status = GdipGetDpiY(graphics, &res);
    expect(Ok, status);
    expectf(res_y, res);
 
    status = GdipSetPageUnit(graphics, unit);
    expect(Ok, status);
    status = GdipSetPageScale(graphics, scale);
    expect(Ok, status);
 
    return graphics;
}

Referenced by test_GdipMeasureString(), and test_transform().

GetBitmapPixelBuffer()

static DWORD * GetBitmapPixelBuffer ( HDC  hdc, HBITMAP  hbmp, int  width, int  height  )

static

Definition at line 6352 of file graphics.c.

{
    BITMAPINFOHEADER bi;
    UINT lines = 0;
    DWORD *buffer = (DWORD *)GdipAlloc(width*height*4);
 
    bi.biSize = sizeof(BITMAPINFOHEADER);
    bi.biWidth = width;
    bi.biHeight = -height; /*very Important, set negative, indicating a top-down DIB*/
    bi.biPlanes = 1;
    bi.biBitCount = 32;
    bi.biCompression = BI_RGB;
    bi.biSizeImage = 0;
    bi.biXPelsPerMeter = 0;
    bi.biYPelsPerMeter = 0;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;
 
    lines = GetDIBits(hdc, hbmp, 0, height, buffer, (BITMAPINFO *)&bi, DIB_RGB_COLORS);
    ok(lines == height, "Expected GetDIBits:%p,%d->%d,%d\n", buffer, height, lines, GetLastError());
 
    return buffer;
}

Referenced by test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), and test_GdipFillRectanglesOnMemoryDCTextureBrush().

GpStatus()

static GpStatus ( WINAPI *  pGdipGraphicsSetAbort )

static

log_state()

static void log_state ( GraphicsState  data, node **  log  )

static

Definition at line 176 of file graphics.c.

{
    node * new_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(node));
 
    new_entry->data = data;
    new_entry->next = *log;
    *log = new_entry;
}

Referenced by test_save_restore().

pixels_to_units()

static REAL pixels_to_units ( REAL  pixels, GpUnit  unit, REAL  dpi  )

static

Definition at line 69 of file graphics.c.

{
    switch (unit)
    {
    case UnitPixel:
    case UnitDisplay:
        return pixels;
    case UnitPoint:
        return pixels * point_per_inch / dpi;
    case UnitInch:
        return pixels / dpi;
    case UnitDocument:
        return pixels * 300.0 / dpi;
    case UnitMillimeter:
        return pixels * mm_per_inch / dpi;
    default:
        ok(0, "Unsupported unit: %d\n", unit);
        return 0;
    }
}

Referenced by test_font_height_scaling(), test_GdipMeasureString(), and units_scale().

set_rect_empty()

static void set_rect_empty ( RectF *  rc )

static

Definition at line 38 of file graphics.c.

{
    rc->X = 0.0;
    rc->Y = 0.0;
    rc->Width = 0.0;
    rc->Height = 0.0;
}

Referenced by test_font_height_scaling(), test_GdipMeasureString(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

START_TEST()

START_TEST

(

graphics

)

Definition at line 6795 of file graphics.c.

{
    struct GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    WNDCLASSA class;
    HMODULE gdiplus_mod = GetModuleHandleA("gdiplus.dll");
    HMODULE hmsvcrt;
    int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
 
    /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
    hmsvcrt = LoadLibraryA("msvcrt");
    _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
    if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
 
    pGdipGraphicsSetAbort = (void*)GetProcAddress(gdiplus_mod, "GdipGraphicsSetAbort");
 
    memset( &class, 0, sizeof(class) );
    class.lpszClassName = "gdiplus_test";
    class.style = CS_HREDRAW | CS_VREDRAW;
    class.lpfnWndProc = DefWindowProcA;
    class.hInstance = GetModuleHandleA(0);
    class.hIcon = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
    class.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    class.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    RegisterClassA( &class );
    hwnd = CreateWindowA( "gdiplus_test", "graphics test", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                          CW_USEDEFAULT, CW_USEDEFAULT, 200, 200, 0, 0, GetModuleHandleA(0), 0 );
    ok(hwnd != NULL, "Expected window to be created\n");
 
    gdiplusStartupInput.GdiplusVersion              = 1;
    gdiplusStartupInput.DebugEventCallback          = NULL;
    gdiplusStartupInput.SuppressBackgroundThread    = 0;
    gdiplusStartupInput.SuppressExternalCodecs      = 0;
 
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
    test_clipping();
    test_clipping_2();
    test_measured_extra_space();
    test_measure_string();
    test_font_height_scaling();
    test_transform();
    test_pen_thickness();
    test_GdipMeasureString();
    test_constructor_destructor();
    test_save_restore();
    test_GdipFillClosedCurve2();
    test_GdipFillClosedCurve2I();
    test_GdipDrawBezierI();
    test_GdipDrawArc();
    test_GdipDrawArcI();
    test_GdipDrawCurve();
    test_GdipDrawCurveI();
    test_GdipDrawCurve2();
    test_GdipDrawCurve2I();
    test_GdipDrawCurve3();
    test_GdipDrawCurve3I();
    test_GdipDrawLineI();
    test_GdipDrawLinesI();
    test_GdipDrawImagePointsRect();
    test_GdipFillClosedCurve();
    test_GdipFillClosedCurveI();
    test_GdipFillPath();
    test_GdipDrawString();
    test_GdipGetNearestColor();
    test_GdipGetVisibleClipBounds();
    test_GdipIsVisiblePoint();
    test_GdipIsVisibleRect();
    test_Get_Release_DC();
    test_BeginContainer2();
    test_transformpoints();
    test_get_set_clip();
    test_clip_xform();
    test_isempty();
    test_clear();
    test_textcontrast();
    test_fromMemoryBitmap();
    test_string_functions();
    test_get_set_interpolation();
    test_get_set_textrenderinghint();
    test_getdc_scaled();
    test_alpha_hdc();
    test_bitmapfromgraphics();
    test_GdipFillRectangles();
    test_GdipGetVisibleClipBounds_memoryDC();
    test_GdipFillRectanglesOnMemoryDCSolidBrush();
    test_GdipFillRectanglesOnMemoryDCTextureBrush();
    test_GdipFillRectanglesOnBitmapTextureBrush();
    test_GdipDrawImagePointsRectOnMemoryDC();
    test_container_rects();
    test_GdipGraphicsSetAbort();
    test_cliphrgn_transform();
    test_hdc_caching();
 
    GdiplusShutdown(gdiplusToken);
    DestroyWindow( hwnd );
}

test_alpha_hdc()

static void test_alpha_hdc ( void  )

static

Definition at line 4941 of file graphics.c.

{
    GpStatus status;
    HDC hdc, gp_hdc;
    HBITMAP hbm, old_hbm;
    GpGraphics *graphics;
    ULONG *bits;
    BITMAPINFO bmi;
    GpRectF bounds;
    COLORREF colorref;
 
    hdc = CreateCompatibleDC(0);
    ok(hdc != NULL, "CreateCompatibleDC failed\n");
    bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
    bmi.bmiHeader.biHeight = 5;
    bmi.bmiHeader.biWidth = 5;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biClrUsed = 0;
 
    hbm = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hbm != NULL, "CreateDIBSection failed\n");
 
    old_hbm = SelectObject(hdc, hbm);
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    status = GdipGetVisibleClipBounds(graphics, &bounds);
    expect(Ok, status);
    expectf(0.0, bounds.X);
    expectf(0.0, bounds.Y);
    expectf(5.0, bounds.Width);
    expectf(5.0, bounds.Height);
 
    bits[0] = 0xdeadbeef;
 
    status = GdipGraphicsClear(graphics, 0xffaaaaaa);
    expect(Ok, status);
 
    expect(0xffaaaaaa, bits[0]);
 
    bits[0] = 0xdeadbeef;
 
    status = GdipGetDC(graphics, &gp_hdc);
    expect(Ok, status);
 
    colorref = GetPixel(gp_hdc, 0, 4);
    expect(0xefbead, colorref);
 
    SetPixel(gp_hdc, 0, 4, 0xffffff);
 
    expect(0xffffff, bits[0]);
 
    status = GdipReleaseDC(graphics, gp_hdc);
    expect(Ok, status);
 
    SelectObject(hdc, old_hbm);
 
    bits[0] = 0xdeadbeef;
 
    status = GdipGraphicsClear(graphics, 0xffbbbbbb);
    expect(Ok, status);
 
    todo_wine expect(0xffbbbbbb, bits[0]);
 
    GdipDeleteGraphics(graphics);
 
    DeleteObject(hbm);
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_BeginContainer2()

static void test_BeginContainer2 ( void  )

static

Definition at line 619 of file graphics.c.

{
    GpMatrix *transform;
    GpRectF clip;
    REAL defClip[] = {5, 10, 15, 20};
    REAL elems[6], defTrans[] = {1, 2, 3, 4, 5, 6};
    GraphicsContainer cont1, cont2, cont3, cont4;
    CompositingQuality compqual, defCompqual = CompositingQualityHighSpeed;
    CompositingMode compmode, defCompmode = CompositingModeSourceOver;
    InterpolationMode interp, defInterp = InterpolationModeHighQualityBicubic;
    REAL scale, defScale = 17;
    GpUnit unit, defUnit = UnitPixel;
    PixelOffsetMode offsetmode, defOffsetmode = PixelOffsetModeHighSpeed;
    SmoothingMode smoothmode, defSmoothmode = SmoothingModeAntiAlias;
    UINT contrast, defContrast = 5;
    TextRenderingHint texthint, defTexthint = TextRenderingHintAntiAlias;
 
    GpStatus status;
    GpGraphics *graphics = NULL;
    HDC hdc = GetDC( hwnd );
 
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    /* null graphics, null container */
    status = GdipBeginContainer2(NULL, &cont1);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer2(graphics, NULL);
    expect(InvalidParameter, status);
 
    status = GdipEndContainer(NULL, cont1);
    expect(InvalidParameter, status);
 
    /* test all quality-related values */
    GdipSetCompositingMode(graphics, defCompmode);
    GdipSetCompositingQuality(graphics, defCompqual);
    GdipSetInterpolationMode(graphics, defInterp);
    GdipSetPageScale(graphics, defScale);
    GdipSetPageUnit(graphics, defUnit);
    GdipSetPixelOffsetMode(graphics, defOffsetmode);
    GdipSetSmoothingMode(graphics, defSmoothmode);
    GdipSetTextContrast(graphics, defContrast);
    GdipSetTextRenderingHint(graphics, defTexthint);
 
    status = GdipBeginContainer2(graphics, &cont1);
    expect(Ok, status);
 
    GdipSetCompositingMode(graphics, CompositingModeSourceCopy);
    GdipSetCompositingQuality(graphics, CompositingQualityHighQuality);
    GdipSetInterpolationMode(graphics, InterpolationModeBilinear);
    GdipSetPageScale(graphics, 10);
    GdipSetPageUnit(graphics, UnitDocument);
    GdipSetPixelOffsetMode(graphics, PixelOffsetModeHalf);
    GdipSetSmoothingMode(graphics, SmoothingModeNone);
    GdipSetTextContrast(graphics, 7);
    GdipSetTextRenderingHint(graphics, TextRenderingHintClearTypeGridFit);
 
    status = GdipEndContainer(graphics, cont1);
    expect(Ok, status);
 
    GdipGetCompositingMode(graphics, &compmode);
    ok(defCompmode == compmode, "Expected Compositing Mode to be restored to %d, got %d\n", defCompmode, compmode);
 
    GdipGetCompositingQuality(graphics, &compqual);
    ok(defCompqual == compqual, "Expected Compositing Quality to be restored to %d, got %d\n", defCompqual, compqual);
 
    GdipGetInterpolationMode(graphics, &interp);
    ok(defInterp == interp, "Expected Interpolation Mode to be restored to %d, got %d\n", defInterp, interp);
 
    GdipGetPageScale(graphics, &scale);
    ok(fabs(defScale - scale) < 0.0001, "Expected Page Scale to be restored to %f, got %f\n", defScale, scale);
 
    GdipGetPageUnit(graphics, &unit);
    ok(defUnit == unit, "Expected Page Unit to be restored to %d, got %d\n", defUnit, unit);
 
    GdipGetPixelOffsetMode(graphics, &offsetmode);
    ok(defOffsetmode == offsetmode, "Expected Pixel Offset Mode to be restored to %d, got %d\n", defOffsetmode, offsetmode);
 
    GdipGetSmoothingMode(graphics, &smoothmode);
    ok(defSmoothmode == smoothmode, "Expected Smoothing Mode to be restored to %d, got %d\n", defSmoothmode, smoothmode);
 
    GdipGetTextContrast(graphics, &contrast);
    ok(defContrast == contrast, "Expected Text Contrast to be restored to %d, got %d\n", defContrast, contrast);
 
    status = GdipGetTextRenderingHint(graphics, &texthint);
    expect(Ok, status);
    ok(defTexthint == texthint, "Expected Text Hint to be restored to %d, got %d\n", defTexthint, texthint);
 
    /* test world transform */
    status = GdipBeginContainer2(graphics, &cont1);
    expect(Ok, status);
 
    status = GdipCreateMatrix2(defTrans[0], defTrans[1], defTrans[2], defTrans[3],
            defTrans[4], defTrans[5], &transform);
    expect(Ok, status);
    GdipSetWorldTransform(graphics, transform);
    GdipDeleteMatrix(transform);
    transform = NULL;
 
    status = GdipBeginContainer2(graphics, &cont2);
    expect(Ok, status);
 
    status = GdipCreateMatrix2(10, 20, 30, 40, 50, 60, &transform);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, transform);
    expect(Ok, status);
    GdipDeleteMatrix(transform);
    transform = NULL;
 
    status = GdipEndContainer(graphics, cont2);
    expect(Ok, status);
 
    status = GdipCreateMatrix(&transform);
    expect(Ok, status);
    status = GdipGetWorldTransform(graphics, transform);
    expect(Ok, status);
    status = GdipGetMatrixElements(transform, elems);
    expect(Ok, status);
    ok(fabs(defTrans[0] - elems[0]) < 0.0001 &&
            fabs(defTrans[1] - elems[1]) < 0.0001 &&
            fabs(defTrans[2] - elems[2]) < 0.0001 &&
            fabs(defTrans[3] - elems[3]) < 0.0001 &&
            fabs(defTrans[4] - elems[4]) < 0.0001 &&
            fabs(defTrans[5] - elems[5]) < 0.0001,
            "Expected World Transform Matrix to be restored to [%f, %f, %f, %f, %f, %f], got [%f, %f, %f, %f, %f, %f]\n",
            defTrans[0], defTrans[1], defTrans[2], defTrans[3], defTrans[4], defTrans[5],
            elems[0], elems[1], elems[2], elems[3], elems[4], elems[5]);
    GdipDeleteMatrix(transform);
    transform = NULL;
 
    status = GdipEndContainer(graphics, cont1);
    expect(Ok, status);
 
    /* test clipping */
    status = GdipBeginContainer2(graphics, &cont1);
    expect(Ok, status);
 
    status = GdipSetClipRect(graphics, defClip[0], defClip[1], defClip[2], defClip[3], CombineModeReplace);
    expect(Ok, status);
 
    status = GdipBeginContainer2(graphics, &cont2);
    expect(Ok, status);
 
    status = GdipSetClipRect(graphics, 2, 4, 6, 8, CombineModeReplace);
    expect(Ok, status);
 
    status = GdipEndContainer(graphics, cont2);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &clip);
    expect(Ok, status);
 
    ok(fabs(defClip[0] - clip.X) < 0.0001 &&
            fabs(defClip[1] - clip.Y) < 0.0001 &&
            fabs(defClip[2] - clip.Width) < 0.0001 &&
            fabs(defClip[3] - clip.Height) < 0.0001,
            "Expected Clipping Rectangle to be restored to [%f, %f, %f, %f], got [%f, %f, %f, %f]\n",
            defClip[0], defClip[1], defClip[2], defClip[3],
            clip.X, clip.Y, clip.Width, clip.Height);
 
    status = GdipEndContainer(graphics, cont1);
    expect(Ok, status);
 
    /* nesting */
    status = GdipBeginContainer2(graphics, &cont1);
    expect(Ok, status);
 
    status = GdipBeginContainer2(graphics, &cont2);
    expect(Ok, status);
 
    status = GdipBeginContainer2(graphics, &cont3);
    expect(Ok, status);
 
    status = GdipEndContainer(graphics, cont3);
    expect(Ok, status);
 
    status = GdipBeginContainer2(graphics, &cont4);
    expect(Ok, status);
 
    status = GdipEndContainer(graphics, cont4);
    expect(Ok, status);
 
    /* skip cont2 */
    status = GdipEndContainer(graphics, cont1);
    expect(Ok, status);
 
    /* end an already-ended container */
    status = GdipEndContainer(graphics, cont1);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_bitmapfromgraphics()

static void test_bitmapfromgraphics ( void  )

static

Definition at line 5014 of file graphics.c.

{
    GpStatus stat;
    GpGraphics *graphics = NULL;
    HDC hdc = GetDC( hwnd );
    GpBitmap *bitmap = NULL;
    PixelFormat format;
    REAL imageres, graphicsres;
    UINT width, height;
 
    stat = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, stat);
 
    stat = GdipCreateBitmapFromGraphics(12, 13, NULL, &bitmap);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromGraphics(12, 13, graphics, NULL);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateBitmapFromGraphics(12, 13, graphics, &bitmap);
    expect(Ok, stat);
 
    stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
    expect(Ok, stat);
    expect(PixelFormat32bppPARGB, format);
 
    stat = GdipGetDpiX(graphics, &graphicsres);
    expect(Ok, stat);
 
    stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &imageres);
    expect(Ok, stat);
    expectf(graphicsres, imageres);
 
    stat = GdipGetDpiY(graphics, &graphicsres);
    expect(Ok, stat);
 
    stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &imageres);
    expect(Ok, stat);
    expectf(graphicsres, imageres);
 
    stat = GdipGetImageWidth((GpImage*)bitmap, &width);
    expect(Ok, stat);
    expect(12, width);
 
    stat = GdipGetImageHeight((GpImage*)bitmap, &height);
    expect(Ok, stat);
    expect(13, height);
 
    GdipDeleteGraphics(graphics);
    GdipDisposeImage((GpImage*)bitmap);
}

Referenced by START_TEST().

test_clear()

static void test_clear ( void  )

static

Definition at line 2241 of file graphics.c.

{
    GpStatus status;
 
    status = GdipGraphicsClear(NULL, 0xdeadbeef);
    expect(InvalidParameter, status);
}

Referenced by START_TEST().

test_clip_xform()

static void test_clip_xform ( void  )

static

Definition at line 2115 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    HDC hdc = GetDC( hwnd );
    GpRegion *clip;
    COLORREF color;
    UINT region_data_size;
    struct {
        DWORD size;
        DWORD checksum;
        DWORD magic;
        DWORD num_children;
        DWORD element_type;
        REAL x;
        REAL y;
        REAL width;
        REAL height;
    } region_data;
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    status = GdipCreateRegion(&clip);
    expect(Ok, status);
 
    status = GdipGraphicsClear(graphics, 0xff000000);
    expect(Ok, status);
 
    status = GdipSetClipRect(graphics, 10, 10, -10, -10, CombineModeReplace);
    expect(Ok, status);
    status = GdipGetClip(graphics, clip);
    expect(Ok, status);
    status = GdipGetRegionData(clip, (BYTE*)&region_data, sizeof(region_data), &region_data_size);
    expect(Ok, status);
    expect(36, region_data_size);
    expect(28, region_data.size);
    expect(0, region_data.num_children);
    expect(0x10000000 /* RegionDataRect */, region_data.element_type);
    expectf(0.0, region_data.x);
    expectf(0.0, region_data.y);
    expectf(10.0, region_data.width);
    expectf(10.0, region_data.height);
 
    /* No effect with negative width/height */
    status = GdipGraphicsClear(graphics, 0xffff0000);
    expect(Ok, status);
    color = GetPixel(hdc, 5, 5);
    expect(0, color);
 
    status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipGraphicsClear(graphics, 0xffff0000);
    expect(Ok, status);
    color = GetPixel(hdc, 5, 5);
    expect(0, color);
 
    status = GdipResetClip(graphics);
    expect(Ok, status);
    status = GdipResetWorldTransform(graphics);
    expect(Ok, status);
    status = GdipGraphicsClear(graphics, 0xff000000);
    expect(Ok, status);
 
    status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipSetClipRect(graphics, 5, 5, -5, -5, CombineModeReplace);
    expect(Ok, status);
    status = GdipGetClip(graphics, clip);
    expect(Ok, status);
    status = GdipGetRegionData(clip, (BYTE*)&region_data, sizeof(region_data), &region_data_size);
    expect(Ok, status);
    expect(36, region_data_size);
    expect(28, region_data.size);
    expect(0, region_data.num_children);
    expect(0x10000000 /* RegionDataRect */, region_data.element_type);
    expectf(0.0, region_data.x);
    expectf(0.0, region_data.y);
    expectf(5.0, region_data.width);
    expectf(5.0, region_data.height);
 
    status = GdipGraphicsClear(graphics, 0xffff0000);
    expect(Ok, status);
    color = GetPixel(hdc, 5, 5);
    expect(0xff, color);
 
    GdipDeleteGraphics(graphics);
    GdipDeleteRegion(clip);
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_cliphrgn_transform()

static void test_cliphrgn_transform ( void  )

static

Definition at line 6681 of file graphics.c.

{
    HDC hdc;
    GpStatus status;
    GpGraphics *graphics;
    HRGN rgn;
    RectF rectf;
    BOOL res;
 
    hdc = GetDC(hwnd);
 
    SetViewportOrgEx(hdc, 10, 10, NULL);
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    rgn = CreateRectRgn(0, 0, 100, 100);
 
    status = GdipSetClipHrgn(graphics, rgn, CombineModeReplace);
    expect(Ok, status);
 
    status = GdipGetVisibleClipBounds(graphics, &rectf);
    expect(Ok, status);
    expectf(-10.0, rectf.X);
    expectf(-10.0, rectf.Y);
    expectf(100.0, rectf.Width);
    expectf(100.0, rectf.Height);
 
    status = GdipIsVisiblePoint(graphics, 95, 95, &res);
    expect(Ok, status);
    expect(FALSE, res);
 
    status = GdipIsVisiblePoint(graphics, -5, -5, &res);
    expect(Ok, status);
    expect(TRUE, res);
 
    DeleteObject(rgn);
 
    GdipDeleteGraphics(graphics);
 
    SetViewportOrgEx(hdc, 0, 0, NULL);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_clipping()

static void test_clipping ( void  )

static

Definition at line 5066 of file graphics.c.

{
    HDC hdc;
    GpStatus status;
    GpGraphics *graphics;
    GpRegion *region, *region100x100;
    GpMatrix *matrix;
    GpRectF rect;
    GpPointF ptf[4];
    GpUnit unit;
    HRGN hrgn;
    int ret;
    RECT rc;
 
    hdc = CreateCompatibleDC(0);
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    status = GdipGetPageUnit(graphics, &unit);
    expect(Ok, status);
    expect(UnitDisplay, unit);
 
    status = GdipCreateRegion(&region);
    expect(Ok, status);
    status = GdipSetEmpty(region);
    expect(Ok, status);
 
    status = GdipCreateRegion(&region100x100);
    expect(Ok, status);
    status = GdipSetEmpty(region100x100);
    expect(Ok, status);
 
    rect.X = rect.Y = 100.0;
    rect.Width = rect.Height = 100.0;
    status = GdipCombineRegionRect(region100x100, &rect, CombineModeUnion);
    expect(Ok, status);
    status = GdipSetClipRegion(graphics, region100x100, CombineModeReplace);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    /* Clip region does not account for changes to gdi32 transform */
    SetViewportOrgEx(hdc, 10, 10, NULL);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    SetViewportOrgEx(hdc, 0, 0, NULL);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
       "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    status = GdipCreateMatrix(&matrix);
    expect(Ok, status);
    status = GdipScaleMatrix(matrix, 2.0, 4.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipTranslateMatrix(matrix, 10.0, 20.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
       "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
       "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45,
       "expected 45,20-95,45, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0,
       "expected 45.0,20.0-95.0,45.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
       "expected 210,420-410,820, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 210.0;
    ptf[0].Y = 420.0;
    ptf[1].X = 410.0;
    ptf[1].Y = 820.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
       "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    status = GdipSetPageScale(graphics, 2.0);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
       "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
       "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45,
       "expected 45,20-95,45, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0,
       "expected 45.0,20.0-95.0,45.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
       "expected 210,420-410,820, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 210.0;
    ptf[0].Y = 420.0;
    ptf[1].X = 410.0;
    ptf[1].Y = 820.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
       "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    GdipSetPageUnit(graphics, UnitPoint);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    ok((rect.X == 13.75 && rect.Y == 4.375 && rect.Width == 18.75 && rect.Height == 9.375) ||
       /* rounding under Wine is slightly different */
       (rect.X == 14.0 && rect.Y == 4.0 && rect.Width == 19.0 && rect.Height == 10.0) /* Wine */ ||
       broken(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0) /* before Win7 */,
       "expected 13.75,4.375-18.75,9.375, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
    ok((rect.X == 13.75 && rect.Y == 4.375 && rect.Width == 18.75 && rect.Height == 9.375) ||
       /* rounding under Wine is slightly different */
       (rect.X == 14.0 && rect.Y == 4.0 && rect.Width == 19.0 && rect.Height == 10.0) /* Wine */ ||
       broken(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0) /* before Win7 */,
       "expected 13.75,4.375-18.75,9.375, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
       "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 14 && rc.top == 5 && rc.right == 33 && rc.bottom == 14) ||
       /* rounding under Wine is slightly different */
       (rc.left == 14 && rc.top == 4 && rc.right == 33 && rc.bottom == 14) /* Wine */ ||
       broken(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45) /* before Win7 */,
       "expected 14,5-33,14, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
      broken(rc.left == 267 && rc.top == 267 && rc.right == 534 && rc.bottom == 534) /* before Win7 */,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    ok((ptf[0].X == 13.75 && ptf[0].Y == 4.375 && ptf[1].X == 32.5 && ptf[1].Y == 13.75) ||
       broken(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0) /* before Win7 */,
       "expected 13.75,4.375-32.5,13.75, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 560 && rc.top == 1120 && rc.right == 1094 && rc.bottom == 2187) ||
       /* rounding under Wine is slightly different */
       (rc.left == 560 && rc.top == 1120 && rc.right == 1093 && rc.bottom == 2187) /* Wine */,
       "expected 560,1120-1094,2187, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 560.0;
    ptf[0].Y = 1120.0;
    ptf[1].X = 1094.0;
    ptf[1].Y = 2187.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 100.0) < 0.001)
    {
        expectf(100.0, ptf[0].X);
        expectf(100.0, ptf[0].Y);
        expectf(200.125, ptf[1].X);
        expectf(200.03125, ptf[1].Y);
    }
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 275.0) < 0.001), "expected 275.0, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 275.0) < 0.001), "expected 275.0, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 542.0) < 0.001), "expected 542.0, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 541.75) < 0.001), "expected 541.75, got %f\n", ptf[1].Y);
    }
 
    status = GdipTransformRegion(region100x100, matrix);
    expect(Ok, status);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
       "expected 210.0,420.0-200.0,400.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
       "expected 210,420-410,820, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 1147 && rc.top == 4534 && rc.right == 2214 && rc.bottom == 8800) ||
       /* rounding under Wine is slightly different */
       (rc.left == 1147 && rc.top == 4533 && rc.right == 2213 && rc.bottom == 8800) /* Wine */,
       "expected 1147,4534-2214,8800, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 1147.0;
    ptf[0].Y = 4534.0;
    ptf[1].X = 2214.0;
    ptf[1].Y = 8800.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 210.0625) < 0.001)
    {
        expectf(210.0625, ptf[0].X);
        expectf(420.0625, ptf[0].Y);
        expectf(410.125, ptf[1].X);
        expectf(820.0, ptf[1].Y);
    }
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 568.5) < 0.001), "expected 568.5, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 1128.5) < 0.001), "expected 1128.5, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 1102.0) < 0.001), "expected 1102.0, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 2195.0) < 0.001), "expected 2195.0, got %f\n", ptf[1].Y);
    }
 
    status = GdipRotateMatrix(matrix, 30.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    expectf_(20.612978, rect.X, 1.0);
    expectf_(-6.256012, rect.Y, 1.5);
    expectf_(25.612978, rect.Width, 1.0);
    expectf_(12.806489, rect.Height, 1.0);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
   /* rounding under Wine is slightly different */
    expectf_(20.612978, rect.X, 1.0);
    expectf_(-6.256012, rect.Y, 1.5);
    expectf_(25.612978, rect.Width, 1.0);
    expectf_(12.806489, rect.Height, 1.0);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
       "expected 210.0,420.0-200.0,400.0, got %f,%f-%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == 22 && rc.top == -6 && rc.right == 46 && rc.bottom == 7) ||
       /* rounding under Wine is slightly different */
       (rc.left == 21 && rc.top == -5 && rc.right == 46 && rc.bottom == 7) /* Wine */,
       "expected (22,-6)-(46,7), got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    ptf[2].X = 200.0;
    ptf[2].Y = 100.0;
    ptf[3].X = 100.0;
    ptf[3].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(20.612978, ptf[0].X);
    expectf(-1.568512, ptf[0].Y);
    expectf(46.225956, ptf[1].X);
    expectf(1.862977, ptf[1].Y);
    expectf(36.850956, ptf[2].X);
    expectf(-6.256012, ptf[2].Y);
    expectf(29.987980, ptf[3].X);
    expectf(6.550478, ptf[3].Y);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
       "expected 210,420-410,820, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == -3406 && rc.top == 4500 && rc.right == -350 && rc.bottom == 8728) ||
       /* rounding under Wine is slightly different */
       (rc.left == -3407 && rc.top == 4500 && rc.right == -350 && rc.bottom == 8728) /* Wine */,
       "expected (-3406,4500)-(-350,8728), got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = -3406.0;
    ptf[0].Y = 4500.0;
    ptf[1].X = -350.0;
    ptf[1].Y = 8728.0;
    ptf[2].X = -350.0;
    ptf[2].Y = 4500.0;
    ptf[3].X = -3406.0;
    ptf[3].Y = 8728.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(-136.190491, ptf[0].X);
    expectf(520.010742, ptf[0].Y);
    expectf(756.417175, ptf[1].X);
    expectf(720.031616, ptf[1].Y);
    expectf(360.042114, ptf[2].X);
    expectf(376.760742, ptf[2].Y);
    expectf(260.184570, ptf[3].X);
    expectf(863.281616, ptf[3].Y);
 
    status = GdipRotateMatrix(matrix, -90.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
 
    status = GdipGetClipBounds(graphics, &rect);
    expect(Ok, status);
    expectf_(-28.100956, rect.X, 1.0);
    expectf_(7.806488, rect.Y, 1.5);
    expectf_(25.612978, rect.Width, 1.0);
    expectf_(12.806489, rect.Height, 1.0);
 
    status = GdipSetEmpty(region);
    expect(Ok, status);
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
   /* rounding under Wine is slightly different */
    expectf_(-28.100956, rect.X, 1.0);
    expectf_(7.806488, rect.Y, 1.5);
    expectf_(25.612978, rect.Width, 1.0);
    expectf_(12.806489, rect.Height, 1.0);
 
    status = GdipGetRegionBounds(region100x100, graphics, &rect);
    expect(Ok, status);
    ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
       "expected 210.0,420.0-200.0,400.0, got %f,%f-%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == -27 && rc.top == 8 && rc.right == -2 && rc.bottom == 21) ||
       /* rounding under Wine is slightly different */
       (rc.left == -28 && rc.top == 9 && rc.right == -2 && rc.bottom == 21) /* Wine */,
       "expected (-27,8)-(-2,21), got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    ptf[2].X = 200.0;
    ptf[2].Y = 100.0;
    ptf[3].X = 100.0;
    ptf[3].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(-11.862979, ptf[0].X);
    expectf(7.806488, ptf[0].Y);
    expectf(-18.725958, ptf[1].X);
    expectf(20.612976, ptf[1].Y);
    expectf(-2.487981, ptf[2].X);
    expectf(15.925477, ptf[2].Y);
    expectf(-28.100956, ptf[3].X);
    expectf(12.493987, ptf[3].Y);
 
    status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
       "expected 210,420-410,820, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == 4500 && rc.top == 351 && rc.right == 8728 && rc.bottom == 3407) ||
       /* rounding under Wine is slightly different */
       (rc.left == 4499 && rc.top == 351 && rc.right == 8728 && rc.bottom == 3407) /* Wine */,
       "expected (4500,351)-(8728,3407), got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = -3406.0;
    ptf[0].Y = 4500.0;
    ptf[1].X = -350.0;
    ptf[1].Y = 8728.0;
    ptf[2].X = -350.0;
    ptf[2].Y = 4500.0;
    ptf[3].X = -3406.0;
    ptf[3].Y = 8728.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(-1055.021484, ptf[0].X);
    expectf(-70.595329, ptf[0].Y);
    expectf(-1455.063232, ptf[1].X);
    expectf(375.708435, ptf[1].Y);
    expectf(-768.521484, ptf[2].X);
    expectf(177.520981, ptf[2].Y);
    expectf(-1741.563110, ptf[3].X);
    expectf(127.592125, ptf[3].Y);
 
    GdipDeleteMatrix(matrix);
    GdipDeleteRegion(region);
    GdipDeleteRegion(region100x100);
    GdipDeleteGraphics(graphics);
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_clipping_2()

static void test_clipping_2 ( void  )

static

Definition at line 5645 of file graphics.c.

{
 
    HDC hdc;
    GpStatus status;
    GpGraphics *graphics;
    GpRegion *region;
    GpMatrix *matrix;
    GpRectF rect;
    GpPointF ptf[4];
    GpUnit unit;
    HRGN hrgn;
    int ret;
    RECT rc;
 
    hdc = CreateCompatibleDC(0);
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    status = GdipGetPageUnit(graphics, &unit);
    expect(Ok, status);
    expect(UnitDisplay, unit);
 
    GdipSetPageUnit(graphics, UnitInch);
 
    status = GdipCreateRegion(&region);
    expect(Ok, status);
    status = GdipSetEmpty(region);
    expect(Ok, status);
    rect.X = rect.Y = 100.0;
    rect.Width = rect.Height = 100.0;
    status = GdipCombineRegionRect(region, &rect, CombineModeUnion);
    expect(Ok, status);
    status = GdipSetClipRegion(graphics, region, CombineModeReplace);
    expect(Ok, status);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 9600 && rc.top == 9600 && rc.right == 19200 && rc.bottom == 19200,
       "expected 9600,9600-19200,19200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 9600.0;
    ptf[0].Y = 9600.0;
    ptf[1].X = 19200.0;
    ptf[1].Y = 19200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    expectf(100.0, ptf[0].X);
    expectf(100.0, ptf[0].Y);
    expectf(200.0, ptf[1].X);
    expectf(200.0, ptf[1].X);
 
    GdipSetPageUnit(graphics, UnitPoint);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 7200 && rc.top == 7200 && rc.right == 14400 && rc.bottom == 14400) ||
       broken(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) /* before Win7 */,
       "expected 7200,7200-14400,14400, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 9600 && rc.top == 9600 && rc.right == 19200 && rc.bottom == 19200) ||
       broken(rc.left == 134 && rc.top == 134 && rc.right == 267 && rc.bottom == 267) /* before Win7 */,
       "expected 9600,9600-19200,19200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 9600.0;
    ptf[0].Y = 9600.0;
    ptf[1].X = 19200.0;
    ptf[1].Y = 19200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 7200.0) < 0.001)
        ok(ptf[0].X == 7200.0 && ptf[0].Y == 7200.0 && ptf[1].X == 14400.0 && ptf[1].Y == 14400.0,
           "expected 7200.0,7200.0-14400.0,14400.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 100.0) < 0.001), "expected 100.0, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 100.0) < 0.001), "expected 100.0, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 200.0) < 0.001), "expected 200.0, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 200.0) < 0.001), "expected 200.0, got %f\n", ptf[1].Y);
    }
 
    GdipDeleteRegion(region);
 
    GdipSetPageUnit(graphics, UnitPixel);
 
    status = GdipCreateRegion(&region);
    expect(Ok, status);
    status = GdipSetEmpty(region);
    expect(Ok, status);
    rect.X = rect.Y = 100.0;
    rect.Width = rect.Height = 100.0;
    status = GdipCombineRegionRect(region, &rect, CombineModeUnion);
    expect(Ok, status);
    status = GdipSetClipRegion(graphics, region, CombineModeReplace);
    expect(Ok, status);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
       broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
       broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 100.0) < 0.001)
        ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
           "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].Y);
    }
 
    GdipSetPageUnit(graphics, UnitPoint);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 75 && rc.top == 75 && rc.right == 150 && rc.bottom == 150) ||
       broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
       "expected 75,75-150,150, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
       broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 75.0) < 0.001)
        ok(ptf[0].X == 75.0 && ptf[0].Y == 75.0 && ptf[1].X == 150.0 && ptf[1].Y == 150.0,
           "expected 75.0,75.0-150.0,150.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].Y);
    }
 
    status = GdipCreateMatrix(&matrix);
    expect(Ok, status);
    status = GdipTranslateMatrix(matrix, 10.0, 10.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
    GdipDeleteMatrix(matrix);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 65 && rc.top == 65 && rc.right == 140 && rc.bottom == 140,
       "expected 65,65-140,140, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    expectf(65.0, ptf[0].X);
    expectf(65.0, ptf[0].Y);
    expectf(140.0, ptf[1].X);
    expectf(140.0, ptf[1].X);
 
    status = GdipCreateMatrix(&matrix);
    expect(Ok, status);
    status = GdipScaleMatrix(matrix, 0.25, 0.5, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
    GdipDeleteMatrix(matrix);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 300 && rc.top == 150 && rc.right == 600 && rc.bottom == 300,
       "expected 300,150-600,300, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    expectf(300.0, ptf[0].X);
    expectf(150.0, ptf[0].Y);
    expectf(600.0, ptf[1].X);
    expectf(300.0, ptf[1].Y);
 
    status = GdipSetPageScale(graphics, 2.0);
    expect(Ok, status);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 150 && rc.top == 75 && rc.right == 300 && rc.bottom == 150) ||
       broken(rc.left == 300 && rc.top == 150 && rc.right == 600 && rc.bottom == 300) /* before Win7 */,
       "expected 150,75-300,150, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
       broken(rc.left == 200 && rc.top == 200 && rc.right == 400 && rc.bottom == 400) /* before Win7 */,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
    expect(Ok, status);
    if (fabs(ptf[0].X - 150.0) < 0.001)
    {
        expectf(150.0, ptf[0].X);
        expectf(75.0, ptf[0].Y);
        expectf(300.0, ptf[1].X);
        expectf(150.0, ptf[1].Y);
    }
    else /* before Win7 */
    {
        ok(broken(fabs(ptf[0].X - 300.0) < 0.001), "expected 300.0, got %f\n", ptf[0].X);
        ok(broken(fabs(ptf[0].Y - 150.0) < 0.001), "expected 150.0, got %f\n", ptf[0].Y);
        ok(broken(fabs(ptf[1].X - 600.0) < 0.001), "expected 600.0, got %f\n", ptf[1].X);
        ok(broken(fabs(ptf[1].Y - 300.0) < 0.001), "expected 300.0, got %f\n", ptf[1].Y);
    }
 
    status = GdipCreateMatrix(&matrix);
    expect(Ok, status);
    status = GdipRotateMatrix(matrix, 45.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
    GdipDeleteMatrix(matrix);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == 54 && rc.top == -26 && rc.right == 107 && rc.bottom == 27) ||
       /* rounding under Wine is slightly different */
       (rc.left == 53 && rc.top == -26 && rc.right == 106 && rc.bottom == 27) /* Wine */,
       "expected 54,-26-107,27, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    ptf[2].X = 200.0;
    ptf[2].Y = 100.0;
    ptf[3].X = 100.0;
    ptf[3].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(53.033016, ptf[0].X);
    expectf(0.0, ptf[0].Y);
    expectf(106.066032, ptf[1].X);
    expectf(0.0, ptf[1].Y);
    expectf(79.549522, ptf[2].X);
    expectf(-26.516510, ptf[2].Y);
    expectf(79.549522, ptf[3].X);
    expectf(26.516508, ptf[3].Y);
 
    status = GdipCreateMatrix(&matrix);
    expect(Ok, status);
    status = GdipRotateMatrix(matrix, -45.0, MatrixOrderAppend);
    expect(Ok, status);
    status = GdipSetWorldTransform(graphics, matrix);
    expect(Ok, status);
    GdipDeleteMatrix(matrix);
 
    status = GdipGetClip(graphics, region);
    expect(Ok, status);
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
    ok((rc.left == -26 && rc.top == 54 && rc.right == 27 && rc.bottom == 107) ||
       /* rounding under Wine is slightly different */
       (rc.left == -27 && rc.top == 54 && rc.right == 27 && rc.bottom == 106) /* Wine */,
       "expected -26,54-27,107, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    expect(Ok, status);
    ret = GetRgnBox(hrgn, &rc);
    ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
    ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
       "expected 100,100-200,200, got %s\n", wine_dbgstr_rect(&rc));
    DeleteObject(hrgn);
 
    ptf[0].X = 100.0;
    ptf[0].Y = 100.0;
    ptf[1].X = 200.0;
    ptf[1].Y = 200.0;
    ptf[2].X = 200.0;
    ptf[2].Y = 100.0;
    ptf[3].X = 100.0;
    ptf[3].Y = 200.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
    expect(Ok, status);
    expectf(0.0, ptf[0].X);
    expectf(53.033005, ptf[0].Y);
    expectf(0.0, ptf[1].X);
    expectf(106.066010, ptf[1].Y);
    expectf(26.516491, ptf[2].X);
    expectf(79.549507, ptf[2].Y);
    expectf(-26.516520, ptf[3].X);
    expectf(79.549500, ptf[3].Y);
 
    GdipDeleteRegion(region);
    GdipDeleteGraphics(graphics);
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_constructor_destructor()

static void test_constructor_destructor ( void  )

static

Definition at line 139 of file graphics.c.

{
    GpStatus stat;
    GpGraphics *graphics = NULL;
    HDC hdc = GetDC( hwnd );
 
    stat = GdipCreateFromHDC(NULL, &graphics);
    expect(OutOfMemory, stat);
    stat = GdipDeleteGraphics(graphics);
    expect(InvalidParameter, stat);
 
    stat = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, stat);
    stat = GdipDeleteGraphics(graphics);
    expect(Ok, stat);
 
    stat = GdipCreateFromHWND(NULL, &graphics);
    expect(Ok, stat);
    stat = GdipDeleteGraphics(graphics);
    expect(Ok, stat);
 
    stat = GdipCreateFromHWNDICM(NULL, &graphics);
    expect(Ok, stat);
    stat = GdipDeleteGraphics(graphics);
    expect(Ok, stat);
 
    stat = GdipDeleteGraphics(NULL);
    expect(InvalidParameter, stat);
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_container_rects()

static void test_container_rects ( void  )

static

Definition at line 6149 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics;
    HDC hdc = GetDC( hwnd );
    GpRectF dstrect, srcrect;
    GraphicsContainer state;
    static const GpPointF test_points[3] = {{0.0,0.0}, {1.0,0.0}, {0.0,1.0}};
    GpPointF points[3];
    REAL dpix, dpiy;
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    dstrect.X = 0.0;
    dstrect.Y = 0.0;
    dstrect.Width = 1.0;
    dstrect.Height = 1.0;
    srcrect = dstrect;
 
    status = GdipGetDpiX(graphics, &dpix);
    expect(Ok, status);
 
    status = GdipGetDpiY(graphics, &dpiy);
    expect(Ok, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitWorld, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitDisplay, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitMillimeter+1, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(NULL, &dstrect, &srcrect, UnitPixel, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, NULL, &srcrect, UnitPixel, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, NULL, UnitPixel, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, -1, &state);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitPixel, NULL);
    expect(InvalidParameter, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitPixel, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(0.0, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(1.0, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(0.0, points[2].X);
    expectf(1.0, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitInch, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(0.0, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(1.0/dpix, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(0.0, points[2].X);
    expectf(1.0/dpiy, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
    expect(Ok, status);
 
    dstrect.X = 1.0;
    dstrect.Height = 3.0;
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitPixel, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(2.0, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(4.0, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(2.0, points[2].X);
    expectf(6.0, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(0.0, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(2.0, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(0.0, points[2].X);
    expectf(2.0, points[2].Y);
 
    status = GdipResetWorldTransform(graphics);
    expect(Ok, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitInch, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(1.0, points[0].X);
    expectf(0.0, points[0].Y);
    expectf((dpix+1.0)/dpix, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(1.0, points[2].X);
    expectf(3.0/dpiy, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    status = GdipSetPageUnit(graphics, UnitInch);
    expect(Ok, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitPixel, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(dpix, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(dpix*2, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(dpix, points[2].X);
    expectf(dpiy*3, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    status = GdipBeginContainer(graphics, &dstrect, &srcrect, UnitInch, &state);
    expect(Ok, status);
 
    memcpy(points, test_points, sizeof(points));
    status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, points, 3);
    expect(Ok, status);
    expectf(dpix, points[0].X);
    expectf(0.0, points[0].Y);
    expectf(dpix+1.0, points[1].X);
    expectf(0.0, points[1].Y);
    expectf(dpix, points[2].X);
    expectf(3.0, points[2].Y);
 
    status = GdipEndContainer(graphics, state);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_font_height_scaling()

static void test_font_height_scaling ( void  )

static

Definition at line 4260 of file graphics.c.

{
    static const WCHAR tahomaW[] = { 'T','a','h','o','m','a',0 };
    static const WCHAR string[] = { '1','2','3','4','5','6','7',0 };
    HDC hdc;
    GpStringFormat *format;
    CharacterRange range = { 0, 7 };
    GpRegion *region;
    GpGraphics *graphics;
    GpFontFamily *family;
    GpFont *font;
    GpStatus status;
    RectF bounds, rect;
    REAL height, dpi, scale;
    PointF ptf;
    GpUnit gfx_unit, font_unit;
 
    status = GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &format);
    expect(Ok, status);
    status = GdipSetStringFormatMeasurableCharacterRanges(format, 1, &range);
    expect(Ok, status);
    status = GdipCreateRegion(&region);
    expect(Ok, status);
 
    status = GdipCreateFontFamilyFromName(tahomaW, NULL, &family);
    expect(Ok, status);
 
    hdc = CreateCompatibleDC(0);
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
 
    status = GdipGetDpiY(graphics, &dpi);
    expect(Ok, status);
 
    /* First check if tested functionality works:
     * under XP if font and graphics units differ then GdipTransformPoints
     * followed by GdipSetPageUnit to change the graphics units breaks region
     * scaling in GdipMeasureCharacterRanges called later.
     */
    status = GdipSetPageUnit(graphics, UnitDocument);
    expect(Ok, status);
 
    ptf.X = 0.0;
    ptf.Y = 0.0;
    status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &ptf, 1);
    expect(Ok, status);
 
    status = GdipSetPageUnit(graphics, UnitInch);
    expect(Ok, status);
 
    status = GdipCreateFont(family, 720.0, FontStyleRegular, UnitPoint, &font);
    expect(Ok, status);
 
    set_rect_empty(&rect);
    set_rect_empty(&bounds);
    status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
    expect(Ok, status);
    trace("test bounds: %f,%f,%f,%f\n", bounds.X, bounds.Y, bounds.Width, bounds.Height);
 
    set_rect_empty(&rect);
    rect.Width = 32000.0;
    rect.Height = 32000.0;
    status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
    expect(Ok, status);
 
    set_rect_empty(&rect);
    status = GdipGetRegionBounds(region, graphics, &rect);
    expect(Ok, status);
    trace("test region: %f,%f,%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
 
    GdipDeleteFont(font);
 
    scale = rect.Height / bounds.Height;
    if (fabs(scale - 1.0) > 0.1)
    {
        win_skip("GdipGetRegionBounds is broken, scale %f (should be near 1.0)\n", scale);
        goto cleanup;
    }
 
    status = GdipScaleWorldTransform(graphics, 0.01, 0.01, MatrixOrderAppend);
    expect(Ok, status);
 
    /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
    /* UnitPixel as a font base unit is not tested because it drastically
       differs in behaviour */
    for (font_unit = 3; font_unit <= 6; font_unit++)
    {
        /* create a font for the final text height of 100 pixels */
        /* height + 2 * (height/6) = 100 => height = 100 * 3 / 4 => 75 */
        status = GdipSetPageUnit(graphics, font_unit);
        expect(Ok, status);
        ptf.X = 0;
        ptf.Y = 75.0;
        status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &ptf, 1);
        expect(Ok, status);
        height = ptf.Y;
        /*trace("height %f units\n", height);*/
        status = GdipCreateFont(family, height, FontStyleRegular, font_unit, &font);
        expect(Ok, status);
 
        /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
        for (gfx_unit = 2; gfx_unit <= 6; gfx_unit++)
        {
            static const WCHAR doubleW[2] = { 'W','W' };
            RectF bounds_1, bounds_2;
            REAL margin, margin_y, font_height;
            int match;
 
            status = GdipSetPageUnit(graphics, gfx_unit);
            expect(Ok, status);
 
            margin_y = units_to_pixels(height / 8.0, font_unit, dpi);
            margin_y = pixels_to_units(margin_y, gfx_unit, dpi);
 
            status = GdipGetFontHeight(font, graphics, &font_height);
            expect(Ok, status);
 
            set_rect_empty(&rect);
            set_rect_empty(&bounds);
            status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
            expect(Ok, status);
            /*trace("bounds: %f,%f,%f,%f\n", bounds.X, bounds.Y, bounds.Width, bounds.Height);*/
todo_wine
            expectf_(font_height + margin_y, bounds.Height, 0.005);
 
            ptf.X = 0;
            ptf.Y = bounds.Height;
            status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &ptf, 1);
            expect(Ok, status);
            match = fabs(100.0 - ptf.Y) <= 1.0;
todo_wine
            ok(match, "Expected 100.0, got %f\n", ptf.Y);
 
            /* verify the result */
            ptf.Y = units_to_pixels(bounds.Height, gfx_unit, dpi);
            ptf.Y /= 100.0;
            match = fabs(100.0 - ptf.Y) <= 1.0;
todo_wine
            ok(match, "Expected 100.0, got %f\n", ptf.Y);
 
            /* bounds.width of 1 glyph: [margin]+[width]+[margin] */
            set_rect_empty(&rect);
            set_rect_empty(&bounds_1);
            status = GdipMeasureString(graphics, doubleW, 1, font, &rect, format, &bounds_1, NULL, NULL);
            expect(Ok, status);
            /* bounds.width of 2 identical glyphs: [margin]+[width]+[width]+[margin] */
            set_rect_empty(&rect);
            set_rect_empty(&bounds_2);
            status = GdipMeasureString(graphics, doubleW, 2, font, &rect, format, &bounds_2, NULL, NULL);
            expect(Ok, status);
 
            /* margin = [bounds.width of 1] - [bounds.width of 2] / 2*/
            margin = bounds_1.Width - bounds_2.Width / 2.0;
            /*trace("margin %f\n", margin);*/
            ok(margin > 0.0, "wrong margin %f\n", margin);
 
            set_rect_empty(&rect);
            rect.Width = 320000.0;
            rect.Height = 320000.0;
            status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
            expect(Ok, status);
            set_rect_empty(&rect);
            status = GdipGetRegionBounds(region, graphics, &rect);
            expect(Ok, status);
            /*trace("region: %f,%f,%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);*/
            ok(rect.X > 0.0, "wrong rect.X %f\n", rect.X);
            expectf(0.0, rect.Y);
            match = fabs(1.0 - margin / rect.X) <= 0.05;
            ok(match, "Expected %f, got %f\n", margin, rect.X);
            match = fabs(1.0 - font_height / rect.Height) <= 0.1;
            ok(match, "Expected %f, got %f\n", font_height, rect.Height);
            match = fabs(1.0 - bounds.Width / (rect.Width + margin * 2.0)) <= 0.05;
            ok(match, "Expected %f, got %f\n", bounds.Width, rect.Width + margin * 2.0);
        }
 
        GdipDeleteFont(font);
    }
 
cleanup:
    status = GdipDeleteGraphics(graphics);
    expect(Ok, status);
    DeleteDC(hdc);
 
    GdipDeleteFontFamily(family);
    GdipDeleteRegion(region);
    GdipDeleteStringFormat(format);
}

Referenced by START_TEST().

test_fromMemoryBitmap()

static void test_fromMemoryBitmap ( void  )

static

Definition at line 2592 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpBitmap *bitmap = NULL;
    BYTE bits[48] = {0};
    HDC hdc=NULL;
    COLORREF color;
 
    status = GdipCreateBitmapFromScan0(4, 4, 12, PixelFormat24bppRGB, bits, &bitmap);
    expect(Ok, status);
 
    status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
    expect(Ok, status);
 
    status = GdipGraphicsClear(graphics, 0xff686868);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
 
    /* drawing writes to the memory provided */
    expect(0x68, bits[10]);
 
    status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
    expect(Ok, status);
 
    status = GdipGetDC(graphics, &hdc);
    expect(Ok, status);
    ok(hdc != NULL, "got NULL hdc\n");
 
    color = GetPixel(hdc, 0, 0);
    /* The HDC is write-only, and native fills with a solid color to figure out
     * which pixels have changed. */
    todo_wine expect(0x0c0b0d, color);
 
    SetPixel(hdc, 0, 0, 0x797979);
    SetPixel(hdc, 1, 0, 0x0c0b0d);
 
    status = GdipReleaseDC(graphics, hdc);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
 
    expect(0x79, bits[0]);
    todo_wine expect(0x68, bits[3]);
 
    GdipDisposeImage((GpImage*)bitmap);
 
    /* We get the same kind of write-only HDC for a "normal" bitmap */
    status = GdipCreateBitmapFromScan0(4, 4, 12, PixelFormat24bppRGB, NULL, &bitmap);
    expect(Ok, status);
 
    status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
    expect(Ok, status);
 
    status = GdipGetDC(graphics, &hdc);
    expect(Ok, status);
    ok(hdc != NULL, "got NULL hdc\n");
 
    color = GetPixel(hdc, 0, 0);
    todo_wine expect(0x0c0b0d, color);
 
    status = GdipReleaseDC(graphics, hdc);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
 
    GdipDisposeImage((GpImage*)bitmap);
 
    /* If we don't draw to the HDC, the bits are never accessed */
    status = GdipCreateBitmapFromScan0(4, 4, 12, PixelFormat24bppRGB, (BYTE*)1, &bitmap);
    expect(Ok, status);
 
    status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
    expect(Ok, status);
 
    status = GdipGetDC(graphics, &hdc);
    expect(Ok, status);
    ok(hdc != NULL, "got NULL hdc\n");
 
    color = GetPixel(hdc, 0, 0);
    todo_wine expect(0x0c0b0d, color);
 
    status = GdipReleaseDC(graphics, hdc);
    expect(Ok, status);
 
    GdipDeleteGraphics(graphics);
 
    GdipDisposeImage((GpImage*)bitmap);
}

Referenced by START_TEST().

test_GdipDrawArc()

static void test_GdipDrawArc ( void  )

static

Definition at line 531 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
    status = GdipDrawArc(NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArc(graphics, NULL, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArc(NULL, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArc(graphics, pen, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    /* successful case */
    status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawArcI()

static void test_GdipDrawArcI ( void  )

static

Definition at line 575 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
    status = GdipDrawArcI(NULL, NULL, 0, 0, 0, 0, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArcI(graphics, NULL, 0, 0, 1, 1, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArcI(NULL, pen, 0, 0, 1, 1, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArcI(graphics, pen, 0, 0, 1, 0, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawArcI(graphics, pen, 0, 0, 0, 1, 0, 0);
    expect(InvalidParameter, status);
 
    /* successful case */
    status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0, 0);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawBezierI()

static void test_GdipDrawBezierI ( void  )

static

Definition at line 817 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen */
    status = GdipDrawBezierI(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawBezierI(graphics, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawBezierI(NULL, pen, 0, 0, 0, 0, 0, 0, 0, 0);
    expect(InvalidParameter, status);
 
    /* successful case */
    status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawCurve()

static void test_GdipDrawCurve ( void  )

static

Definition at line 1149 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
    GpPointF points[3];
 
    points[0].X = 0;
    points[0].Y = 0;
 
    points[1].X = 40;
    points[1].Y = 20;
 
    points[2].X = 10;
    points[2].Y = 40;
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen */
    status = GdipDrawCurve(NULL, NULL, points, 3);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve(graphics, NULL, points, 3);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve(NULL, pen, points, 3);
    expect(InvalidParameter, status);
 
    /* InvalidParameter cases: invalid count */
    status = GdipDrawCurve(graphics, pen, points, -1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve(graphics, pen, points, 0);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve(graphics, pen, points, 1);
    expect(InvalidParameter, status);
 
    /* Valid test cases */
    status = GdipDrawCurve(graphics, pen, points, 2);
    expect(Ok, status);
 
    status = GdipDrawCurve(graphics, pen, points, 3);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawCurve2()

static void test_GdipDrawCurve2 ( void  )

static

Definition at line 1015 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
    GpPointF points[3];
 
    points[0].X = 0;
    points[0].Y = 0;
 
    points[1].X = 40;
    points[1].Y = 20;
 
    points[2].X = 10;
    points[2].Y = 40;
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen */
    status = GdipDrawCurve2(NULL, NULL, points, 3, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2(graphics, NULL, points, 3, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2(NULL, pen, points, 3, 1);
    expect(InvalidParameter, status);
 
    /* InvalidParameter cases: invalid count */
    status = GdipDrawCurve2(graphics, pen, points, -1, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2(graphics, pen, points, 0, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2(graphics, pen, points, 1, 1);
    expect(InvalidParameter, status);
 
    /* Valid test cases */
    status = GdipDrawCurve2(graphics, pen, points, 2, 1);
    expect(Ok, status);
 
    status = GdipDrawCurve2(graphics, pen, points, 3, 2);
    expect(Ok, status);
 
    status = GdipDrawCurve2(graphics, pen, points, 3, -2);
    expect(Ok, status);
 
    status = GdipDrawCurve2(graphics, pen, points, 3, 0);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawCurve2I()

static void test_GdipDrawCurve2I ( void  )

static

Definition at line 1082 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
    GpPoint points[3];
 
    points[0].X = 0;
    points[0].Y = 0;
 
    points[1].X = 40;
    points[1].Y = 20;
 
    points[2].X = 10;
    points[2].Y = 40;
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen */
    status = GdipDrawCurve2I(NULL, NULL, points, 3, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2I(graphics, NULL, points, 3, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2I(NULL, pen, points, 3, 1);
    expect(InvalidParameter, status);
 
    /* InvalidParameter cases: invalid count */
    status = GdipDrawCurve2I(graphics, pen, points, -1, 1);
    expect(OutOfMemory, status);
 
    status = GdipDrawCurve2I(graphics, pen, points, 0, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve2I(graphics, pen, points, 1, 1);
    expect(InvalidParameter, status);
 
    /* Valid test cases */
    status = GdipDrawCurve2I(graphics, pen, points, 2, 1);
    expect(Ok, status);
 
    status = GdipDrawCurve2I(graphics, pen, points, 3, 2);
    expect(Ok, status);
 
    status = GdipDrawCurve2I(graphics, pen, points, 3, -2);
    expect(Ok, status);
 
    status = GdipDrawCurve2I(graphics, pen, points, 3, 0);
    expect(Ok, status);
 
    GdipDeletePen(pen);
    GdipDeleteGraphics(graphics);
 
    ReleaseDC(hwnd, hdc);
}

Referenced by START_TEST().

test_GdipDrawCurve3()

static void test_GdipDrawCurve3 ( void  )

static

Definition at line 855 of file graphics.c.

{
    GpStatus status;
    GpGraphics *graphics = NULL;
    GpPen *pen = NULL;
    HDC hdc = GetDC( hwnd );
    GpPointF points[3];
 
    points[0].X = 0;
    points[0].Y = 0;
 
    points[1].X = 40;
    points[1].Y = 20;
 
    points[2].X = 10;
    points[2].Y = 40;
 
    /* make a graphics object and pen object */
    ok(hdc != NULL, "Expected HDC to be initialized\n");
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected graphics to be initialized\n");
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* InvalidParameter cases: null graphics, null pen */
    status = GdipDrawCurve3(NULL, NULL, points, 3, 0, 2, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve3(graphics, NULL, points, 3, 0, 2, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve3(NULL, pen, points, 3, 0, 2, 1);
    expect(InvalidParameter, status);
 
    /* InvalidParameter cases: invalid count */
    status = GdipDrawCurve3(graphics, pen, points, -1, 0, 2, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve3(graphics, pen, points, 0, 0, 2, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve3(graphics, pen, points, 1, 0, 0, 1);
    expect(InvalidParameter, status);
 
    status = GdipDrawCurve3(graphics, pen, points, 3, 4, 2, 1);
    expect(InvalidParameter, status);
 
    /* InvalidParameter cases: invalid number of segments */
    status = GdipDrawCurve3(graphics, pen, points, 3, 0, -1, 1);