コード例 #1
0
ファイル: gdi.c プロジェクト: AMV007/FreeRDP
void gdi_init_primary(rdpGdi* gdi)
{
	gdi->primary = (gdiBitmap*) malloc(sizeof(gdiBitmap));

	if (!gdi->primary)
		return;

	gdi->primary->hdc = gdi_CreateCompatibleDC(gdi->hdc);

	if (!gdi->primary_buffer)
		gdi->primary->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, gdi->width, gdi->height);
	else
		gdi->primary->bitmap = gdi_CreateBitmap(gdi->width, gdi->height, gdi->dstBpp, gdi->primary_buffer);

	gdi_SelectObject(gdi->primary->hdc, (HGDIOBJECT) gdi->primary->bitmap);
	gdi->primary->org_bitmap = NULL;

	gdi->primary_buffer = gdi->primary->bitmap->data;

	if (!gdi->drawing)
		gdi->drawing = gdi->primary;

	gdi->primary->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
	gdi->primary->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
	gdi->primary->hdc->hwnd->invalid->null = 1;

	gdi->primary->hdc->hwnd->count = 32;
	gdi->primary->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * gdi->primary->hdc->hwnd->count);
	gdi->primary->hdc->hwnd->ninvalid = 0;
}
コード例 #2
0
ファイル: TestGdiCreate.c プロジェクト: C4rt/FreeRDP
int test_gdi_SetPixel(void)
{
	HGDI_DC hdc;
	int width = 128;
	int height = 64;
	HGDI_BITMAP hBitmap;

	if (!(hdc = gdi_GetDC()))
	{
		printf("failed to get gdi device context\n");
		return -1;
	}

	hdc->bytesPerPixel = 4;
	hdc->bitsPerPixel = 32;

	hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height);
	gdi_SelectObject(hdc, (HGDIOBJECT) hBitmap);

	gdi_SetPixel(hdc, 32, 64, 0xAABBCCDD);

	if (gdi_GetPixel(hdc, 32, 64) != 0xAABBCCDD)
		return -1;

	gdi_SetPixel(hdc, width - 1, height - 1, 0xAABBCCDD);

	if (gdi_GetPixel(hdc, width - 1, height - 1) != 0xAABBCCDD)
		return -1;

	gdi_DeleteObject((HGDIOBJECT) hBitmap);

	return 0;
}
コード例 #3
0
ファイル: gdi.c プロジェクト: JunaidLoonat/FreeRDP
gdiBitmap* gdi_bitmap_new_ex(rdpGdi* gdi, int width, int height, int bpp,
                             BYTE* data)
{
	gdiBitmap* bitmap;
	bitmap = (gdiBitmap*) calloc(1, sizeof(gdiBitmap));

	if (!bitmap)
		goto fail_bitmap;

	if (!(bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc)))
		goto fail_hdc;

	WLog_Print(gdi->log, WLOG_DEBUG, "gdi_bitmap_new: width:%d height:%d bpp:%d",
	           width, height, bpp);

	if (!data)
		bitmap->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, width, height);
	else
		bitmap->bitmap = gdi_create_bitmap(gdi, width, height, bpp, data);

	if (!bitmap->bitmap)
		goto fail_bitmap_bitmap;

	gdi_SelectObject(bitmap->hdc, (HGDIOBJECT) bitmap->bitmap);
	bitmap->org_bitmap = NULL;
	return bitmap;
fail_bitmap_bitmap:
	gdi_DeleteDC(bitmap->hdc);
fail_hdc:
	free(bitmap);
fail_bitmap:
	return NULL;
}
コード例 #4
0
ファイル: graphics.c プロジェクト: nfedera/FreeRDP
static BOOL gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
    gdiBitmap* gdi_bitmap;
    rdpGdi* gdi = context->gdi;
    gdi_bitmap = (gdiBitmap*) bitmap;
    gdi_bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);

    if (!gdi_bitmap->hdc)
        return FALSE;

    if (!bitmap->data)
        gdi_bitmap->bitmap = gdi_CreateCompatibleBitmap(
                                 gdi->hdc, bitmap->width,
                                 bitmap->height);
    else
    {
        UINT32 format = bitmap->format;
        gdi_bitmap->bitmap = gdi_create_bitmap(gdi, bitmap->width,
                                               bitmap->height,
                                               format, bitmap->data);
    }

    if (!gdi_bitmap->bitmap)
    {
        gdi_DeleteDC(gdi_bitmap->hdc);
        return FALSE;
    }

    gdi_bitmap->hdc->format = gdi_bitmap->bitmap->format;
    gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->bitmap);
    gdi_bitmap->org_bitmap = NULL;
    return TRUE;
}
コード例 #5
0
ファイル: gdi.c プロジェクト: BrianChangchien/FiWoRDC
BOOL gdi_init_primary(rdpGdi* gdi)
{
	gdi->primary = (gdiBitmap*) calloc(1, sizeof(gdiBitmap));

	if (!gdi->primary)
		goto fail_primary;

	if (!(gdi->primary->hdc = gdi_CreateCompatibleDC(gdi->hdc)))
		goto fail_hdc;

	if (!gdi->primary_buffer)
		gdi->primary->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, gdi->width, gdi->height);
	else
		gdi->primary->bitmap = gdi_CreateBitmapEx(gdi->width, gdi->height, gdi->dstBpp,
												gdi->primary_buffer, NULL);

	if (!gdi->primary->bitmap)
		goto fail_bitmap;

	gdi_SelectObject(gdi->primary->hdc, (HGDIOBJECT) gdi->primary->bitmap);
	gdi->primary->org_bitmap = NULL;

	gdi->primary_buffer = gdi->primary->bitmap->data;

	if (!(gdi->primary->hdc->hwnd = (HGDI_WND) calloc(1, sizeof(GDI_WND))))
		goto fail_hwnd;
	if (!(gdi->primary->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0)))
		goto fail_hwnd;
	gdi->primary->hdc->hwnd->invalid->null = 1;

	gdi->primary->hdc->hwnd->count = 32;
	if (!(gdi->primary->hdc->hwnd->cinvalid = (HGDI_RGN) calloc(gdi->primary->hdc->hwnd->count, sizeof(GDI_RGN))))
		goto fail_hwnd;
	gdi->primary->hdc->hwnd->ninvalid = 0;

	if (!gdi->drawing)
		gdi->drawing = gdi->primary;

	return TRUE;

fail_hwnd:
	gdi_DeleteObject((HGDIOBJECT) gdi->primary->bitmap);
fail_bitmap:
	gdi_DeleteDC(gdi->primary->hdc);
fail_hdc:
	free(gdi->primary);
	gdi->primary = NULL;
fail_primary:
	return FALSE;
}
コード例 #6
0
ファイル: graphics.c プロジェクト: felfert/FreeRDP
void gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
	gdiBitmap* gdi_bitmap;
	rdpGdi* gdi = context->gdi;

	gdi_bitmap = (gdiBitmap*) bitmap;
	gdi_bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);

	if (bitmap->data == NULL)
		gdi_bitmap->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, bitmap->width, bitmap->height);
	else
		gdi_bitmap->bitmap = gdi_create_bitmap(gdi, bitmap->width, bitmap->height, gdi->dstBpp, bitmap->data);

	gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->bitmap);
	gdi_bitmap->org_bitmap = NULL;
}
コード例 #7
0
ファイル: TestGdiCreate.c プロジェクト: C4rt/FreeRDP
int test_gdi_CreateCompatibleBitmap(void)
{
	HGDI_DC hdc;
	int width;
	int height;
	HGDI_BITMAP hBitmap;

	if (!(hdc = gdi_GetDC()))
	{
		printf("failed to get gdi device context\n");
		return -1;
	}

	hdc->bytesPerPixel = 4;
	hdc->bitsPerPixel = 32;

	width = 32;
	height = 16;
	hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height);

	if (hBitmap->objectType != GDIOBJECT_BITMAP)
		return -1;

	if (hBitmap->bytesPerPixel != hdc->bytesPerPixel)
		return -1;

	if (hBitmap->bitsPerPixel != hdc->bitsPerPixel)
		return -1;

	if (hBitmap->width != width)
		return -1;

	if (hBitmap->height != height)
		return -1;

	if (!hBitmap->data)
		return -1;

	gdi_DeleteObject((HGDIOBJECT) hBitmap);

	return 0;
}
コード例 #8
0
ファイル: gdi.c プロジェクト: AMV007/FreeRDP
gdiBitmap* gdi_bitmap_new_ex(rdpGdi* gdi, int width, int height, int bpp, BYTE* data)
{
	gdiBitmap* bitmap;

	bitmap = (gdiBitmap*) malloc(sizeof(gdiBitmap));

	if (!bitmap)
		return NULL;

	bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);

	DEBUG_GDI("gdi_bitmap_new: width:%d height:%d bpp:%d", width, height, bpp);

	if (!data)
		bitmap->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, width, height);
	else
		bitmap->bitmap = gdi_create_bitmap(gdi, width, height, bpp, data);

	gdi_SelectObject(bitmap->hdc, (HGDIOBJECT) bitmap->bitmap);
	bitmap->org_bitmap = NULL;

	return bitmap;
}
コード例 #9
0
ファイル: TestGdiLine.c プロジェクト: 99455125/FreeRDP
int TestGdiLine(int argc, char* argv[])
{
	int rc = -1;
	UINT32 x, i;
	gdiPalette g;
	const UINT32 RawFormat = PIXEL_FORMAT_RGB8;
	const UINT32 colorFormats[] =
	{
		PIXEL_FORMAT_RGB15,
		PIXEL_FORMAT_ARGB15,
		PIXEL_FORMAT_RGB16,
		PIXEL_FORMAT_RGB24,
		PIXEL_FORMAT_ARGB32,
		PIXEL_FORMAT_XRGB32,
		PIXEL_FORMAT_RGBA32,
		PIXEL_FORMAT_RGBX32,
		PIXEL_FORMAT_BGR15,
		PIXEL_FORMAT_ABGR15,
		PIXEL_FORMAT_BGR16,
		PIXEL_FORMAT_BGR24,
		PIXEL_FORMAT_ABGR32,
		PIXEL_FORMAT_XBGR32,
		PIXEL_FORMAT_BGRA32,
		PIXEL_FORMAT_BGRX32
	};
	const UINT32 number_formats = sizeof(colorFormats) / sizeof(colorFormats[0]);

	for (i = 0; i < number_formats; i++)
	{
		HGDI_DC hdc = NULL;
		HGDI_PEN pen = NULL;
		HGDI_BITMAP hBmp = NULL;
		struct ropMap rop_map[] =
		{
			{GDI_R2_BLACK, NULL, line_to_R2_BLACK},
			{GDI_R2_NOTMERGEPEN, NULL, line_to_R2_NOTMERGEPEN},
			{GDI_R2_MASKNOTPEN, NULL, line_to_R2_MASKNOTPEN},
			{GDI_R2_NOTCOPYPEN, NULL, line_to_R2_NOTCOPYPEN},
			{GDI_R2_MASKPENNOT, NULL, line_to_R2_MASKPENNOT},
			{GDI_R2_NOT, NULL, line_to_R2_NOT},
			{GDI_R2_XORPEN, NULL, line_to_R2_XORPEN},
			{GDI_R2_NOTMASKPEN, NULL, line_to_R2_NOTMASKPEN},
			{GDI_R2_MASKPEN, NULL, line_to_R2_MASKPEN},
			{GDI_R2_NOTXORPEN, NULL, line_to_R2_NOTXORPEN},
			{GDI_R2_NOP, NULL, line_to_R2_NOP},
			{GDI_R2_MERGENOTPEN, NULL, line_to_R2_MERGENOTPEN},
			{GDI_R2_COPYPEN, NULL, line_to_R2_COPYPEN},
			{GDI_R2_MERGEPENNOT, NULL, line_to_R2_MERGEPENNOT},
			{GDI_R2_MERGEPEN, NULL, line_to_R2_MERGEPEN},
			{GDI_R2_WHITE, NULL, line_to_R2_WHITE}
		};
		const UINT32 map_size = sizeof(rop_map) / sizeof(rop_map[0]);
		HGDI_BITMAP hBmp_LineTo[LINTETO_NUMBER] = {NULL};
		gdiPalette* hPalette = &g;
		UINT32 penColor;
		const UINT32 format = colorFormats[i];
		g.format = format;

		for (i = 0; i < 256; i++)
			g.palette[i] = GetColor(format, i, i, i, 0xFF);

		rc = -1;

		if (!(hdc = gdi_GetDC()))
		{
			printf("failed to get gdi device context\n");
			goto fail;
		}

		hdc->format = format;
		gdi_SetNullClipRgn(hdc);
		penColor = GetColor(format, 0xFF, 0xFF, 0xFF, 0xFF);

		if (!(pen = gdi_CreatePen(1, 1, penColor, format, hPalette)))
		{
			printf("gdi_CreatePen failed\n");
			goto fail;
		}

		gdi_SelectObject(hdc, (HGDIOBJECT) pen);
		hBmp = gdi_CreateCompatibleBitmap(hdc, 16, 16);
		gdi_SelectObject(hdc, (HGDIOBJECT) hBmp);

		for (x = 0; x < LINTETO_NUMBER; x++)
		{
			hBmp_LineTo[x] = test_convert_to_bitmap(line_to_case[x], RawFormat, 0, 0, 0,
			                                        format, 0, 0, 0, 16, 16, hPalette);

			if (!hBmp_LineTo[x])
				goto fail;
		}

		for (x = 0; x < map_size; x++)
		{
			rop_map[x].bmp = test_convert_to_bitmap(rop_map[x].src, RawFormat, 0, 0, 0,
			                                        format, 0, 0, 0, 16, 16, hPalette);

			if (!rop_map[x].bmp)
				goto fail;
		}

		if (!test_line(hdc, hPalette, 0, 0, 15, 15, hBmp, hBmp_LineTo[0], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 15, 15, 0, 0, hBmp, hBmp_LineTo[1], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 15, 0, 0, 15, hBmp, hBmp_LineTo[2], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 0, 15, 15, 0, hBmp, hBmp_LineTo[3], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 0, 8, 15, 8, hBmp, hBmp_LineTo[4], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 15, 8, 0, 8, hBmp, hBmp_LineTo[5], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 8, 0, 8, 15, hBmp, hBmp_LineTo[6], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 8, 15, 8, 0, hBmp, hBmp_LineTo[7], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 4, 4, 12, 12, hBmp, hBmp_LineTo[8], 0, 0, 16, 16))
			goto fail;

		if (!test_line(hdc, hPalette, 0, 0, 16, 16, hBmp, hBmp_LineTo[9], 5, 5, 8, 8))
			goto fail;

		if (!test_line(hdc, hPalette, 0, 0, 26, 26, hBmp, hBmp_LineTo[10], 0, 0, 16,
		               16))
			goto fail;

		for (x = 0; x < map_size; x++)
		{
			char name[1024];
			_snprintf(name, sizeof(name), "%s [%s]", gdi_rop_to_string(rop_map[x].rop),
			          GetColorFormatName(hdc->format));

			/* Test Case 13: (0,0) -> (16,16), R2_NOTMERGEPEN */
			if (!gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS, hPalette))
			{
				printf("gdi_BitBlt failed (line #%u)\n", __LINE__);
				goto fail;
			}

			gdi_SetClipRgn(hdc, 0, 0, 16, 16);
			gdi_MoveToEx(hdc, 0, 0, NULL);
			gdi_SetROP2(hdc, rop_map[x].rop);
			gdi_LineTo(hdc, 16, 16);

			if (!test_assert_bitmaps_equal(hBmp, rop_map[x].bmp,
			                               name,
			                               hPalette))
				goto fail;
		}

		rc = 0;
	fail:

		for (x = 0; x < LINTETO_NUMBER; x++)
			gdi_DeleteObject((HGDIOBJECT) hBmp_LineTo[x]);

		for (x = 0; x < map_size; x++)
			gdi_DeleteObject((HGDIOBJECT) rop_map[x].bmp);

		gdi_DeleteObject((HGDIOBJECT) pen);
		gdi_DeleteDC(hdc);

		if (rc != 0)
			break;
	}

	return rc;
}
コード例 #10
0
ファイル: TestGdiEllipse.c プロジェクト: 99455125/FreeRDP
int TestGdiEllipse(int argc, char* argv[])
{
	int rc = -1;
	UINT32 i, j;
	const UINT32 RawFormat = PIXEL_FORMAT_RGB8;
	const UINT32 colorFormats[] =
	{
		PIXEL_FORMAT_RGB15,
		PIXEL_FORMAT_ARGB15,
		PIXEL_FORMAT_RGB16,
		PIXEL_FORMAT_RGB24,
		PIXEL_FORMAT_ARGB32,
		PIXEL_FORMAT_XRGB32,
		PIXEL_FORMAT_RGBA32,
		PIXEL_FORMAT_RGBX32,
		PIXEL_FORMAT_BGR15,
		PIXEL_FORMAT_ABGR15,
		PIXEL_FORMAT_BGR16,
		PIXEL_FORMAT_BGR24,
		PIXEL_FORMAT_ABGR32,
		PIXEL_FORMAT_XBGR32,
		PIXEL_FORMAT_BGRA32,
		PIXEL_FORMAT_BGRX32
	};
	const UINT32 number_formats = sizeof(colorFormats) / sizeof(colorFormats[0]);
	gdiPalette g;

	for (i = 0; i < number_formats; i++)
	{
		HGDI_DC hdc = NULL;
		HGDI_PEN pen = NULL;
		HGDI_BITMAP hBmp = NULL;
		HGDI_BITMAP hBmp_Ellipse_1 = NULL;
		HGDI_BITMAP hBmp_Ellipse_2 = NULL;
		HGDI_BITMAP hBmp_Ellipse_3 = NULL;
		const UINT32 format = colorFormats[i];
		gdiPalette* hPalette = &g;
		g.format = format;

		for (j = 0; j < 256; j++)
			g.palette[i] = GetColor(format, j, j, j, 0xFF);

		rc = -1;

		if (!(hdc = gdi_GetDC()))
		{
			printf("failed to get gdi device context\n");
			goto fail;
		}

		hdc->format = format;
		gdi_SetNullClipRgn(hdc);

		if (!(pen = gdi_CreatePen(1, 1, 0, format, hPalette)))
		{
			printf("gdi_CreatePen failed\n");
			goto fail;
		}

		gdi_SelectObject(hdc, (HGDIOBJECT) pen);
		hBmp = gdi_CreateCompatibleBitmap(hdc, 16, 16);
		gdi_SelectObject(hdc, (HGDIOBJECT) hBmp);
		hBmp_Ellipse_1 = test_convert_to_bitmap(ellipse_case_1, RawFormat, 0, 0, 0,
		                                        format, 0, 0, 0, 16, 16, hPalette);

		if (!hBmp_Ellipse_1)
			goto fail;

		hBmp_Ellipse_2 = test_convert_to_bitmap(ellipse_case_2, RawFormat, 0, 0, 0,
		                                        format, 0, 0, 0, 16, 16, hPalette);

		if (!hBmp_Ellipse_2)
			goto fail;

		hBmp_Ellipse_3 = test_convert_to_bitmap(ellipse_case_3, RawFormat, 0, 0, 0,
		                                        format, 0, 0, 0, 16, 16, hPalette);

		if (!hBmp_Ellipse_3)
			goto fail;

		/* Test Case 1: (0,0) -> (16, 16) */
		if (!gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS, hPalette))
		{
			printf("gdi_BitBlt failed (line #%u)\n", __LINE__);
			goto fail;
		}

		if (!gdi_Ellipse(hdc, 0, 0, 15, 15))
			goto fail;

		rc = 0;
	fail:
		gdi_DeleteObject((HGDIOBJECT) hBmp_Ellipse_1);
		gdi_DeleteObject((HGDIOBJECT) hBmp_Ellipse_2);
		gdi_DeleteObject((HGDIOBJECT) hBmp_Ellipse_3);
		gdi_DeleteObject((HGDIOBJECT) hBmp);
		gdi_DeleteObject((HGDIOBJECT) pen);
		gdi_DeleteDC(hdc);

		if (rc != 0)
			break;
	}

	return rc;
}
コード例 #11
0
ファイル: gdi.c プロジェクト: JunaidLoonat/FreeRDP
static BOOL gdi_init_primary(rdpGdi* gdi, UINT32 stride, UINT32 format,
                             BYTE* buffer, void (*pfree)(void*))
{
	gdi->primary = (gdiBitmap*) calloc(1, sizeof(gdiBitmap));

	if (format > 0)
		gdi->dstFormat = format;

	if (stride > 0)
		gdi->stride = stride;
	else
		gdi->stride = gdi->width * GetBytesPerPixel(gdi->dstFormat);

	if (!gdi->primary)
		goto fail_primary;

	if (!(gdi->primary->hdc = gdi_CreateCompatibleDC(gdi->hdc)))
		goto fail_hdc;

	if (!buffer)
	{
		gdi->primary->bitmap = gdi_CreateCompatibleBitmap(
		                           gdi->hdc, gdi->width, gdi->height);
	}
	else
	{
		gdi->primary->bitmap = gdi_CreateBitmapEx(gdi->width, gdi->height,
		                       gdi->dstFormat,
		                       gdi->stride,
		                       buffer, pfree);
	}

	gdi->stride = gdi->primary->bitmap->scanline;

	if (!gdi->primary->bitmap)
		goto fail_bitmap;

	gdi_SelectObject(gdi->primary->hdc, (HGDIOBJECT) gdi->primary->bitmap);
	gdi->primary->org_bitmap = NULL;
	gdi->primary_buffer = gdi->primary->bitmap->data;

	if (!(gdi->primary->hdc->hwnd = (HGDI_WND) calloc(1, sizeof(GDI_WND))))
		goto fail_hwnd;

	if (!(gdi->primary->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0)))
		goto fail_hwnd;

	gdi->primary->hdc->hwnd->invalid->null = TRUE;
	gdi->primary->hdc->hwnd->count = 32;

	if (!(gdi->primary->hdc->hwnd->cinvalid = (HGDI_RGN) calloc(
	            gdi->primary->hdc->hwnd->count, sizeof(GDI_RGN))))
		goto fail_hwnd;

	gdi->primary->hdc->hwnd->ninvalid = 0;

	if (!gdi->drawing)
		gdi->drawing = gdi->primary;

	return TRUE;
fail_hwnd:
	gdi_DeleteObject((HGDIOBJECT) gdi->primary->bitmap);
fail_bitmap:
	gdi_DeleteDC(gdi->primary->hdc);
fail_hdc:
	free(gdi->primary);
	gdi->primary = NULL;
fail_primary:
	return FALSE;
}
コード例 #12
0
ファイル: TestGdiLine.c プロジェクト: 10084462/FreeRDP
int TestGdiLine(int argc, char* argv[])
{
	HGDI_DC hdc;
	HGDI_PEN pen;
	BYTE* data;
	HGDI_BITMAP hBmp;
	HGDI_BITMAP hBmp_LineTo_1;
	HGDI_BITMAP hBmp_LineTo_2;
	HGDI_BITMAP hBmp_LineTo_3;
	HGDI_BITMAP hBmp_LineTo_4;
	HGDI_BITMAP hBmp_LineTo_5;
	HGDI_BITMAP hBmp_LineTo_6;
	HGDI_BITMAP hBmp_LineTo_7;
	HGDI_BITMAP hBmp_LineTo_8;
	HGDI_BITMAP hBmp_LineTo_9;
	HGDI_BITMAP hBmp_LineTo_10;
	HGDI_BITMAP hBmp_LineTo_11;
	HGDI_BITMAP hBmp_LineTo_R2_BLACK;
	HGDI_BITMAP hBmp_LineTo_R2_NOTMERGEPEN;
	HGDI_BITMAP hBmp_LineTo_R2_MASKNOTPEN;
	HGDI_BITMAP hBmp_LineTo_R2_NOTCOPYPEN;
	HGDI_BITMAP hBmp_LineTo_R2_MASKPENNOT;
	HGDI_BITMAP hBmp_LineTo_R2_NOT;
	HGDI_BITMAP hBmp_LineTo_R2_XORPEN;
	HGDI_BITMAP hBmp_LineTo_R2_NOTMASKPEN;
	HGDI_BITMAP hBmp_LineTo_R2_MASKPEN;
	HGDI_BITMAP hBmp_LineTo_R2_NOTXORPEN;
	HGDI_BITMAP hBmp_LineTo_R2_NOP;
	HGDI_BITMAP hBmp_LineTo_R2_MERGENOTPEN;
	HGDI_BITMAP hBmp_LineTo_R2_COPYPEN;
	HGDI_BITMAP hBmp_LineTo_R2_MERGEPENNOT;
	HGDI_BITMAP hBmp_LineTo_R2_MERGEPEN;
	HGDI_BITMAP hBmp_LineTo_R2_WHITE;
	rdpPalette* hPalette;
	HCLRCONV clrconv;
	int bitsPerPixel = 8;
	int bytesPerPixel = 1;

	hdc = gdi_GetDC();
	hdc->bitsPerPixel = bitsPerPixel;
	hdc->bytesPerPixel = bytesPerPixel;
	gdi_SetNullClipRgn(hdc);

	pen = gdi_CreatePen(1, 1, 0);
	gdi_SelectObject(hdc, (HGDIOBJECT) pen);

	hBmp = gdi_CreateCompatibleBitmap(hdc, 16, 16);
	gdi_SelectObject(hdc, (HGDIOBJECT) hBmp);

	hPalette = (rdpPalette*) gdi_GetSystemPalette();

	clrconv = (HCLRCONV) malloc(sizeof(CLRCONV));
	clrconv->alpha = 1;
	clrconv->invert = 0;
	clrconv->palette = hPalette;

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_1, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_1 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_2, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_2 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_3, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_3 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_4, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_4 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_5, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_5 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_5, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_5 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_6, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_6 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_7, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_7 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_8, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_8 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_9, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_9 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_10, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_10 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_case_11, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_11 = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_BLACK, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_BLACK = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOTMERGEPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOTMERGEPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MASKNOTPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MASKNOTPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOTCOPYPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOTCOPYPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MASKPENNOT, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MASKPENNOT = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOT, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOT = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_XORPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_XORPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOTMASKPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOTMASKPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MASKPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MASKPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOTXORPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOTXORPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_NOP, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_NOP = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MERGENOTPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MERGENOTPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_COPYPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_COPYPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MERGEPENNOT, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MERGEPENNOT = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_MERGEPEN, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_MERGEPEN = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	data = (BYTE*) freerdp_image_convert((BYTE*) line_to_R2_WHITE, NULL, 16, 16, 8, bitsPerPixel, clrconv);
	hBmp_LineTo_R2_WHITE = gdi_CreateBitmap(16, 16, bitsPerPixel, data);

	/* Test Case 1: (0,0) -> (15, 15) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_LineTo(hdc, 15, 15);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_1, "Case 1") < 0)
		return -1;

	/* Test Case 2: (15,15) -> (0,0) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 15, 15, NULL);
	gdi_LineTo(hdc, 0, 0);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_2, "Case 2") < 0)
		return -1;

	/* Test Case 3: (15,0) -> (0,15) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 15, 0, NULL);
	gdi_LineTo(hdc, 0, 15);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_3, "Case 3") < 0)
		return -1;

	/* Test Case 4: (0,15) -> (15,0) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 0, 15, NULL);
	gdi_LineTo(hdc, 15, 0);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_4, "Case 4") < 0)
		return -1;

	/* Test Case 5: (0,8) -> (15,8) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 0, 8, NULL);
	gdi_LineTo(hdc, 15, 8);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_5, "Case 5") < 0)
		return -1;

	/* Test Case 6: (15,8) -> (0,8) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 15, 8, NULL);
	gdi_LineTo(hdc, 0, 8);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_6, "Case 6") < 0)
		return -1;

	/* Test Case 7: (8,0) -> (8,15) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 8, 0, NULL);
	gdi_LineTo(hdc, 8, 15);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_7, "Case 7") < 0)
		return -1;

	/* Test Case 8: (8,15) -> (8,0) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 8, 15, NULL);
	gdi_LineTo(hdc, 8, 0);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_8, "Case 8") < 0)
		return -1;

	/* Test Case 9: (4,4) -> (12,12) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 4, 4, NULL);
	gdi_LineTo(hdc, 12, 12);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_9, "Case 9") < 0)
		return -1;

	/* Test Case 10: (12,12) -> (4,4) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_MoveToEx(hdc, 12, 12, NULL);
	gdi_LineTo(hdc, 4, 4);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_10, "Case 10") < 0)
		return -1;

	/* Test Case 11: (0,0) -> (+10,+10) */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_LineTo(hdc, 16 + 10, 16 + 10);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_11, "Case 11") < 0)
		return -1;

	/* Test Case 12: (0,0) -> (16,16), R2_BLACK */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_BLACK);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_BLACK, "Case 12") < 0)
		return -1;

	/* Test Case 13: (0,0) -> (16,16), R2_NOTMERGEPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOTMERGEPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOTMERGEPEN, "Case 13") < 0)
		return -1;

	/* Test Case 14: (0,0) -> (16,16), R2_MASKNOTPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MASKNOTPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MASKNOTPEN, "Case 14") < 0)
		return -1;

	/* Test Case 15: (0,0) -> (16,16), R2_NOTCOPYPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOTCOPYPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOTCOPYPEN, "Case 15") < 0)
		return -1;

	/* Test Case 16: (0,0) -> (16,16), R2_MASKPENNOT */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MASKPENNOT);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MASKPENNOT, "Case 16") < 0)
		return -1;

	/* Test Case 17: (0,0) -> (16,16), R2_NOT */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOT);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOT, "Case 17") < 0)
		return -1;

	/* Test Case 18: (0,0) -> (16,16), R2_XORPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_XORPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_XORPEN, "Case 18") < 0)
		return -1;

	/* Test Case 19: (0,0) -> (16,16), R2_NOTMASKPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOTMASKPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOTMASKPEN, "Case 19") < 0)
		return -1;

	/* Test Case 20: (0,0) -> (16,16), R2_MASKPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MASKPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MASKPEN, "Case 20") < 0)
		return -1;

	/* Test Case 21: (0,0) -> (16,16), R2_NOTXORPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOTXORPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOTXORPEN, "Case 21") < 0)
		return -1;

	/* Test Case 22: (0,0) -> (16,16), R2_NOP */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_NOP);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_NOP, "Case 22") < 0)
		return -1;

	/* Test Case 23: (0,0) -> (16,16), R2_MERGENOTPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MERGENOTPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MERGENOTPEN, "Case 23") < 0)
		return -1;

	/* Test Case 24: (0,0) -> (16,16), R2_COPYPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_COPYPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_COPYPEN, "Case 24") < 0)
		return -1;

	/* Test Case 25: (0,0) -> (16,16), R2_MERGEPENNOT */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MERGEPENNOT);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MERGEPENNOT, "Case 25") < 0)
		return -1;

	/* Test Case 26: (0,0) -> (16,16), R2_MERGEPEN */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_MERGEPEN);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_MERGEPEN, "Case 26") < 0)
		return -1;

	/* Test Case 27: (0,0) -> (16,16), R2_WHITE */
	gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS);
	gdi_SetClipRgn(hdc, 0, 0, 16, 16);
	gdi_MoveToEx(hdc, 0, 0, NULL);
	gdi_SetROP2(hdc, GDI_R2_WHITE);
	gdi_LineTo(hdc, 16, 16);

	if (test_assert_bitmaps_equal(hBmp, hBmp_LineTo_R2_WHITE, "Case 27") < 0)
		return -1;

	return 0;
}
コード例 #13
0
ファイル: TestGdiRect.c プロジェクト: Devolutions/FreeRDP
int test_gdi_FillRect(void)
{
	int rc = -1;
	HGDI_DC hdc = NULL;
	HGDI_RECT hRect = NULL;
	HGDI_BRUSH hBrush = NULL;
	HGDI_BITMAP hBitmap = NULL;
	UINT32 color;
	UINT32 pixel;
	UINT32 rawPixel;
	UINT32 x, y;
	UINT32 badPixels;
	UINT32 goodPixels;
	UINT32 width = 200;
	UINT32 height = 300;
	UINT32 left = 20;
	UINT32 top = 40;
	UINT32 right = 60;
	UINT32 bottom = 80;

	if (!(hdc = gdi_GetDC()))
	{
		printf("failed to get gdi device context\n");
		goto fail;
	}

	hdc->format = PIXEL_FORMAT_XRGB32;

	if (!(hRect = gdi_CreateRect(left, top, right, bottom)))
	{
		printf("gdi_CreateRect failed\n");
		goto fail;
	}

	hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height);
	ZeroMemory(hBitmap->data, width * height * GetBytesPerPixel(hdc->format));
	gdi_SelectObject(hdc, (HGDIOBJECT) hBitmap);
	color = FreeRDPGetColor(PIXEL_FORMAT_ARGB32, 0xAA, 0xBB, 0xCC, 0xFF);
	hBrush = gdi_CreateSolidBrush(color);
	gdi_FillRect(hdc, hRect, hBrush);
	badPixels = 0;
	goodPixels = 0;

	for (x = 0; x < width; x++)
	{
		for (y = 0; y < height; y++)
		{
			rawPixel = gdi_GetPixel(hdc, x, y);
			pixel = FreeRDPConvertColor(rawPixel, hdc->format, PIXEL_FORMAT_ARGB32, NULL);

			if (gdi_PtInRect(hRect, x, y))
			{
				if (pixel == color)
				{
					goodPixels++;
				}
				else
				{
					printf("actual:%08"PRIX32" expected:%08"PRIX32"\n", gdi_GetPixel(hdc, x, y), color);
					badPixels++;
				}
			}
			else
			{
				if (pixel == color)
				{
					badPixels++;
				}
				else
				{
					goodPixels++;
				}
			}
		}
	}

	if (goodPixels != width * height)
		goto fail;

	if (badPixels != 0)
		goto fail;

	rc = 0;
fail:
	gdi_DeleteObject((HGDIOBJECT) hBrush);
	gdi_DeleteObject((HGDIOBJECT) hBitmap);
	gdi_DeleteObject((HGDIOBJECT)hRect);
	gdi_DeleteDC(hdc);
	return rc;
}