mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libfreerdp-gdi: initial commit

Browse Source
This commit is contained in:
Marc-André Moreau 2011-06-30 16:17:55 -04:00
parent ed3a7a7627
commit f4337d6223
27 changed files with 5494 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
libfreerdp-gdi/gdi.h Normal file
View File

@ -0,0 +1,273 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Library
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifndef __GDI_H
#define __GDI_H
#include "color.h"
#include <freerdp/rfx.h>
#include <freerdp/freerdp.h>
#include <freerdp/utils/debug.h>
/* For more information, see [MS-RDPEGDI] */
/* Binary Raster Operations (ROP2) */
#define GDI_R2_BLACK 0x01 /* D = 0 */
#define GDI_R2_NOTMERGEPEN 0x02 /* D = ~(D | P) */
#define GDI_R2_MASKNOTPEN 0x03 /* D = D & ~P */
#define GDI_R2_NOTCOPYPEN 0x04 /* D = ~P */
#define GDI_R2_MASKPENNOT 0x05 /* D = P & ~D */
#define GDI_R2_NOT 0x06 /* D = ~D */
#define GDI_R2_XORPEN 0x07 /* D = D ^ P */
#define GDI_R2_NOTMASKPEN 0x08 /* D = ~(D & P) */
#define GDI_R2_MASKPEN 0x09 /* D = D & P */
#define GDI_R2_NOTXORPEN 0x0A /* D = ~(D ^ P) */
#define GDI_R2_NOP 0x0B /* D = D */
#define GDI_R2_MERGENOTPEN 0x0C /* D = D | ~P */
#define GDI_R2_COPYPEN 0x0D /* D = P */
#define GDI_R2_MERGEPENNOT 0x0E /* D = P | ~D */
#define GDI_R2_MERGEPEN 0x0F /* D = P | D */
#define GDI_R2_WHITE 0x10 /* D = 1 */
/* Ternary Raster Operations (ROP3) */
#define GDI_SRCCOPY 0x00CC0020 /* D = S */
#define GDI_SRCPAINT 0x00EE0086 /* D = S | D */
#define GDI_SRCAND 0x008800C6 /* D = S & D */
#define GDI_SRCINVERT 0x00660046 /* D = S ^ D */
#define GDI_SRCERASE 0x00440328 /* D = S & ~D */
#define GDI_NOTSRCCOPY 0x00330008 /* D = ~S */
#define GDI_NOTSRCERASE 0x001100A6 /* D = ~S & ~D */
#define GDI_MERGECOPY 0x00C000CA /* D = S & P */
#define GDI_MERGEPAINT 0x00BB0226 /* D = ~S | D */
#define GDI_PATCOPY 0x00F00021 /* D = P */
#define GDI_PATPAINT 0x00FB0A09 /* D = D | (P | ~S) */
#define GDI_PATINVERT 0x005A0049 /* D = P ^ D */
#define GDI_DSTINVERT 0x00550009 /* D = ~D */
#define GDI_BLACKNESS 0x00000042 /* D = 0 */
#define GDI_WHITENESS 0x00FF0062 /* D = 1 */
#define GDI_DSPDxax 0x00E20746 /* D = (S & P) | (~S & D) */
#define GDI_SPna 0x000C0324 /* D = S & ~P */
#define GDI_DSna 0x00220326 /* D = D & ~S */
/* Brush Styles */
#define GDI_BS_SOLID 0x00
#define GDI_BS_NULL 0x01
#define GDI_BS_HATCHED 0x02
#define GDI_BS_PATTERN 0x03
/* Hatch Patterns */
#define GDI_HS_HORIZONTAL 0x00
#define GDI_HS_VERTICAL 0x01
#define GDI_HS_FDIAGONAL 0x02
#define GDI_HS_BDIAGONAL 0x03
#define GDI_HS_CROSS 0x04
#define GDI_HS_DIAGCROSS 0x05
/* Pen Styles */
#define GDI_PS_SOLID 0x00
#define GDI_PS_DASH 0x01
#define GDI_PS_NULL 0x05
/* Background Modes */
#define GDI_OPAQUE 0x00000001
#define GDI_TRANSPARENT 0x00000002
/* GDI Object Types */
#define GDIOBJECT_BITMAP 0x00
#define GDIOBJECT_PEN 0x01
#define GDIOBJECT_PALETTE 0x02
#define GDIOBJECT_BRUSH 0x03
#define GDIOBJECT_RECT 0x04
#define GDIOBJECT_REGION 0x04
struct _GDIOBJECT
{
uint8 objectType;
};
typedef struct _GDIOBJECT GDIOBJECT;
typedef GDIOBJECT* HGDIOBJECT;
/* RGB encoded as 0x00BBGGRR */
typedef unsigned int GDI_COLOR;
typedef GDI_COLOR* LPGDI_COLOR;
struct _GDI_RECT
{
uint8 objectType;
int left;
int top;
int right;
int bottom;
};
typedef struct _GDI_RECT GDI_RECT;
typedef GDI_RECT* HGDI_RECT;
struct _GDI_RGN
{
uint8 objectType;
int x; /* left */
int y; /* top */
int w; /* width */
int h; /* height */
int null; /* null region */
};
typedef struct _GDI_RGN GDI_RGN;
typedef GDI_RGN* HGDI_RGN;
struct _GDI_BITMAP
{
uint8 objectType;
int bytesPerPixel;
int bitsPerPixel;
int width;
int height;
int scanline;
uint8* data;
};
typedef struct _GDI_BITMAP GDI_BITMAP;
typedef GDI_BITMAP* HGDI_BITMAP;
struct _GDI_PEN
{
uint8 objectType;
int style;
int width;
int posX;
int posY;
GDI_COLOR color;
};
typedef struct _GDI_PEN GDI_PEN;
typedef GDI_PEN* HGDI_PEN;
struct _GDI_PALETTEENTRY
{
uint8 red;
uint8 green;
uint8 blue;
};
typedef struct _GDI_PALETTEENTRY GDI_PALETTEENTRY;
struct _GDI_PALETTE
{
uint16 count;
GDI_PALETTEENTRY *entries;
};
typedef struct _GDI_PALETTE GDI_PALETTE;
typedef GDI_PALETTE* HGDI_PALETTE;
struct _GDI_POINT
{
int x;
int y;
};
typedef struct _GDI_POINT GDI_POINT;
typedef GDI_POINT* HGDI_POINT;
struct _GDI_BRUSH
{
uint8 objectType;
int style;
HGDI_BITMAP pattern;
GDI_COLOR color;
};
typedef struct _GDI_BRUSH GDI_BRUSH;
typedef GDI_BRUSH* HGDI_BRUSH;
struct _GDI_WND
{
HGDI_RGN invalid;
};
typedef struct _GDI_WND GDI_WND;
typedef GDI_WND* HGDI_WND;
struct _GDI_DC
{
HGDIOBJECT selectedObject;
int bytesPerPixel;
int bitsPerPixel;
GDI_COLOR bkColor;
GDI_COLOR textColor;
HGDI_BRUSH brush;
HGDI_RGN clip;
HGDI_PEN pen;
HGDI_WND hwnd;
int drawMode;
int bkMode;
int alpha;
int invert;
int rgb555;
};
typedef struct _GDI_DC GDI_DC;
typedef GDI_DC* HGDI_DC;
struct _GDI_IMAGE
{
HGDI_DC hdc;
HGDI_BITMAP bitmap;
HGDI_BITMAP org_bitmap;
};
typedef struct _GDI_IMAGE GDI_IMAGE;
typedef GDI_IMAGE* HGDI_IMAGE;
struct _GDI
{
int width;
int height;
int dstBpp;
int srcBpp;
int cursor_x;
int cursor_y;
int bytesPerPixel;
HGDI_DC hdc;
HCLRCONV clrconv;
GDI_IMAGE *primary;
GDI_IMAGE *drawing;
uint8* primary_buffer;
GDI_COLOR textColor;
void * rfx_context;
GDI_IMAGE *tile;
};
typedef struct _GDI GDI;
uint32 gdi_rop3_code(uint8 code);
void gdi_copy_mem(uint8 *d, uint8 *s, int n);
void gdi_copy_memb(uint8 *d, uint8 *s, int n);
uint8* gdi_get_bitmap_pointer(HGDI_DC hdcBmp, int x, int y);
uint8* gdi_get_brush_pointer(HGDI_DC hdcBrush, int x, int y);
int gdi_is_mono_pixel_set(uint8* data, int x, int y, int width);
int gdi_init(rdpInst * inst, uint32 flags);
GDI_IMAGE* gdi_bitmap_new(GDI *gdi, int width, int height, int bpp, uint8* data);
void gdi_bitmap_free(GDI_IMAGE *gdi_bmp);
void gdi_free(rdpInst* inst);
#define SET_GDI(_inst, _gdi) (_inst)->param2 = _gdi
#define GET_GDI(_inst) ((GDI*) ((_inst)->param2))
#ifdef WITH_DEBUG_GDI
#define DEBUG_GDI(fmt, ...) DEBUG_CLASS(GDI, fmt, ## __VA_ARGS__)
#else
#define DEBUG_GDI(fmt, ...) DEBUG_NULL(fmt, ## __VA_ARGS__)
#endif
#endif /* __GDI_H */

1044
libfreerdp-gdi/gdi_16bpp.c Normal file
View File

File diff suppressed because it is too large Load Diff

28
libfreerdp-gdi/gdi_16bpp.h Normal file
View File

@ -0,0 +1,28 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI 16bpp Internal Buffer Routines
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/freerdp.h>
#include "gdi.h"
typedef void (*pSetPixel16_ROP2)(uint16 *pixel, uint16 *pen);
int FillRect_16bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
int BitBlt_16bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
int PatBlt_16bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
int LineTo_16bpp(HGDI_DC hdc, int nXEnd, int nYEnd);

1117
libfreerdp-gdi/gdi_32bpp.c Normal file
View File

File diff suppressed because it is too large Load Diff

28
libfreerdp-gdi/gdi_32bpp.h Normal file
View File

@ -0,0 +1,28 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI 32bpp Internal Buffer Routines
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/freerdp.h>
#include "gdi.h"
typedef void (*pSetPixel32_ROP2)(uint32 *pixel, uint32 *pen);
int FillRect_32bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
int BitBlt_32bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
int PatBlt_32bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
int LineTo_32bpp(HGDI_DC hdc, int nXEnd, int nYEnd);

875
libfreerdp-gdi/gdi_8bpp.c Normal file
View File

@ -0,0 +1,875 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI 8bpp Internal Buffer Routines
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "color.h"
#include "gdi_pen.h"
#include "gdi_bitmap.h"
#include "gdi_region.h"
#include "gdi_clipping.h"
#include "gdi_drawing.h"
#include "gdi_8bpp.h"
int FillRect_8bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr)
{
/* TODO: Implement 8bpp FillRect() */
return 0;
}
static int BitBlt_BLACKNESS_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight)
{
int y;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
memset(dstp, 0, nWidth * hdcDest->bytesPerPixel);
}
return 0;
}
static int BitBlt_WHITENESS_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight)
{
int y;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
memset(dstp, 0xFF, nWidth * hdcDest->bytesPerPixel);
}
return 0;
}
static int BitBlt_SRCCOPY_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int y;
uint8 *srcp;
uint8 *dstp;
if ((hdcDest->selectedObject != hdcSrc->selectedObject) ||
gdi_CopyOverlap(nXDest, nYDest, nWidth, nHeight, nXSrc, nYSrc) == 0)
{
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (srcp != 0 && dstp != 0)
{
gdi_copy_mem(dstp, srcp, nWidth * hdcDest->bytesPerPixel);
}
}
return 0;
}
if (nYSrc < nYDest)
{
/* copy down (bottom to top) */
for (y = nHeight - 1; y >= 0; y--)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (srcp != 0 && dstp != 0)
{
gdi_copy_mem(dstp, srcp, nWidth * hdcDest->bytesPerPixel);
}
}
}
else if (nYSrc > nYDest || nXSrc > nXDest)
{
/* copy up or left (top top bottom) */
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (srcp != 0 && dstp != 0)
{
gdi_copy_mem(dstp, srcp, nWidth * hdcDest->bytesPerPixel);
}
}
}
else
{
/* copy straight right */
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (srcp != 0 && dstp != 0)
{
gdi_copy_memb(dstp, srcp, nWidth * hdcDest->bytesPerPixel);
}
}
}
return 0;
}
static int BitBlt_NOTSRCCOPY_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = ~(*srcp);
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_DSTINVERT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight)
{
int x, y;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = ~(*dstp);
dstp++;
}
}
}
return 0;
}
static int BitBlt_SRCERASE_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = *srcp & ~(*dstp);
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_NOTSRCERASE_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = ~(*srcp) & ~(*dstp);
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_SRCINVERT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp ^= *srcp;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_SRCAND_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp &= *srcp;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_SRCPAINT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp |= *srcp;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_DSPDxax_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
/* TODO: Implement 8bpp DSPDxax BitBlt */
return 0;
}
static int BitBlt_SPna_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
uint8 *patp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
patp = gdi_get_brush_pointer(hdcDest, x, y);
*dstp = *srcp & ~(*patp);
patp++;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_DSna_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = ~(*srcp) & (*dstp);
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_MERGECOPY_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
uint8 *patp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
patp = gdi_get_brush_pointer(hdcDest, x, y);
*dstp = *srcp & *patp;
patp++;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_MERGEPAINT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = ~(*srcp) | *dstp;
srcp++;
dstp++;
}
}
}
return 0;
}
static int BitBlt_PATCOPY_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight)
{
int x, y;
uint8 *dstp;
uint8 *patp;
uint8 palIndex;
if(hdcDest->brush->style == GDI_BS_SOLID)
{
palIndex = ((hdcDest->brush->color >> 16) & 0xFF);
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp = palIndex;
dstp++;
}
}
}
}
else
{
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
patp = gdi_get_brush_pointer(hdcDest, x, y);
*dstp = *patp;
patp++;
dstp++;
}
}
}
}
return 0;
}
static int BitBlt_PATINVERT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight)
{
int x, y;
uint8 *dstp;
uint8 *patp;
uint8 palIndex;
if(hdcDest->brush->style == GDI_BS_SOLID)
{
palIndex = ((hdcDest->brush->color >> 16) & 0xFF);
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
*dstp ^= palIndex;
dstp++;
}
}
}
}
else
{
for (y = 0; y < nHeight; y++)
{
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
patp = gdi_get_brush_pointer(hdcDest, x, y);
*dstp = *patp ^ *dstp;
patp++;
dstp++;
}
}
}
}
return 0;
}
static int BitBlt_PATPAINT_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc)
{
int x, y;
uint8 *srcp;
uint8 *dstp;
uint8 *patp;
for (y = 0; y < nHeight; y++)
{
srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc, nYSrc + y);
dstp = gdi_get_bitmap_pointer(hdcDest, nXDest, nYDest + y);
if (dstp != 0)
{
for (x = 0; x < nWidth; x++)
{
patp = gdi_get_brush_pointer(hdcDest, x, y);
*dstp = *dstp | (*patp | ~(*srcp));
patp++;
srcp++;
dstp++;
}
}
}
return 0;
}
int BitBlt_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop)
{
if (hdcSrc != NULL)
{
if (gdi_ClipCoords(hdcDest, &nXDest, &nYDest, &nWidth, &nHeight, &nXSrc, &nYSrc) == 0)
return 0;
}
else
{
if (gdi_ClipCoords(hdcDest, &nXDest, &nYDest, &nWidth, &nHeight, NULL, NULL) == 0)
return 0;
}
gdi_InvalidateRegion(hdcDest, nXDest, nYDest, nWidth, nHeight);
switch (rop)
{
case GDI_BLACKNESS:
return BitBlt_BLACKNESS_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight);
break;
case GDI_WHITENESS:
return BitBlt_WHITENESS_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight);
break;
case GDI_SRCCOPY:
return BitBlt_SRCCOPY_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_SPna:
return BitBlt_SPna_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_DSna:
return BitBlt_DSna_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_DSPDxax:
return BitBlt_DSPDxax_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_NOTSRCCOPY:
return BitBlt_NOTSRCCOPY_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_DSTINVERT:
return BitBlt_DSTINVERT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight);
break;
case GDI_SRCERASE:
return BitBlt_SRCERASE_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_NOTSRCERASE:
return BitBlt_NOTSRCERASE_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_SRCINVERT:
return BitBlt_SRCINVERT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_SRCAND:
return BitBlt_SRCAND_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_SRCPAINT:
return BitBlt_SRCPAINT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_MERGECOPY:
return BitBlt_MERGECOPY_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_MERGEPAINT:
return BitBlt_MERGEPAINT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
case GDI_PATCOPY:
return BitBlt_PATCOPY_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight);
break;
case GDI_PATINVERT:
return BitBlt_PATINVERT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight);
break;
case GDI_PATPAINT:
return BitBlt_PATPAINT_8bpp(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc);
break;
}
printf("BitBlt: unknown rop: 0x%08X\n", rop);
return 1;
}
int PatBlt_8bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop)
{
if (gdi_ClipCoords(hdc, &nXLeft, &nYLeft, &nWidth, &nHeight, NULL, NULL) == 0)
return 0;
gdi_InvalidateRegion(hdc, nXLeft, nYLeft, nWidth, nHeight);
switch (rop)
{
case GDI_PATCOPY:
return BitBlt_PATCOPY_8bpp(hdc, nXLeft, nYLeft, nWidth, nHeight);
break;
case GDI_PATINVERT:
return BitBlt_PATINVERT_8bpp(hdc, nXLeft, nYLeft, nWidth, nHeight);
break;
case GDI_DSTINVERT:
return BitBlt_DSTINVERT_8bpp(hdc, nXLeft, nYLeft, nWidth, nHeight);
break;
case GDI_BLACKNESS:
return BitBlt_BLACKNESS_8bpp(hdc, nXLeft, nYLeft, nWidth, nHeight);
break;
case GDI_WHITENESS:
return BitBlt_WHITENESS_8bpp(hdc, nXLeft, nYLeft, nWidth, nHeight);
break;
}
printf("PatBlt: unknown rop: 0x%08X", rop);
return 1;
}
void SetPixel_BLACK_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = 0 */
*pixel = 0;
}
void SetPixel_NOTMERGEPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = ~(D | P) */
*pixel = ~(*pixel | *pen);
}
void SetPixel_MASKNOTPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = D & ~P */
*pixel &= ~(*pen);
}
void SetPixel_NOTCOPYPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = ~P */
*pixel = ~(*pen);
}
void SetPixel_MASKPENNOT_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = P & ~D */
*pixel = *pen & ~*pixel;
}
void SetPixel_NOT_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = ~D */
*pixel = ~(*pixel);
}
void SetPixel_XORPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = D ^ P */
*pixel = *pixel ^ *pen;
}
void SetPixel_NOTMASKPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = ~(D & P) */
*pixel = ~(*pixel & *pen);
}
void SetPixel_MASKPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = D & P */
*pixel &= *pen;
}
void SetPixel_NOTXORPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = ~(D ^ P) */
*pixel = ~(*pixel ^ *pen);
}
void SetPixel_NOP_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = D */
}
void SetPixel_MERGENOTPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = D | ~P */
*pixel |= ~(*pen);
}
void SetPixel_COPYPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = P */
*pixel = *pen;
}
void SetPixel_MERGEPENNOT_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = P | ~D */
*pixel = *pen | ~(*pixel);
}
void SetPixel_MERGEPEN_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = P | D */
*pixel |= *pen;
}
void SetPixel_WHITE_8bpp(uint8 *pixel, uint8 *pen)
{
/* D = 1 */
*pixel = 0xFF;
}
pSetPixel8_ROP2 SetPixel8_ROP2_[16] =
{
SetPixel_BLACK_8bpp,
SetPixel_NOTMERGEPEN_8bpp,
SetPixel_MASKNOTPEN_8bpp,
SetPixel_NOTCOPYPEN_8bpp,
SetPixel_MASKPENNOT_8bpp,
SetPixel_NOT_8bpp,
SetPixel_XORPEN_8bpp,
SetPixel_NOTMASKPEN_8bpp,
SetPixel_MASKPEN_8bpp,
SetPixel_NOTXORPEN_8bpp,
SetPixel_NOP_8bpp,
SetPixel_MERGENOTPEN_8bpp,
SetPixel_COPYPEN_8bpp,
SetPixel_MERGEPENNOT_8bpp,
SetPixel_MERGEPEN_8bpp,
SetPixel_WHITE_8bpp
};
int LineTo_8bpp(HGDI_DC hdc, int nXEnd, int nYEnd)
{
int x, y;
int x1, y1;
int x2, y2;
int e, e2;
int dx, dy;
int sx, sy;
HGDI_BITMAP bmp;
int bx1, by1;
int bx2, by2;
int irop2;
uint8 pen;
uint8 *pixel;
x1 = hdc->pen->posX;
y1 = hdc->pen->posY;
x2 = nXEnd;
y2 = nYEnd;
dx = (x1 > x2) ? x1 - x2 : x2 - x1;
dy = (y1 > y2) ? y1 - y2 : y2 - y1;
sx = (x1 < x2) ? 1 : -1;
sy = (y1 < y2) ? 1 : -1;
e = dx - dy;
x = x1;
y = y1;
irop2 = gdi_GetROP2(hdc) - 1;
bmp = (HGDI_BITMAP) hdc->selectedObject;
if (hdc->clip->null)
{
bx1 = (x1 < x2) ? x1 : x2;
by1 = (y1 < y2) ? y1 : y2;
bx2 = (x1 > x2) ? x1 : x2;
by2 = (y1 > y2) ? y1 : y2;
}
else
{
bx1 = hdc->clip->x;
by1 = hdc->clip->y;
bx2 = bx1 + hdc->clip->w - 1;
by2 = by1 + hdc->clip->h - 1;
}
pen = gdi_GetPenColor_8bpp(hdc->pen);
while (1)
{
if (!(x == x2 && y == y2))
{
if ((x >= bx1 && x <= bx2) && (y >= by1 && y <= by2))
{
pixel = gdi_GetPointer_8bpp(bmp, x, y);
SetPixel8_ROP2_[irop2](pixel, &pen);
}
}
else
{
break;
}
e2 = 2 * e;
if (e2 > -dy)
{
e -= dy;
x += sx;
}
if (e2 < dx)
{
e += dx;
y += sy;
}
}
return 1;
}

28
libfreerdp-gdi/gdi_8bpp.h Normal file
View File

@ -0,0 +1,28 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI 8bpp Internal Buffer Routines
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/freerdp.h>
#include "gdi.h"
typedef void (*pSetPixel8_ROP2)(uint8 *pixel, uint8 *pen);
int FillRect_8bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
int BitBlt_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
int PatBlt_8bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
int LineTo_8bpp(HGDI_DC hdc, int nXEnd, int nYEnd);

189
libfreerdp-gdi/gdi_bitmap.c Normal file
View File

@ -0,0 +1,189 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Bitmap Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "color.h"
#include "gdi_32bpp.h"
#include "gdi_16bpp.h"
#include "gdi_8bpp.h"
#include "gdi_bitmap.h"
pBitBlt BitBlt_[5] =
{
NULL,
BitBlt_8bpp,
BitBlt_16bpp,
NULL,
BitBlt_32bpp
};
/**
* Get pixel at the given coordinates.\n
* @msdn{dd144909}
* @param hdc device context
* @param nXPos pixel x position
* @param nYPos pixel y position
* @return pixel color
*/
GDI_COLOR gdi_GetPixel(HGDI_DC hdc, int nXPos, int nYPos)
{
HGDI_BITMAP hBmp = (HGDI_BITMAP) hdc->selectedObject;
GDI_COLOR* colorp = (GDI_COLOR*)&(hBmp->data[(nYPos * hBmp->width * hdc->bytesPerPixel) + nXPos * hdc->bytesPerPixel]);
return (GDI_COLOR) *colorp;
}
uint8 gdi_GetPixel_8bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return *((uint8*)&(hBmp->data[(Y * hBmp->width) + X]));
}
uint16 gdi_GetPixel_16bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return *((uint16*)&(hBmp->data[(Y * hBmp->width * 2) + X * 2]));
}
uint32 gdi_GetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return *((uint32*)&(hBmp->data[(Y * hBmp->width * 4) + X * 4]));
}
uint8* gdi_GetPointer_8bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return ((uint8*)&(hBmp->data[(Y * hBmp->width) + X]));
}
uint16* gdi_GetPointer_16bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return ((uint16*)&(hBmp->data[(Y * hBmp->width * 2) + X * 2]));
}
uint32* gdi_GetPointer_32bpp(HGDI_BITMAP hBmp, int X, int Y)
{
return ((uint32*)&(hBmp->data[(Y * hBmp->width * 4) + X * 4]));
}
/**
* Set pixel at the given coordinates.\n
* @msdn{dd145078}
* @param hdc device context
* @param X pixel x position
* @param Y pixel y position
* @param crColor new pixel color
* @return
*/
GDI_COLOR gdi_SetPixel(HGDI_DC hdc, int X, int Y, GDI_COLOR crColor)
{
HGDI_BITMAP hBmp = (HGDI_BITMAP) hdc->selectedObject;
*((GDI_COLOR*)&(hBmp->data[(Y * hBmp->width * hdc->bytesPerPixel) + X * hdc->bytesPerPixel])) = crColor;
return 0;
}
void gdi_SetPixel_8bpp(HGDI_BITMAP hBmp, int X, int Y, uint8 pixel)
{
*((uint8*)&(hBmp->data[(Y * hBmp->width) + X])) = pixel;
}
void gdi_SetPixel_16bpp(HGDI_BITMAP hBmp, int X, int Y, uint16 pixel)
{
*((uint16*)&(hBmp->data[(Y * hBmp->width * 2) + X * 2])) = pixel;
}
void gdi_SetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y, uint32 pixel)
{
*((uint32*)&(hBmp->data[(Y * hBmp->width * 4) + X * 4])) = pixel;
}
/**
* Create a new bitmap with the given width, height, color format and pixel buffer.\n
* @msdn{dd183485}
* @param nWidth width
* @param nHeight height
* @param cBitsPerPixel bits per pixel
* @param data pixel buffer
* @return new bitmap
*/
HGDI_BITMAP gdi_CreateBitmap(int nWidth, int nHeight, int cBitsPerPixel, uint8* data)
{
HGDI_BITMAP hBitmap = (HGDI_BITMAP) malloc(sizeof(GDI_BITMAP));
hBitmap->objectType = GDIOBJECT_BITMAP;
hBitmap->bitsPerPixel = cBitsPerPixel;
hBitmap->bytesPerPixel = (cBitsPerPixel + 1) / 8;
hBitmap->scanline = nWidth * hBitmap->bytesPerPixel;
hBitmap->width = nWidth;
hBitmap->height = nHeight;
hBitmap->data = data;
return hBitmap;
}
/**
* Create a new bitmap of the given width and height compatible with the current device context.\n
* @msdn{dd183488}
* @param hdc device context
* @param nWidth width
* @param nHeight height
* @return new bitmap
*/
HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, int nWidth, int nHeight)
{
HGDI_BITMAP hBitmap = (HGDI_BITMAP) malloc(sizeof(GDI_BITMAP));
hBitmap->objectType = GDIOBJECT_BITMAP;
hBitmap->bytesPerPixel = hdc->bytesPerPixel;
hBitmap->bitsPerPixel = hdc->bitsPerPixel;
hBitmap->width = nWidth;
hBitmap->height = nHeight;
hBitmap->data = malloc(nWidth * nHeight * hBitmap->bytesPerPixel);
hBitmap->scanline = nWidth * hBitmap->bytesPerPixel;
return hBitmap;
}
/**
* Perform a bit blit operation on the given pixel buffers.\n
* @msdn{dd183370}
* @param hdcDest destination device context
* @param nXDest destination x1
* @param nYDest destination y1
* @param nWidth width
* @param nHeight height
* @param hdcSrc source device context
* @param nXSrc source x1
* @param nYSrc source y1
* @param rop raster operation code
* @return 1 if successful, 0 otherwise
*/
int gdi_BitBlt(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop)
{
pBitBlt _BitBlt = BitBlt_[IBPP(hdcDest->bitsPerPixel)];
if (_BitBlt != NULL)
return _BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, rop);
else
return 0;
}

42
libfreerdp-gdi/gdi_bitmap.h Normal file
View File

@ -0,0 +1,42 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Bitmap Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_BITMAP_H
#define __GDI_BITMAP_H
#include "gdi.h"
GDI_COLOR gdi_GetPixel(HGDI_DC hdc, int nXPos, int nYPos);
GDI_COLOR gdi_SetPixel(HGDI_DC hdc, int X, int Y, GDI_COLOR crColor);
uint8 gdi_GetPixel_8bpp(HGDI_BITMAP hBmp, int X, int Y);
uint16 gdi_GetPixel_16bpp(HGDI_BITMAP hBmp, int X, int Y);
uint32 gdi_GetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y);
uint8* gdi_GetPointer_8bpp(HGDI_BITMAP hBmp, int X, int Y);
uint16* gdi_GetPointer_16bpp(HGDI_BITMAP hBmp, int X, int Y);
uint32* gdi_GetPointer_32bpp(HGDI_BITMAP hBmp, int X, int Y);
void gdi_SetPixel_8bpp(HGDI_BITMAP hBmp, int X, int Y, uint8 pixel);
void gdi_SetPixel_16bpp(HGDI_BITMAP hBmp, int X, int Y, uint16 pixel);
void gdi_SetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y, uint32 pixel);
HGDI_BITMAP gdi_CreateBitmap(int nWidth, int nHeight, int cBitsPerPixel, uint8* data);
HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, int nWidth, int nHeight);
int gdi_BitBlt(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
typedef int (*pBitBlt)(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
#endif /* __GDI_BITMAP_H */

96
libfreerdp-gdi/gdi_brush.c Normal file
View File

@ -0,0 +1,96 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Brush Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* GDI Brush Functions: http://msdn.microsoft.com/en-us/library/dd183395/ */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_32bpp.h"
#include "gdi_16bpp.h"
#include "gdi_8bpp.h"
#include "gdi_brush.h"
pPatBlt PatBlt_[5] =
{
NULL,
PatBlt_8bpp,
PatBlt_16bpp,
NULL,
PatBlt_32bpp
};
/**
* Create a new solid brush.\n
* @msdn{dd183518}
* @param crColor brush color
* @return new brush
*/
HGDI_BRUSH gdi_CreateSolidBrush(GDI_COLOR crColor)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) malloc(sizeof(GDI_BRUSH));
hBrush->objectType = GDIOBJECT_BRUSH;
hBrush->style = GDI_BS_SOLID;
hBrush->color = crColor;
return hBrush;
}
/**
* Create a new pattern brush.\n
* @msdn{dd183508}
* @param hbmp pattern bitmap
* @return new brush
*/
HGDI_BRUSH gdi_CreatePatternBrush(HGDI_BITMAP hbmp)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) malloc(sizeof(GDI_BRUSH));
hBrush->objectType = GDIOBJECT_BRUSH;
hBrush->style = GDI_BS_PATTERN;
hBrush->pattern = hbmp;
return hBrush;
}
/**
* Perform a pattern blit operation on the given pixel buffer.\n
* @msdn{dd162778}
* @param hdc device context
* @param nXLeft x1
* @param nYLeft y1
* @param nWidth width
* @param nHeight height
* @param rop raster operation code
* @return 1 if successful, 0 otherwise
*/
int gdi_PatBlt(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop)
{
pPatBlt _PatBlt = PatBlt_[IBPP(hdc->bitsPerPixel)];
if (_PatBlt != NULL)
return _PatBlt(hdc, nXLeft, nYLeft, nWidth, nHeight, rop);
else
return 0;
}

31
libfreerdp-gdi/gdi_brush.h Normal file
View File

@ -0,0 +1,31 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Brush Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_BRUSH_H
#define __GDI_BRUSH_H
#include "gdi.h"
HGDI_BRUSH gdi_CreateSolidBrush(GDI_COLOR crColor);
HGDI_BRUSH gdi_CreatePatternBrush(HGDI_BITMAP hbmp);
int gdi_PatBlt(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
typedef int (*pPatBlt)(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
#endif /* __GDI_BRUSH_H */

172
libfreerdp-gdi/gdi_clipping.c Normal file
View File

@ -0,0 +1,172 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Clipping Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_region.h"
#include "gdi_clipping.h"
int gdi_SetClipRgn(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight)
{
return gdi_SetRgn(hdc->clip, nXLeft, nYLeft, nWidth, nHeight);
}
/**
* Get the current clipping region.\n
* @msdn{dd144866}
* @param hdc device context
* @return clipping region
*/
HGDI_RGN gdi_GetClipRgn(HGDI_DC hdc)
{
return hdc->clip;
}
/**
* Set the current clipping region to null.
* @param hdc device context
* @return
*/
int gdi_SetNullClipRgn(HGDI_DC hdc)
{
gdi_SetClipRgn(hdc, 0, 0, 0, 0);
hdc->clip->null = 1;
return 0;
}
/**
* Clip coordinates according to clipping region
* @param hdc device context
* @param x x1
* @param y y1
* @param w width
* @param h height
* @param srcx source x1
* @param srcy source y1
* @return 1 if there is something to draw, 0 otherwise
*/
int gdi_ClipCoords(HGDI_DC hdc, int *x, int *y, int *w, int *h, int *srcx, int *srcy)
{
GDI_RECT bmp;
GDI_RECT clip;
GDI_RECT coords;
HGDI_BITMAP hBmp;
int dx = 0;
int dy = 0;
int draw = 1;
if (hdc == NULL)
return 0;
hBmp = (HGDI_BITMAP) hdc->selectedObject;
if (hBmp != NULL)
{
if (hdc->clip->null)
{
gdi_CRgnToRect(0, 0, hBmp->width, hBmp->height, &clip);
}
else
{
gdi_RgnToRect(hdc->clip, &clip);
gdi_CRgnToRect(0, 0, hBmp->width, hBmp->height, &bmp);
if (clip.left < bmp.left)
clip.left = bmp.left;
if (clip.right > bmp.right)
clip.right = bmp.right;
if (clip.top < bmp.top)
clip.top = bmp.top;
if (clip.bottom > bmp.bottom)
clip.bottom = bmp.bottom;
}
}
else
{
gdi_RgnToRect(hdc->clip, &clip);
}
gdi_CRgnToRect(*x, *y, *w, *h, &coords);
if (coords.right >= clip.left && coords.left <= clip.right &&
coords.bottom >= clip.top && coords.top <= clip.bottom)
{
/* coordinates overlap with clipping region */
if (coords.left < clip.left)
{
dx = (clip.left - coords.left) + 1;
coords.left = clip.left;
}
if (coords.right > clip.right)
coords.right = clip.right;
if (coords.top < clip.top)
{
dy = (clip.top - coords.top) + 1;
coords.top = clip.top;
}
if (coords.bottom > clip.bottom)
coords.bottom = clip.bottom;
}
else
{
/* coordinates do not overlap with clipping region */
coords.left = 0;
coords.right = 0;
coords.top = 0;
coords.bottom = 0;
draw = 0;
}
if (srcx != NULL)
{
if (dx > 0)
{
*srcx += dx - 1;
}
}
if (srcy != NULL)
{
if (dy > 0)
{
*srcy += dy - 1;
}
}
gdi_RectToCRgn(&coords, x, y, w, h);
return draw;
}

30
libfreerdp-gdi/gdi_clipping.h Normal file
View File

@ -0,0 +1,30 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Clipping Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_CLIPPING_H
#define __GDI_CLIPPING_H
#include "gdi.h"
int gdi_SetClipRgn(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight);
HGDI_RGN gdi_GetClipRgn(HGDI_DC hdc);
int gdi_SetNullClipRgn(HGDI_DC hdc);
int gdi_ClipCoords(HGDI_DC hdc, int *x, int *y, int *w, int *h, int *srcx, int *srcy);
#endif /* __GDI_CLIPPING_H */

190
libfreerdp-gdi/gdi_dc.c Normal file
View File

@ -0,0 +1,190 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Device Context Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Device Context Functions: http://msdn.microsoft.com/en-us/library/dd183554 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_region.h"
#include "gdi_dc.h"
/**
* Get the current device context (a new one is created each time).\n
* @msdn{dd144871}
* @return current device context
*/
HGDI_DC gdi_GetDC()
{
HGDI_DC hDC = (HGDI_DC) malloc(sizeof(GDI_DC));
hDC->bytesPerPixel = 4;
hDC->bitsPerPixel = 32;
hDC->drawMode = GDI_R2_BLACK;
hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0);
hDC->clip->null = 1;
hDC->hwnd = NULL;
return hDC;
}
/**
* Create a new device context compatible with the given device context.\n
* @msdn{dd183489}
* @param hdc device context
* @return new compatible device context
*/
HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc)
{
HGDI_DC hDC = (HGDI_DC) malloc(sizeof(GDI_DC));
hDC->bytesPerPixel = hdc->bytesPerPixel;
hDC->bitsPerPixel = hdc->bitsPerPixel;
hDC->drawMode = hdc->drawMode;
hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0);
hDC->clip->null = 1;
hDC->hwnd = NULL;
hDC->alpha = hdc->alpha;
hDC->invert = hdc->invert;
hDC->rgb555 = hdc->rgb555;
return hDC;
}
/**
* Select a GDI object in the current device context.\n
* @msdn{dd162957}
* @param hdc device context
* @param hgdiobject new selected GDI object
* @return previous selected GDI object
*/
HGDIOBJECT gdi_SelectObject(HGDI_DC hdc, HGDIOBJECT hgdiobject)
{
HGDIOBJECT previousSelectedObject = hdc->selectedObject;
if (hgdiobject == NULL)
return NULL;
if (hgdiobject->objectType == GDIOBJECT_BITMAP)
{
hdc->selectedObject = hgdiobject;
}
else if (hgdiobject->objectType == GDIOBJECT_PEN)
{
previousSelectedObject = (HGDIOBJECT) hdc->pen;
hdc->pen = (HGDI_PEN) hgdiobject;
}
else if (hgdiobject->objectType == GDIOBJECT_BRUSH)
{
previousSelectedObject = (HGDIOBJECT) hdc->brush;
hdc->brush = (HGDI_BRUSH) hgdiobject;
}
else if (hgdiobject->objectType == GDIOBJECT_REGION)
{
hdc->selectedObject = hgdiobject;
}
else if (hgdiobject->objectType == GDIOBJECT_RECT)
{
hdc->selectedObject = hgdiobject;
}
else
{
/* Unknown GDI Object Type */
return 0;
}
return previousSelectedObject;
}
/**
* Delete a GDI object.\n
* @msdn{dd183539}
* @param hgdiobject GDI object
* @return 1 if successful, 0 otherwise
*/
int gdi_DeleteObject(HGDIOBJECT hgdiobject)
{
if (hgdiobject == NULL)
return 0;
if (hgdiobject->objectType == GDIOBJECT_BITMAP)
{
HGDI_BITMAP hBitmap = (HGDI_BITMAP) hgdiobject;
if (hBitmap->data != NULL)
free(hBitmap->data);
free(hBitmap);
}
else if (hgdiobject->objectType == GDIOBJECT_PEN)
{
HGDI_PEN hPen = (HGDI_PEN) hgdiobject;
free(hPen);
}
else if (hgdiobject->objectType == GDIOBJECT_BRUSH)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) hgdiobject;
if(hBrush->style == GDI_BS_PATTERN)
gdi_DeleteObject((HGDIOBJECT) hBrush->pattern);
free(hBrush);
}
else if (hgdiobject->objectType == GDIOBJECT_REGION)
{
free(hgdiobject);
}
else if (hgdiobject->objectType == GDIOBJECT_RECT)
{
free(hgdiobject);
}
else
{
/* Unknown GDI Object Type */
free(hgdiobject);
return 0;
}
return 1;
}
/**
* Delete device context.\n
* @msdn{dd183533}
* @param hdc device context
* @return 1 if successful, 0 otherwise
*/
int gdi_DeleteDC(HGDI_DC hdc)
{
if (hdc->hwnd)
{
free(hdc->hwnd->invalid);
free(hdc->hwnd);
}
free(hdc->clip);
free(hdc);
return 1;
}

31
libfreerdp-gdi/gdi_dc.h Normal file
View File

@ -0,0 +1,31 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Device Context Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_DC_H
#define __GDI_DC_H
#include "gdi.h"
HGDI_DC gdi_GetDC();
HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc);
HGDIOBJECT gdi_SelectObject(HGDI_DC hdc, HGDIOBJECT hgdiobject);
int gdi_DeleteObject(HGDIOBJECT hgdiobject);
int gdi_DeleteDC(HGDI_DC hdc);
#endif /* __GDI_DC_H */

131
libfreerdp-gdi/gdi_drawing.c Normal file
View File

@ -0,0 +1,131 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Drawing Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* GDI Drawing Functions: http://msdn.microsoft.com/en-us/library/dd162760/ */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_dc.h"
/**
* Set current foreground draw mode.\n
* @msdn{dd144922}
* @param hdc device context
* @return draw mode
*/
int gdi_GetROP2(HGDI_DC hdc)
{
return hdc->drawMode;
}
/**
* Set current foreground draw mode.\n
* @msdn{dd145088}
* @param hdc device context
* @param fnDrawMode draw mode
* @return previous draw mode
*/
int gdi_SetROP2(HGDI_DC hdc, int fnDrawMode)
{
int prevDrawMode = hdc->drawMode;
if (fnDrawMode > 0 && fnDrawMode <= 16)
hdc->drawMode = fnDrawMode;
return prevDrawMode;
}
/**
* Get the current background color.\n
* @msdn{dd144852}
* @param hdc device context
* @return background color
*/
GDI_COLOR gdi_GetBkColor(HGDI_DC hdc)
{
return hdc->bkColor;
}
/**
* Set the current background color.\n
* @msdn{dd162964}
* @param hdc device color
* @param crColor new background color
* @return previous background color
*/
GDI_COLOR gdi_SetBkColor(HGDI_DC hdc, GDI_COLOR crColor)
{
GDI_COLOR previousBkColor = hdc->bkColor;
hdc->bkColor = crColor;
return previousBkColor;
}
/**
* Get the current background mode.\n
* @msdn{dd144853}
* @param hdc device context
* @return background mode
*/
int gdi_GetBkMode(HGDI_DC hdc)
{
return hdc->bkMode;
}
/**
* Set the current background mode.\n
* @msdn{dd162965}
* @param hdc device context
* @param iBkMode background mode
* @return
*/
int gdi_SetBkMode(HGDI_DC hdc, int iBkMode)
{
if (iBkMode == GDI_OPAQUE || iBkMode == GDI_TRANSPARENT)
hdc->bkMode = iBkMode;
else
hdc->bkMode = GDI_OPAQUE;
return 0;
}
/**
* Set the current text color.\n
* @msdn{dd145093}
* @param hdc device context
* @param crColor new text color
* @return previous text color
*/
GDI_COLOR gdi_SetTextColor(HGDI_DC hdc, GDI_COLOR crColor)
{
GDI_COLOR previousTextColor = hdc->textColor;
hdc->textColor = crColor;
return previousTextColor;
}

33
libfreerdp-gdi/gdi_drawing.h Normal file
View File

@ -0,0 +1,33 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Drawing Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_DRAWING_H
#define __GDI_DRAWING_H
#include "gdi.h"
int gdi_GetROP2(HGDI_DC hdc);
int gdi_SetROP2(HGDI_DC hdc, int fnDrawMode);
GDI_COLOR gdi_GetBkColor(HGDI_DC hdc);
GDI_COLOR gdi_SetBkColor(HGDI_DC hdc, GDI_COLOR crColor);
int gdi_GetBkMode(HGDI_DC hdc);
int gdi_SetBkMode(HGDI_DC hdc, int iBkMode);
GDI_COLOR gdi_SetTextColor(HGDI_DC hdc, GDI_COLOR crColor);
#endif /* __GDI_DRAWING_H */

151
libfreerdp-gdi/gdi_line.c Normal file
View File

@ -0,0 +1,151 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Line Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_32bpp.h"
#include "gdi_16bpp.h"
#include "gdi_8bpp.h"
#include "gdi_line.h"
pLineTo LineTo_[5] =
{
NULL,
LineTo_8bpp,
LineTo_16bpp,
NULL,
LineTo_32bpp
};
/**
* Draw a line from the current position to the given position.\n
* @msdn{dd145029}
* @param hdc device context
* @param nXEnd ending x position
* @param nYEnd ending y position
* @return 1 if successful, 0 otherwise
*/
int gdi_LineTo(HGDI_DC hdc, int nXEnd, int nYEnd)
{
pLineTo _LineTo = LineTo_[IBPP(hdc->bitsPerPixel)];
if (_LineTo != NULL)
return _LineTo(hdc, nXEnd, nYEnd);
else
return 0;
}
/**
* Draw one or more straight lines
* @param hdc device context
* @param lppt array of points
* @param cCount number of points
* @return
*/
int gdi_PolylineTo(HGDI_DC hdc, GDI_POINT *lppt, int cCount)
{
int i;
for (i = 0; i < cCount; i++)
{
gdi_LineTo(hdc, lppt[i].x, lppt[i].y);
gdi_MoveToEx(hdc, lppt[i].x, lppt[i].y, NULL);
}
return 1;
}
/**
* Draw one or more straight lines
* @param hdc device context
* @param lppt array of points
* @param cPoints number of points
* @return
*/
int gdi_Polyline(HGDI_DC hdc, GDI_POINT *lppt, int cPoints)
{
if (cPoints > 0)
{
int i;
GDI_POINT pt;
gdi_MoveToEx(hdc, lppt[0].x, lppt[0].y, &pt);
for (i = 0; i < cPoints; i++)
{
gdi_LineTo(hdc, lppt[i].x, lppt[i].y);
gdi_MoveToEx(hdc, lppt[i].x, lppt[i].y, NULL);
}
gdi_MoveToEx(hdc, pt.x, pt.y, NULL);
}
return 1;
}
/**
* Draw multiple series of connected line segments
* @param hdc device context
* @param lppt array of points
* @param lpdwPolyPoints array of numbers of points per series
* @param cCount count of entries in lpdwPolyPoints
* @return
*/
int gdi_PolyPolyline(HGDI_DC hdc, GDI_POINT *lppt, int *lpdwPolyPoints, int cCount)
{
int cPoints;
int i, j = 0;
for (i = 0; i < cCount; i++)
{
cPoints = lpdwPolyPoints[i];
gdi_Polyline(hdc, &lppt[j], cPoints);
j += cPoints;
}
return 1;
}
/**
* Move pen from the current device context to a new position.
* @param hdc device context
* @param X x position
* @param Y y position
* @return 1 if successful, 0 otherwise
*/
int gdi_MoveToEx(HGDI_DC hdc, int X, int Y, HGDI_POINT lpPoint)
{
if (lpPoint != NULL)
{
lpPoint->x = hdc->pen->posX;
lpPoint->y = hdc->pen->posY;
}
hdc->pen->posX = X;
hdc->pen->posY = Y;
return 1;
}

33
libfreerdp-gdi/gdi_line.h Normal file
View File

@ -0,0 +1,33 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Line Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_LINE_H
#define __GDI_LINE_H
#include "gdi.h"
int gdi_LineTo(HGDI_DC hdc, int nXEnd, int nYEnd);
int gdi_PolylineTo(HGDI_DC hdc, GDI_POINT *lppt, int cCount);
int gdi_Polyline(HGDI_DC hdc, GDI_POINT *lppt, int cPoints);
int gdi_PolyPolyline(HGDI_DC hdc, GDI_POINT *lppt, int *lpdwPolyPoints, int cCount);
int gdi_MoveToEx(HGDI_DC hdc, int X, int Y, HGDI_POINT lpPoint);
typedef int (*pLineTo)(HGDI_DC hdc, int nXEnd, int nYEnd);
#endif /* __GDI_LINE_H */

106
libfreerdp-gdi/gdi_palette.c Normal file
View File

@ -0,0 +1,106 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Palette Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* GDI Palette Functions: http://msdn.microsoft.com/en-us/library/dd183454/ */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_palette.h"
static HGDI_PALETTE hSystemPalette = NULL;
static const GDI_PALETTEENTRY default_system_palette[20] =
{
/* First 10 entries */
{ 0x00, 0x00, 0x00 },
{ 0x80, 0x00, 0x00 },
{ 0x00, 0x80, 0x00 },
{ 0x80, 0x80, 0x00 },
{ 0x00, 0x00, 0x80 },
{ 0x80, 0x00, 0x80 },
{ 0x00, 0x80, 0x80 },
{ 0xC0, 0xC0, 0xC0 },
{ 0xC0, 0xDC, 0xC0 },
{ 0xA6, 0xCA, 0xF0 },
/* Last 10 entries */
{ 0xFF, 0xFB, 0xF0 },
{ 0xA0, 0xA0, 0xA4 },
{ 0x80, 0x80, 0x80 },
{ 0xFF, 0x00, 0x00 },
{ 0x00, 0xFF, 0x00 },
{ 0xFF, 0xFF, 0x00 },
{ 0x00, 0x00, 0xFF },
{ 0xFF, 0x00, 0xFF },
{ 0x00, 0xFF, 0xFF },
{ 0xFF, 0xFF, 0xFF }
};
/**
* Create a new palette.\n
* @msdn{dd183507}
* @param original palette
* @return new palette
*/
HGDI_PALETTE gdi_CreatePalette(HGDI_PALETTE palette)
{
HGDI_PALETTE hPalette = (HGDI_PALETTE) malloc(sizeof(GDI_PALETTE));
hPalette->count = palette->count;
hPalette->entries = (GDI_PALETTEENTRY*) malloc(sizeof(GDI_PALETTEENTRY) * hPalette->count);
memcpy(hPalette->entries, palette->entries, sizeof(GDI_PALETTEENTRY) * hPalette->count);
return hPalette;
}
/**
* Create system palette\n
* @return system palette
*/
HGDI_PALETTE CreateSystemPalette()
{
HGDI_PALETTE palette = (HGDI_PALETTE) malloc(sizeof(GDI_PALETTE));
palette->count = 256;
palette->entries = (GDI_PALETTEENTRY*) malloc(sizeof(GDI_PALETTEENTRY) * 256);
memset(palette->entries, 0, sizeof(GDI_PALETTEENTRY) * 256);
memcpy(&palette->entries[0], &default_system_palette[0], 10 * sizeof(GDI_PALETTEENTRY));
memcpy(&palette->entries[256 - 10], &default_system_palette[10], 10 * sizeof(GDI_PALETTEENTRY));
return palette;
}
/**
* Get system palette\n
* @return system palette
*/
HGDI_PALETTE gdi_GetSystemPalette()
{
if (hSystemPalette == NULL)
hSystemPalette = CreateSystemPalette();
return hSystemPalette;
}

28
libfreerdp-gdi/gdi_palette.h Normal file
View File

@ -0,0 +1,28 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Palette Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_PALETTE_H
#define __GDI_PALETTE_H
#include "gdi.h"
HGDI_PALETTE gdi_CreatePalette(HGDI_PALETTE palette);
HGDI_PALETTE gdi_GetSystemPalette();
#endif /* __GDI_PALETTE_H */

69
libfreerdp-gdi/gdi_pen.c Normal file
View File

@ -0,0 +1,69 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Pen Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* GDI Pen Functions: http://msdn.microsoft.com/en-us/library/dd162790 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_pen.h"
/**
* Create a new pen.\n
* @msdn{dd183509}
* @param fnPenStyle pen style
* @param nWidth pen width
* @param crColor pen color
* @return new pen
*/
HGDI_PEN gdi_CreatePen(int fnPenStyle, int nWidth, int crColor)
{
HGDI_PEN hPen = (HGDI_PEN) malloc(sizeof(GDI_PEN));
hPen->objectType = GDIOBJECT_PEN;
hPen->style = fnPenStyle;
hPen->color = crColor;
hPen->width = nWidth;
return hPen;
}
uint8 gdi_GetPenColor_8bpp(HGDI_PEN pen)
{
/* TODO: implement conversion using palette */
return 0xFF;
}
uint16 gdi_GetPenColor_16bpp(HGDI_PEN pen)
{
uint16 p;
int r, g, b;
GetRGB32(r, g, b, pen->color);
RGB_888_565(r, g, b);
p = RGB16(r, g, b);
return p;
}
uint32 gdi_GetPenColor_32bpp(HGDI_PEN pen)
{
return pen->color;
}

30
libfreerdp-gdi/gdi_pen.h Normal file
View File

@ -0,0 +1,30 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Pen Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_PEN_H
#define __GDI_PEN_H
#include "gdi.h"
HGDI_PEN gdi_CreatePen(int fnPenStyle, int nWidth, int crColor);
uint8 gdi_GetPenColor_8bpp(HGDI_PEN pen);
uint16 gdi_GetPenColor_16bpp(HGDI_PEN pen);
uint32 gdi_GetPenColor_32bpp(HGDI_PEN pen);
#endif /* __GDI_PEN_H */

422
libfreerdp-gdi/gdi_region.c Normal file
View File

@ -0,0 +1,422 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Region Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_region.h"
/**
* Create a region from rectangular coordinates.\n
* @msdn{dd183514}
* @param nLeftRect x1
* @param nTopRect y1
* @param nRightRect x2
* @param nBottomRect y2
* @return new region
*/
HGDI_RGN gdi_CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
{
HGDI_RGN hRgn = (HGDI_RGN) malloc(sizeof(GDI_RGN));
hRgn->objectType = GDIOBJECT_REGION;
hRgn->x = nLeftRect;
hRgn->y = nTopRect;
hRgn->w = nRightRect - nLeftRect + 1;
hRgn->h = nBottomRect - nTopRect + 1;
hRgn->null = 0;
return hRgn;
}
/**
* Create a new rectangle.
* @param xLeft x1
* @param yTop y1
* @param xRight x2
* @param yBottom y2
* @return new rectangle
*/
HGDI_RECT gdi_CreateRect(int xLeft, int yTop, int xRight, int yBottom)
{
HGDI_RECT hRect = (HGDI_RECT) malloc(sizeof(GDI_RECT));
hRect->objectType = GDIOBJECT_RECT;
hRect->left = xLeft;
hRect->top = yTop;
hRect->right = xRight;
hRect->bottom = yBottom;
return hRect;
}
/**
* Convert a rectangle to a region.
* @param rect source rectangle
* @param rgn destination region
*/
void gdi_RectToRgn(HGDI_RECT rect, HGDI_RGN rgn)
{
rgn->x = rect->left;
rgn->y = rect->top;
rgn->w = rect->right - rect->left + 1;
rgn->h = rect->bottom - rect->top + 1;
}
/**
* Convert rectangular coordinates to a region.
* @param left x1
* @param top y1
* @param right x2
* @param bottom y2
* @param rgn destination region
*/
void gdi_CRectToRgn(int left, int top, int right, int bottom, HGDI_RGN rgn)
{
rgn->x = left;
rgn->y = top;
rgn->w = right - left + 1;
rgn->h = bottom - top + 1;
}
/**
* Convert a rectangle to region coordinates.
* @param rect source rectangle
* @param x x1
* @param y y1
* @param w width
* @param h height
*/
void gdi_RectToCRgn(HGDI_RECT rect, int *x, int *y, int *w, int *h)
{
*x = rect->left;
*y = rect->top;
*w = rect->right - rect->left + 1;
*h = rect->bottom - rect->top + 1;
}
/**
* Convert rectangular coordinates to region coordinates.
* @param left x1
* @param top y1
* @param right x2
* @param bottom y2
* @param x x1
* @param y y1
* @param w width
* @param h height
*/
void gdi_CRectToCRgn(int left, int top, int right, int bottom, int *x, int *y, int *w, int *h)
{
*x = left;
*y = top;
*w = right - left + 1;
*h = bottom - top + 1;
}
/**
* Convert a region to a rectangle.
* @param rgn source region
* @param rect destination rectangle
*/
void gdi_RgnToRect(HGDI_RGN rgn, HGDI_RECT rect)
{
rect->left = rgn->x;
rect->top = rgn->y;
rect->right = rgn->x + rgn->w - 1;
rect->bottom = rgn->y + rgn->h - 1;
}
/**
* Convert region coordinates to a rectangle.
* @param x x1
* @param y y1
* @param w width
* @param h height
* @param rect destination rectangle
*/
void gdi_CRgnToRect(int x, int y, int w, int h, HGDI_RECT rect)
{
rect->left = x;
rect->top = y;
rect->right = x + w - 1;
rect->bottom = y + h - 1;
}
/**
* Convert a region to rectangular coordinates.
* @param rgn source region
* @param left x1
* @param top y1
* @param right x2
* @param bottom y2
*/
void gdi_RgnToCRect(HGDI_RGN rgn, int *left, int *top, int *right, int *bottom)
{
*left = rgn->x;
*top = rgn->y;
*right = rgn->x + rgn->w - 1;
*bottom = rgn->y + rgn->h - 1;
}
/**
* Convert region coordinates to rectangular coordinates.
* @param x x1
* @param y y1
* @param w width
* @param h height
* @param left x1
* @param top y1
* @param right x2
* @param bottom y2
*/
void gdi_CRgnToCRect(int x, int y, int w, int h, int *left, int *top, int *right, int *bottom)
{
*left = x;
*top = y;
*right = x + w - 1;
*bottom = y + h - 1;
}
/**
* Check if copying would involve overlapping regions
* @param x x1
* @param y y1
* @param width width
* @param height height
* @param srcx source x1
* @param srcy source y1
* @return 1 if there is an overlap, 0 otherwise
*/
int gdi_CopyOverlap(int x, int y, int width, int height, int srcx, int srcy)
{
GDI_RECT dst;
GDI_RECT src;
gdi_CRgnToRect(x, y, width, height, &dst);
gdi_CRgnToRect(srcx, srcy, width, height, &src);
return (dst.right > src.left && dst.left < src.right &&
dst.bottom > src.top && dst.top < src.bottom) ? 1 : 0;
}
/**
* Set the coordinates of a given rectangle.\n
* @msdn{dd145085}
* @param rc rectangle
* @param xLeft x1
* @param yTop y1
* @param xRight x2
* @param yBottom y2
* @return 1 if successful, 0 otherwise
*/
int gdi_SetRect(HGDI_RECT rc, int xLeft, int yTop, int xRight, int yBottom)
{
rc->left = xLeft;
rc->top = yTop;
rc->right = xRight;
rc->bottom = yBottom;
return 1;
}
/**
* Set the coordinates of a given region.
* @param hRgn region
* @param nXLeft x1
* @param nYLeft y1
* @param nWidth width
* @param nHeight height
* @return
*/
int gdi_SetRgn(HGDI_RGN hRgn, int nXLeft, int nYLeft, int nWidth, int nHeight)
{
hRgn->x = nXLeft;
hRgn->y = nYLeft;
hRgn->w = nWidth;
hRgn->h = nHeight;
hRgn->null = 0;
return 0;
}
/**
* Convert rectangular coordinates to a region
* @param hRgn destination region
* @param nLeftRect x1
* @param nTopRect y1
* @param nRightRect x2
* @param nBottomRect y2
* @return
*/
int gdi_SetRectRgn(HGDI_RGN hRgn, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
{
gdi_CRectToRgn(nLeftRect, nTopRect, nRightRect, nBottomRect, hRgn);
hRgn->null = 0;
return 0;
}
/**
* Set the current clipping region coordinates.
* @param hdc device context
* @param nXLeft x1
* @param nYLeft y1
* @param nWidth width
* @param nHeight height
* @return
*/
/**
* Compare two regions for equality.\n
* @msdn{dd162700}
* @param hSrcRgn1 first region
* @param hSrcRgn2 second region
* @return 1 if both regions are equal, 0 otherwise
*/
int gdi_EqualRgn(HGDI_RGN hSrcRgn1, HGDI_RGN hSrcRgn2)
{
if ((hSrcRgn1->x == hSrcRgn2->x) &&
(hSrcRgn1->y == hSrcRgn2->y) &&
(hSrcRgn1->w == hSrcRgn2->w) &&
(hSrcRgn1->h == hSrcRgn2->h))
{
return 1;
}
return 0;
}
/**
* Copy coordinates from a rectangle to another rectangle
* @param dst destination rectangle
* @param src source rectangle
* @return 1 if successful, 0 otherwise
*/
int gdi_CopyRect(HGDI_RECT dst, HGDI_RECT src)
{
dst->left = src->left;
dst->top = src->top;
dst->right = src->right;
dst->bottom = src->bottom;
return 1;
}
/**
* Check if a point is inside a rectangle.\n
* @msdn{dd162882}
* @param rc rectangle
* @param x point x position
* @param y point y position
* @return 1 if the point is inside, 0 otherwise
*/
int gdi_PtInRect(HGDI_RECT rc, int x, int y)
{
/*
* points on the left and top sides are considered in,
* while points on the right and bottom sides are considered out
*/
if (x >= rc->left && x <= rc->right)
{
if (y >= rc->top && y <= rc->bottom)
{
return 1;
}
}
return 0;
}
/**
* Invalidate a given region, such that it is redrawn on the next region update.\n
* @msdn{dd145003}
* @param hdc device context
* @param x x1
* @param y y1
* @param w width
* @param h height
* @return
*/
int gdi_InvalidateRegion(HGDI_DC hdc, int x, int y, int w, int h)
{
GDI_RECT inv;
GDI_RECT rgn;
HGDI_RGN invalid;
HGDI_BITMAP bmp;
if (hdc->hwnd == NULL)
return 0;
if (hdc->hwnd->invalid == NULL)
return 0;
invalid = hdc->hwnd->invalid;
bmp = (HGDI_BITMAP) hdc->selectedObject;
if (invalid->null)
{
invalid->x = x;
invalid->y = y;
invalid->w = w;
invalid->h = h;
invalid->null = 0;
return 0;
}
gdi_CRgnToRect(x, y, w, h, &rgn);
gdi_RgnToRect(invalid, &inv);
if (rgn.left < 0)
rgn.left = 0;
if (rgn.top < 0)
rgn.top = 0;
if (rgn.left < inv.left)
inv.left = rgn.left;
if (rgn.top < inv.top)
inv.top = rgn.top;
if (rgn.right > inv.right)
inv.right = rgn.right;
if (rgn.bottom > inv.bottom)
inv.bottom = rgn.bottom;
gdi_RectToRgn(&inv, invalid);
return 0;
}

44
libfreerdp-gdi/gdi_region.h Normal file
View File

@ -0,0 +1,44 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Region Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_REGION_H
#define __GDI_REGION_H
#include "gdi.h"
HGDI_RGN gdi_CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
HGDI_RECT gdi_CreateRect(int xLeft, int yTop, int xRight, int yBottom);
void gdi_RectToRgn(HGDI_RECT rect, HGDI_RGN rgn);
void gdi_CRectToRgn(int left, int top, int right, int bottom, HGDI_RGN rgn);
void gdi_RectToCRgn(HGDI_RECT rect, int *x, int *y, int *w, int *h);
void gdi_CRectToCRgn(int left, int top, int right, int bottom, int *x, int *y, int *w, int *h);
void gdi_RgnToRect(HGDI_RGN rgn, HGDI_RECT rect);
void gdi_CRgnToRect(int x, int y, int w, int h, HGDI_RECT rect);
void gdi_RgnToCRect(HGDI_RGN rgn, int *left, int *top, int *right, int *bottom);
void gdi_CRgnToCRect(int x, int y, int w, int h, int *left, int *top, int *right, int *bottom);
int gdi_CopyOverlap(int x, int y, int width, int height, int srcx, int srcy);
int gdi_SetRect(HGDI_RECT rc, int xLeft, int yTop, int xRight, int yBottom);
int gdi_SetRgn(HGDI_RGN hRgn, int nXLeft, int nYLeft, int nWidth, int nHeight);
int gdi_SetRectRgn(HGDI_RGN hRgn, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
int gdi_EqualRgn(HGDI_RGN hSrcRgn1, HGDI_RGN hSrcRgn2);
int gdi_CopyRect(HGDI_RECT dst, HGDI_RECT src);
int gdi_PtInRect(HGDI_RECT rc, int x, int y);
int gdi_InvalidateRegion(HGDI_DC hdc, int x, int y, int w, int h);
#endif /* __GDI_REGION_H */

240
libfreerdp-gdi/gdi_shape.c Normal file
View File

@ -0,0 +1,240 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Shape Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
#include "gdi.h"
#include "gdi_8bpp.h"
#include "gdi_16bpp.h"
#include "gdi_32bpp.h"
#include "gdi_bitmap.h"
#include "gdi_shape.h"
pFillRect FillRect_[5] =
{
NULL,
FillRect_8bpp,
FillRect_16bpp,
NULL,
FillRect_32bpp
};
static void Ellipse_Bresenham(HGDI_DC hdc, int x1, int y1, int x2, int y2)
{
int i;
long e, e2;
long dx, dy;
int a, b, c;
int bx1, by1;
int bx2, by2;
HGDI_BITMAP bmp;
uint8 pixel8;
uint16 pixel16;
uint32 pixel32;
int bpp = hdc->bitsPerPixel;
a = (x1 < x2) ? x2 - x1 : x1 - x2;
b = (y1 < y2) ? y2 - y1 : y1 - y2;
c = b & 1;
dx = 4 * (1 - a) * b * b;
dy = 4 * (c + 1) * a * a;
e = dx + dy + c * a * a;
if (x1 > x2)
{
x1 = x2;
x2 += a;
}
if (y1 > y2)
y1 = y2;
y1 += (b + 1) / 2;
y2 = y1 - c;
a *= 8 * a;
c = 8 * b * b;
pixel8 = 0;
pixel16 = 0;
pixel32 = 0;
bmp = (HGDI_BITMAP) hdc->selectedObject;
if (hdc->clip->null)
{
bx1 = (x1 < x2) ? x1 : x2;
by1 = (y1 < y2) ? y1 : y2;
bx2 = (x1 > x2) ? x1 : x2;
by2 = (y1 > y2) ? y1 : y2;
}
else
{
bx1 = hdc->clip->x;
by1 = hdc->clip->y;
bx2 = bx1 + hdc->clip->w - 1;
by2 = by1 + hdc->clip->h - 1;
}
do
{
if (bpp == 32)
{
gdi_SetPixel_32bpp(bmp, x2, y1, pixel32);
gdi_SetPixel_32bpp(bmp, x1, y1, pixel32);
gdi_SetPixel_32bpp(bmp, x1, y2, pixel32);
gdi_SetPixel_32bpp(bmp, x2, y2, pixel32);
}
else if (bpp == 16)
{
gdi_SetPixel_16bpp(bmp, x2, y1, pixel16);
gdi_SetPixel_16bpp(bmp, x1, y1, pixel16);
gdi_SetPixel_16bpp(bmp, x1, y2, pixel16);
gdi_SetPixel_16bpp(bmp, x2, y2, pixel16);
}
else if (bpp == 8)
{
for (i = x1; i < x2; i++)
{
gdi_SetPixel_8bpp(bmp, i, y1, pixel8);
gdi_SetPixel_8bpp(bmp, i, y2, pixel8);
}
for (i = y1; i < y2; i++)
{
gdi_SetPixel_8bpp(bmp, x1, i, pixel8);
gdi_SetPixel_8bpp(bmp, x2, i, pixel8);
}
}
e2 = 2 * e;
if (e2 >= dx)
{
x1++;
x2--;
e += dx += c;
}
if (e2 <= dy)
{
y1++;
y2--;
e += dy += a;
}
}
while (x1 <= x2);
while (y1 - y2 < b)
{
if (bpp == 32)
{
gdi_SetPixel_32bpp(bmp, x1 - 1, ++y1, pixel32);
gdi_SetPixel_32bpp(bmp, x1 - 1, --y2, pixel32);
}
else if (bpp == 16)
{
gdi_SetPixel_16bpp(bmp, x1 - 1, ++y1, pixel16);
gdi_SetPixel_16bpp(bmp, x1 - 1, --y2, pixel16);
}
else if (bpp == 8)
{
gdi_SetPixel_8bpp(bmp, x1 - 1, ++y1, pixel8);
gdi_SetPixel_8bpp(bmp, x1 - 1, --y2, pixel8);
}
}
}
/**
* Draw an ellipse
* @param hdc device context
* @param nLeftRect x1
* @param nTopRect y1
* @param nRightRect x2
* @param nBottomRect y2
* @return
*/
int gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
{
Ellipse_Bresenham(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
return 1;
}
/**
* Fill a rectangle with the given brush.\n
* @msdn{dd162719}
* @param hdc device context
* @param rect rectangle
* @param hbr brush
* @return 1 if successful, 0 otherwise
*/
int gdi_FillRect(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr)
{
pFillRect _FillRect = FillRect_[IBPP(hdc->bitsPerPixel)];
if (_FillRect != NULL)
return _FillRect(hdc, rect, hbr);
else
return 0;
}
/**
*
* @param hdc device context
* @param lpPoints array of points
* @param nCount number of points
* @return
*/
int gdi_Polygon(HGDI_DC hdc, GDI_POINT *lpPoints, int nCount)
{
return 1;
}
/**
* Draw a series of closed polygons
* @param hdc device context
* @param lpPoints array of series of points
* @param lpPolyCounts array of number of points in each series
* @param nCount count of number of points in lpPolyCounts
* @return
*/
int gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT *lpPoints, int *lpPolyCounts, int nCount)
{
return 1;
}
/**
* Draw a rectangle
* @param hdc device context
* @param nLeftRect x1
* @param nTopRect y1
* @param nRightRect x2
* @param nBottomRect y2
* @return
*/
int gdi_Rectangle(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
{
return 1;
}

33
libfreerdp-gdi/gdi_shape.h Normal file
View File

@ -0,0 +1,33 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* GDI Shape Functions
*
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GDI_SHAPE_H
#define __GDI_SHAPE_H
#include "gdi.h"
int gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
int gdi_FillRect(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
int gdi_Polygon(HGDI_DC hdc, GDI_POINT *lpPoints, int nCount);
int gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT *lpPoints, int *lpPolyCounts, int nCount);
int gdi_Rectangle(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
typedef int (*pFillRect)(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
#endif /* __GDI_SHAPE_H */