SetLayout.c File Reference

#include "precomp.h"

Include dependency graph for SetLayout.c:

Go to the source code of this file.

Macros
#define	BLACK_PIXEL   0x000000
#define	BLUE_PIXEL   0x0000FF
#define	GREEN_PIXEL   0x00FF00
#define	RED_PIXEL   0xFF0000
#define	WHITE_PIXEL   0xFFFFFF
#define	WIDTH   10

Functions
static void	copy (PUINT32 buffer, UINT32 value, int width, int start_x, int start_y, int end_x, int end_y)
static void	nomirror_test (PUINT32 dstBuffer, PUINT32 srcBuffer, int width, int line)
	START_TEST (SetLayout)

Macro Definition Documentation

BLACK_PIXEL

#define BLACK_PIXEL   0x000000

Definition at line 21 of file SetLayout.c.

BLUE_PIXEL

#define BLUE_PIXEL   0x0000FF

Definition at line 22 of file SetLayout.c.

GREEN_PIXEL

#define GREEN_PIXEL   0x00FF00

Definition at line 23 of file SetLayout.c.

RED_PIXEL

#define RED_PIXEL   0xFF0000

Definition at line 24 of file SetLayout.c.

WHITE_PIXEL

#define WHITE_PIXEL   0xFFFFFF

Definition at line 25 of file SetLayout.c.

WIDTH

#define WIDTH   10

Definition at line 112 of file SetLayout.c.

Function Documentation

copy()

static void copy ( PUINT32  buffer, UINT32  value, int  width, int  start_x, int  start_y, int  end_x, int  end_y  )

static

Definition at line 12 of file SetLayout.c.

{
    for (int y = start_y; y < end_y; y++)
    {
        for (int x = start_x; x < end_x; x++)
            buffer[y * width + x] = value;
    }
}

Referenced by START_TEST().

nomirror_test()

static void nomirror_test ( PUINT32  dstBuffer, PUINT32  srcBuffer, int  width, int  line  )

static

Definition at line 90 of file SetLayout.c.

{
    for (int y = 0; y < width; y++)
    {
        for (int x = 0; x < width; x++)
        {
            if (x == width - 1)
            {
                ok(dstBuffer[y * width + x] == BLACK_PIXEL,
                   "Expected blank (black) pixel (0x0), got (%06X), coordinates (%d, %d). line: %d\n",
                   dstBuffer[y * width + x], x, y, line);
            }
            else
            {
                ok(dstBuffer[y * width + x] == srcBuffer[y * width + x + 1],
                   "Coordinates: (%d, %d), expected (%06X), got (%06X). line: %d\n",
                   x, y, srcBuffer[y * width + x + 1], dstBuffer[y * width + x], line);
            }
        }
    }
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

SetLayout

)

Definition at line 113 of file SetLayout.c.

{
    HBITMAP bmpDst, bmpSrc, oldDst, oldSrc;
    HDC hdc, hdcDst, hdcSrc;
    PUINT32 dstBuffer, srcBuffer;
    BITMAPINFO info = { 0 };
    size_t nBuf = WIDTH * WIDTH * sizeof(UINT32);
 
    hdc = CreateCompatibleDC(NULL);
    hdcDst = CreateCompatibleDC(hdc);
    hdcSrc = CreateCompatibleDC(hdc);
 
    info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    info.bmiHeader.biWidth = WIDTH;
    info.bmiHeader.biHeight = -WIDTH;
    info.bmiHeader.biPlanes = 1;
    info.bmiHeader.biBitCount = 32;
    info.bmiHeader.biCompression = BI_RGB;
 
    /* Create bitmaps to test with */
    bmpSrc = CreateDIBSection(hdcSrc, &info, DIB_RGB_COLORS, (PVOID*)&srcBuffer, NULL, 0);
    bmpDst = CreateDIBSection(hdcDst, &info, DIB_RGB_COLORS, (PVOID*)&dstBuffer, NULL, 0);
 
    if (!bmpSrc || !bmpDst)
    {
        skip("Failed to create bitmaps");
        goto cleanup;
    }
 
    oldSrc = SelectObject(hdcSrc, bmpSrc);
    oldDst = SelectObject(hdcDst, bmpDst);
 
    /* Create base "image" for use in the tests */
    copy(srcBuffer, WHITE_PIXEL, WIDTH, 0, 0, WIDTH / 2, WIDTH / 2);
    copy(srcBuffer, BLUE_PIXEL, WIDTH, 0, WIDTH / 2, WIDTH / 2, WIDTH);
    copy(srcBuffer, GREEN_PIXEL, WIDTH, WIDTH / 2, 0, WIDTH, WIDTH / 2);
    copy(srcBuffer, RED_PIXEL, WIDTH, WIDTH / 2, WIDTH / 2, WIDTH, WIDTH);
 
    /* Mirror destination DC */
    SetLayout(hdcDst, LAYOUT_RTL);
    ok(GetLayout(hdcDst) == LAYOUT_RTL, "DC layout is not RTL\n");
    ok(GetMapMode(hdcDst) == MM_ANISOTROPIC, "DC Map mode is not MM_ANISOTROPIC\n");
 
    /* Test RTL transform (using LPtoDP) and the inverse transform (DPtoLP) */
    for (int y = 0; y < WIDTH; y++)
    {
        for (int x = 0; x < WIDTH; x++)
        {
            POINT pt = { x, y };
            POINT mirrored = { WIDTH - 1 - x, y }; /* Expected results */
 
            LPtoDP(hdcDst, &pt, 1);
            /* Test LPtoDP */
            ok(pt.x == mirrored.x && pt.y == mirrored.y,
              "Coodinates: (%d, %d), expected (%ld, %ld), got (%ld, %ld)\n",
              x, y, mirrored.x, mirrored.y, pt.x, pt.y);
 
            pt = mirrored;
 
            /* Test DPtoLP */
            DPtoLP(hdcDst, &pt, 1);
            ok(pt.x == x && pt.y == y,
               "Mirrored Coodinates: (%ld, %ld), expected (%d, %d), got (%ld, %ld)\n",
               mirrored.x, mirrored.y, x, y, pt.x, pt.y);
        }
    }
 
    ZeroMemory(dstBuffer, nBuf);
    StretchBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, WIDTH, WIDTH, SRCCOPY);
    for (int y = 0; y < WIDTH; y++)
    {
        for (int x = 0; x < WIDTH; x++)
        {
            /* Test if the image is mirrored using the assumed RTL transform results */
            ok(dstBuffer[y * WIDTH + (WIDTH - 1 - x)] == srcBuffer[y * WIDTH + x],
               "Coordinates: (%d, %d), expected (%06X), got (%06X)\n",
               x, y, srcBuffer[y * WIDTH + x], dstBuffer[y * WIDTH + (WIDTH - 1 - x)]);
        }
    }
 
    ZeroMemory(dstBuffer, nBuf);
    StretchBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, WIDTH, WIDTH, SRCCOPY | NOMIRRORBITMAP);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    ZeroMemory(dstBuffer, nBuf);
    BitBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, SRCCOPY);
    for (int y = 0; y < WIDTH; y++)
    {
        for (int x = 0; x < WIDTH; x++)
        {
            /* Test if the image is mirrored using the assumed RTL transform results */
            ok(dstBuffer[y * WIDTH + (WIDTH - 1 - x)] == srcBuffer[y * WIDTH + x],
               "Coordinates: (%d, %d), expected (%06X), got (%06X)\n",
               x, y, srcBuffer[y * WIDTH + x], dstBuffer[y * WIDTH + (WIDTH - 1 - x)]);
        }
    }
 
    ZeroMemory(dstBuffer, nBuf);
    BitBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, SRCCOPY | NOMIRRORBITMAP);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    SetLayout(hdcDst, LAYOUT_RTL | LAYOUT_BITMAPORIENTATIONPRESERVED);
 
    ok(GetLayout(hdcDst) == (LAYOUT_RTL | LAYOUT_BITMAPORIENTATIONPRESERVED),
       "DC Layout is not LAYOUT_RTL | LAYOUT_BITMAPORIENTATIONPRESERVED\n");
    ok(GetMapMode(hdcDst) == MM_ANISOTROPIC, "DC Map mode is not MM_ANISOTROPIC\n");
 
    ZeroMemory(dstBuffer, nBuf);
    StretchBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, WIDTH, WIDTH, SRCCOPY);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    ZeroMemory(dstBuffer, nBuf);
    StretchBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, WIDTH, WIDTH, SRCCOPY | NOMIRRORBITMAP);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    ZeroMemory(dstBuffer, nBuf);
    BitBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, SRCCOPY);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    ZeroMemory(dstBuffer, nBuf);
    BitBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, SRCCOPY | NOMIRRORBITMAP);
    nomirror_test(dstBuffer, srcBuffer, WIDTH, __LINE__);
 
    /* Reset DC layout to default (LTR) */
    SetLayout(hdcDst, LAYOUT_LTR);
    ok(GetLayout(hdcDst) == LAYOUT_LTR, "DC layout is not LAYOUT_LTR");
 
    for (int y = 0; y < WIDTH; y++)
    {
        for (int x = 0; x < WIDTH; x++)
        {
            POINT pt = { x, y };
 
            LPtoDP(hdcDst, &pt, 1);
            /* Confirm that RTL transform is not the current one */
            ok(pt.x == x && pt.y == y,
               "Expected (%d, %d) got (%ld, %ld)\n", x, y, pt.x, pt.y);
        }
    }
 
    ZeroMemory(dstBuffer, nBuf);
    StretchBlt(hdcDst, 0, 0, WIDTH, WIDTH, hdcSrc, 0, 0, WIDTH, WIDTH, SRCCOPY);
    ok(memcmp(dstBuffer, srcBuffer, nBuf) == 0, "Bitmaps are not identical\n");
 
    SetLayout(hdcDst, LAYOUT_BITMAPORIENTATIONPRESERVED);
    ok(GetLayout(hdcDst) == LAYOUT_BITMAPORIENTATIONPRESERVED, "DC Layout is not LAYOUT_BITMAPORIENTATIONPRESERVED");
 
    SelectObject(hdcSrc, oldSrc);
    SelectObject(hdcDst, oldDst);
    DeleteObject(bmpSrc);
    DeleteObject(bmpDst);
cleanup:
    DeleteDC(hdcSrc);
    DeleteDC(hdcDst);
    DeleteDC(hdc);
}