2011-08-26 02:07:52 +04:00
|
|
|
/**
|
2012-10-09 07:02:04 +04:00
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
2011-08-26 02:07:52 +04:00
|
|
|
* X11 GDI
|
|
|
|
*
|
|
|
|
* Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
2014-12-01 13:19:27 +03:00
|
|
|
* Copyright 2014 Thincast Technologies GmbH
|
|
|
|
* Copyright 2014 Norbert Federa <norbert.federa@thincast.com>
|
2011-08-26 02:07:52 +04:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2012-08-15 01:20:53 +04:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2011-10-27 21:29:16 +04:00
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
|
|
|
|
2011-09-12 06:32:22 +04:00
|
|
|
#include <freerdp/gdi/gdi.h>
|
2011-10-03 04:52:17 +04:00
|
|
|
#include <freerdp/codec/rfx.h>
|
|
|
|
#include <freerdp/codec/nsc.h>
|
2011-09-12 05:22:03 +04:00
|
|
|
#include <freerdp/constants.h>
|
2011-10-03 04:28:20 +04:00
|
|
|
#include <freerdp/codec/color.h>
|
2011-10-03 07:09:13 +04:00
|
|
|
#include <freerdp/codec/bitmap.h>
|
2011-08-26 22:48:51 +04:00
|
|
|
|
2011-08-26 02:07:52 +04:00
|
|
|
#include "xf_gdi.h"
|
|
|
|
|
2014-09-12 19:13:01 +04:00
|
|
|
#include <freerdp/log.h>
|
|
|
|
#define TAG CLIENT_TAG("x11")
|
|
|
|
|
2013-02-10 03:10:45 +04:00
|
|
|
static UINT8 GDI_BS_HATCHED_PATTERNS[] =
|
2013-02-07 06:57:49 +04:00
|
|
|
{
|
2013-02-04 18:28:48 +04:00
|
|
|
0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, /* HS_HORIZONTAL */
|
|
|
|
0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, /* HS_VERTICAL */
|
|
|
|
0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, /* HS_FDIAGONAL */
|
|
|
|
0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE, /* HS_BDIAGONAL */
|
|
|
|
0xF7, 0xF7, 0xF7, 0x00, 0xF7, 0xF7, 0xF7, 0xF7, /* HS_CROSS */
|
|
|
|
0x7E, 0xBD, 0xDB, 0xE7, 0xE7, 0xDB, 0xBD, 0x7E /* HS_DIACROSS */
|
|
|
|
};
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
static const BYTE xf_rop2_table[] =
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
|
|
|
0,
|
|
|
|
GXclear, /* 0 */
|
|
|
|
GXnor, /* DPon */
|
|
|
|
GXandInverted, /* DPna */
|
|
|
|
GXcopyInverted, /* Pn */
|
|
|
|
GXandReverse, /* PDna */
|
|
|
|
GXinvert, /* Dn */
|
|
|
|
GXxor, /* DPx */
|
|
|
|
GXnand, /* DPan */
|
|
|
|
GXand, /* DPa */
|
|
|
|
GXequiv, /* DPxn */
|
|
|
|
GXnoop, /* D */
|
|
|
|
GXorInverted, /* DPno */
|
|
|
|
GXcopy, /* P */
|
|
|
|
GXorReverse, /* PDno */
|
|
|
|
GXor, /* DPo */
|
|
|
|
GXset /* 1 */
|
|
|
|
};
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
BOOL xf_set_rop2(xfContext* xfc, int rop2)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
|
|
|
if ((rop2 < 0x01) || (rop2 > 0x10))
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "Unsupported ROP2: %d", rop2);
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, xf_rop2_table[rop2]);
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
BOOL xf_set_rop3(xfContext* xfc, int rop3)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
|
|
|
int function = -1;
|
|
|
|
|
|
|
|
switch (rop3)
|
|
|
|
{
|
|
|
|
case GDI_BLACKNESS:
|
|
|
|
function = GXclear;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPon:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXnor;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPna:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXandInverted;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_Pn:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXcopyInverted;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_NOTSRCERASE:
|
|
|
|
function = GXnor;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_DSna:
|
|
|
|
function = GXandInverted;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_NOTSRCCOPY:
|
|
|
|
function = GXcopyInverted;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_SRCERASE:
|
|
|
|
function = GXandReverse;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_PDna:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXandReverse;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_DSTINVERT:
|
|
|
|
function = GXinvert;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_PATINVERT:
|
|
|
|
function = GXxor;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPan:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXnand;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_SRCINVERT:
|
|
|
|
function = GXxor;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DSan:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXnand;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_SRCAND:
|
|
|
|
function = GXand;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DSxn:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXequiv;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPa:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXand;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_PDxn:
|
|
|
|
function = GXequiv;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_D:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXnoop;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPno:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXorInverted;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_MERGEPAINT:
|
|
|
|
function = GXorInverted;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_SRCCOPY:
|
|
|
|
function = GXcopy;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_SDno:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXorReverse;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_SRCPAINT:
|
|
|
|
function = GXor;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_PATCOPY:
|
|
|
|
function = GXcopy;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_PDno:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXorReverse;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_DPo:
|
2011-08-26 02:07:52 +04:00
|
|
|
function = GXor;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDI_WHITENESS:
|
|
|
|
function = GXset;
|
|
|
|
break;
|
|
|
|
|
2012-02-13 03:12:28 +04:00
|
|
|
case GDI_PSDPxax:
|
|
|
|
function = GXand;
|
|
|
|
break;
|
|
|
|
|
2011-08-26 02:07:52 +04:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (function < 0)
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "Unsupported ROP3: 0x%08X", rop3);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXclear);
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, function);
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2014-12-15 18:34:09 +03:00
|
|
|
UINT32 xf_convert_rdp_order_color(xfContext* xfc, UINT32 color)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE r = 0, g = 0, b = 0;
|
2014-12-15 18:34:09 +03:00
|
|
|
|
|
|
|
switch (xfc->srcBpp)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
case 32:
|
|
|
|
case 24:
|
|
|
|
if (xfc->visual->red_mask == 0xFF0000 &&
|
|
|
|
xfc->visual->green_mask == 0xFF00 &&
|
|
|
|
xfc->visual->blue_mask == 0xFF)
|
|
|
|
{
|
|
|
|
return color;
|
|
|
|
}
|
|
|
|
|
|
|
|
color = GetColor(xfc->format, r, g, b, 0xFF);
|
|
|
|
break;
|
2014-12-15 18:34:09 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
case 16:
|
|
|
|
color = (color & 0xFF00) | ((color >> 16) & 0xFF);
|
2014-12-15 18:34:09 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (xfc->visual->red_mask == 0xF800 &&
|
|
|
|
xfc->visual->green_mask == 0x07E0 &&
|
|
|
|
xfc->visual->blue_mask == 0x001F)
|
|
|
|
{
|
|
|
|
return color;
|
|
|
|
}
|
|
|
|
|
|
|
|
color = GetColor(xfc->format, r, g, b, 0xFF);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 15:
|
|
|
|
color = (color & 0xFF00) | ((color >> 16) & 0xFF);
|
|
|
|
color = GetColor(xfc->format, r, g, b, 0xFF);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
color = (color >> 16) & (UINT32) 0xFF;
|
2014-12-15 18:34:09 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (xfc->palette)
|
|
|
|
{
|
|
|
|
UINT32 dstColor = xfc->palette[color];
|
|
|
|
SplitColor(dstColor, xfc->format, &r, &g, &b,
|
|
|
|
NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return color;
|
2014-12-15 18:34:09 +03:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
return (((r >> xfc->red_shift_r) << xfc->red_shift_l) |
|
|
|
|
((g >> xfc->green_shift_r) << xfc->green_shift_l) |
|
|
|
|
((b >> xfc->blue_shift_r) << xfc->blue_shift_l));
|
2014-12-15 18:34:09 +03:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
Pixmap xf_brush_new(xfContext* xfc, int width, int height, int bpp, BYTE* data)
|
2011-10-13 23:51:07 +04:00
|
|
|
{
|
2014-10-22 05:56:10 +04:00
|
|
|
GC gc;
|
2011-10-13 23:51:07 +04:00
|
|
|
Pixmap bitmap;
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE* cdata;
|
2011-10-13 23:51:07 +04:00
|
|
|
XImage* image;
|
2014-10-22 05:56:10 +04:00
|
|
|
UINT32 brushFormat;
|
2013-06-13 02:57:25 +04:00
|
|
|
bitmap = XCreatePixmap(xfc->display, xfc->drawable, width, height, xfc->depth);
|
2011-10-13 23:51:07 +04:00
|
|
|
|
2014-09-17 03:12:26 +04:00
|
|
|
if (data)
|
2011-10-13 23:51:07 +04:00
|
|
|
{
|
2014-10-22 05:56:10 +04:00
|
|
|
brushFormat = gdi_get_pixel_format(bpp, FALSE);
|
|
|
|
cdata = (BYTE*) _aligned_malloc(width * height * 4, 16);
|
|
|
|
freerdp_image_copy(cdata, xfc->format, -1, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
width, height, data, brushFormat, -1, 0, 0, xfc->palette);
|
2013-06-13 02:57:25 +04:00
|
|
|
image = XCreateImage(xfc->display, xfc->visual, xfc->depth,
|
2016-04-05 18:07:45 +03:00
|
|
|
ZPixmap, 0, (char*) cdata, width, height, xfc->scanline_pad, 0);
|
2013-06-13 02:57:25 +04:00
|
|
|
gc = XCreateGC(xfc->display, xfc->drawable, 0, NULL);
|
|
|
|
XPutImage(xfc->display, bitmap, gc, image, 0, 0, 0, 0, width, height);
|
2011-10-13 23:51:07 +04:00
|
|
|
XFree(image);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
2011-10-13 23:51:07 +04:00
|
|
|
if (cdata != data)
|
2014-09-08 12:50:46 +04:00
|
|
|
_aligned_free(cdata);
|
2012-01-01 02:00:26 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XFreeGC(xfc->display, gc);
|
2011-10-13 23:51:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return bitmap;
|
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
Pixmap xf_mono_bitmap_new(xfContext* xfc, int width, int height, BYTE* data)
|
2011-09-12 06:32:22 +04:00
|
|
|
{
|
|
|
|
int scanline;
|
|
|
|
XImage* image;
|
|
|
|
Pixmap bitmap;
|
|
|
|
scanline = (width + 7) / 8;
|
2013-06-13 02:57:25 +04:00
|
|
|
bitmap = XCreatePixmap(xfc->display, xfc->drawable, width, height, 1);
|
|
|
|
image = XCreateImage(xfc->display, xfc->visual, 1,
|
2016-04-05 18:07:45 +03:00
|
|
|
ZPixmap, 0, (char*) data, width, height, 8, scanline);
|
2013-06-13 02:57:25 +04:00
|
|
|
XPutImage(xfc->display, bitmap, xfc->gc_mono, image, 0, 0, 0, 0, width, height);
|
2011-09-12 06:32:22 +04:00
|
|
|
XFree(image);
|
|
|
|
return bitmap;
|
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BOOL xf_gdi_bitmap_update(rdpContext* context,
|
|
|
|
const BITMAP_UPDATE* bitmapUpdate)
|
2014-09-12 06:29:09 +04:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
int nXDst;
|
|
|
|
int nYDst;
|
|
|
|
int nXSrc;
|
|
|
|
int nYSrc;
|
|
|
|
int nWidth;
|
|
|
|
int nHeight;
|
|
|
|
UINT32 index;
|
|
|
|
XImage* image;
|
|
|
|
BYTE* pSrcData;
|
|
|
|
BYTE* pDstData;
|
|
|
|
UINT32 SrcSize;
|
|
|
|
BOOL compressed;
|
|
|
|
UINT32 SrcFormat;
|
|
|
|
BITMAP_DATA* bitmap;
|
|
|
|
rdpCodecs* codecs = context->codecs;
|
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2014-09-12 06:29:09 +04:00
|
|
|
|
|
|
|
for (index = 0; index < bitmapUpdate->number; index++)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 bitsPerPixel;
|
2014-09-12 06:29:09 +04:00
|
|
|
bitmap = &(bitmapUpdate->rectangles[index]);
|
|
|
|
nXSrc = 0;
|
|
|
|
nYSrc = 0;
|
|
|
|
nXDst = bitmap->destLeft;
|
|
|
|
nYDst = bitmap->destTop;
|
|
|
|
nWidth = bitmap->width;
|
|
|
|
nHeight = bitmap->height;
|
|
|
|
pSrcData = bitmap->bitmapDataStream;
|
|
|
|
SrcSize = bitmap->bitmapLength;
|
|
|
|
compressed = bitmap->compressed;
|
|
|
|
bitsPerPixel = bitmap->bitsPerPixel;
|
|
|
|
SrcFormat = gdi_get_pixel_format(bitsPerPixel, TRUE);
|
|
|
|
|
|
|
|
if (compressed)
|
|
|
|
{
|
|
|
|
pDstData = xfc->bitmap_buffer;
|
|
|
|
|
|
|
|
if (bitsPerPixel < 32)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_client_codecs_prepare(codecs, FREERDP_CODEC_INTERLEAVED))
|
2015-04-28 18:00:41 +03:00
|
|
|
return FALSE;
|
2014-09-12 06:29:09 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
status = interleaved_decompress(codecs->interleaved,
|
|
|
|
pSrcData, SrcSize,
|
|
|
|
bitsPerPixel,
|
|
|
|
pDstData,
|
|
|
|
xfc->format, -1,
|
|
|
|
0, 0,
|
|
|
|
nWidth, nHeight,
|
|
|
|
xfc->palette);
|
2014-09-12 06:29:09 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_client_codecs_prepare(codecs, FREERDP_CODEC_PLANAR))
|
2015-04-28 18:00:41 +03:00
|
|
|
return FALSE;
|
2014-09-12 06:29:09 +04:00
|
|
|
|
|
|
|
status = planar_decompress(codecs->planar, pSrcData, SrcSize, &pDstData,
|
2016-04-05 18:07:45 +03:00
|
|
|
xfc->format, -1, 0, 0, nWidth, nHeight, TRUE);
|
2014-09-12 06:29:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "bitmap decompression failure");
|
2015-04-14 11:14:23 +03:00
|
|
|
return FALSE;
|
2014-09-12 06:29:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
pSrcData = xfc->bitmap_buffer;
|
|
|
|
}
|
2014-09-17 03:12:26 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
pDstData = xfc->bitmap_buffer;
|
|
|
|
status = freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
nWidth, nHeight, pSrcData, SrcFormat, -1, 0, 0, xfc->palette);
|
2014-09-17 03:12:26 +04:00
|
|
|
pSrcData = xfc->bitmap_buffer;
|
|
|
|
}
|
2014-09-12 06:29:09 +04:00
|
|
|
|
|
|
|
xf_lock_x11(xfc, FALSE);
|
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
(char*) pSrcData, nWidth, nHeight, xfc->scanline_pad, 0);
|
|
|
|
|
2015-04-20 12:43:44 +03:00
|
|
|
if (!image)
|
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-09-12 06:29:09 +04:00
|
|
|
|
|
|
|
nWidth = bitmap->destRight - bitmap->destLeft + 1; /* clip width */
|
|
|
|
nHeight = bitmap->destBottom - bitmap->destTop + 1; /* clip height */
|
|
|
|
XPutImage(xfc->display, xfc->primary, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
image, 0, 0, nXDst, nYDst, nWidth, nHeight);
|
2014-09-12 06:29:09 +04:00
|
|
|
XFree(image);
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, nXDst, nYDst, nWidth, nHeight);
|
2014-09-12 06:29:09 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-20 12:43:44 +03:00
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
break;
|
2014-09-12 06:29:09 +04:00
|
|
|
}
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2014-09-12 06:29:09 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_palette_update(rdpContext* context,
|
|
|
|
const PALETTE_UPDATE* palette)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2014-09-18 02:30:09 +04:00
|
|
|
int index;
|
2016-04-05 18:07:45 +03:00
|
|
|
const PALETTE_ENTRY* pe;
|
2014-09-18 02:30:09 +04:00
|
|
|
UINT32* palette32;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
|
|
|
xf_lock_x11(xfc, FALSE);
|
2014-09-18 02:30:09 +04:00
|
|
|
palette32 = (UINT32*) xfc->palette;
|
|
|
|
|
|
|
|
for (index = 0; index < palette->number; index++)
|
|
|
|
{
|
|
|
|
pe = &(palette->entries[index]);
|
2016-04-05 18:07:45 +03:00
|
|
|
palette32[index] = GetColor(xfc->format,
|
|
|
|
pe->red, pe->green, pe->blue, 0xFF);
|
2014-09-18 02:30:09 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_set_bounds(rdpContext* context,
|
|
|
|
const rdpBounds* bounds)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2011-08-26 22:48:51 +04:00
|
|
|
XRectangle clip;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
|
|
|
xf_lock_x11(xfc, FALSE);
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2014-09-17 03:12:26 +04:00
|
|
|
if (bounds)
|
2011-08-26 22:48:51 +04:00
|
|
|
{
|
|
|
|
clip.x = bounds->left;
|
|
|
|
clip.y = bounds->top;
|
|
|
|
clip.width = bounds->right - bounds->left + 1;
|
|
|
|
clip.height = bounds->bottom - bounds->top + 1;
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetClipRectangles(xfc->display, xfc->gc, 0, 0, &clip, 1, YXBanded);
|
2011-08-26 22:48:51 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetClipMask(xfc->display, xfc->gc, None);
|
2011-08-26 22:48:51 +04:00
|
|
|
}
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_dstblt(rdpContext* context, const DSTBLT_ORDER* dstblt)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
|
|
|
xf_set_rop3(xfc, gdi_rop3_code(dstblt->bRop));
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
dstblt->nLeftRect, dstblt->nTopRect,
|
|
|
|
dstblt->nWidth, dstblt->nHeight);
|
2011-08-26 22:48:51 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, dstblt->nLeftRect, dstblt->nTopRect,
|
|
|
|
dstblt->nWidth, dstblt->nHeight);
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2015-04-14 11:14:23 +03:00
|
|
|
static BOOL xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2011-09-12 06:32:22 +04:00
|
|
|
Pixmap pattern;
|
2016-04-05 18:07:45 +03:00
|
|
|
const rdpBrush* brush;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 foreColor;
|
|
|
|
UINT32 backColor;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2011-09-12 06:32:22 +04:00
|
|
|
brush = &patblt->brush;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_set_rop3(xfc, gdi_rop3_code(patblt->bRop));
|
2014-12-15 18:34:09 +03:00
|
|
|
foreColor = xf_convert_rdp_order_color(xfc, patblt->foreColor);
|
|
|
|
backColor = xf_convert_rdp_order_color(xfc, patblt->backColor);
|
2011-09-12 06:32:22 +04:00
|
|
|
|
|
|
|
if (brush->style == GDI_BS_SOLID)
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, foreColor);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
2013-02-04 18:28:48 +04:00
|
|
|
else if (brush->style == GDI_BS_HATCHED)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
pattern = xf_mono_bitmap_new(xfc, 8, 8,
|
|
|
|
GDI_BS_HATCHED_PATTERNS + 8 * brush->hatch);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetForeground(xfc->display, xfc->gc, backColor);
|
|
|
|
XSetBackground(xfc->display, xfc->gc, foreColor);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
|
|
|
|
XSetStipple(xfc->display, xfc->gc, pattern);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
|
2013-06-13 02:57:25 +04:00
|
|
|
XFreePixmap(xfc->display, pattern);
|
2013-02-04 18:28:48 +04:00
|
|
|
}
|
2011-09-12 06:32:22 +04:00
|
|
|
else if (brush->style == GDI_BS_PATTERN)
|
|
|
|
{
|
|
|
|
if (brush->bpp > 1)
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_brush_new(xfc, 8, 8, brush->bpp, brush->data);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillTiled);
|
|
|
|
XSetTile(xfc->display, xfc->gc, pattern);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetTile(xfc->display, xfc->gc, xfc->primary);
|
|
|
|
XFreePixmap(xfc->display, pattern);
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, backColor);
|
|
|
|
XSetBackground(xfc->display, xfc->gc, foreColor);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
|
|
|
|
XSetStipple(xfc->display, xfc->gc, pattern);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
|
2013-06-13 02:57:25 +04:00
|
|
|
XFreePixmap(xfc->display, pattern);
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "unimplemented brush style:%d", brush->style);
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
2011-08-26 02:07:52 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, patblt->nLeftRect, patblt->nTopRect,
|
|
|
|
patblt->nWidth, patblt->nHeight);
|
2011-10-21 07:15:18 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_scrblt(rdpContext* context, const SCRBLT_ORDER* scrblt)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2011-08-26 22:48:51 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!xfc->display || !xfc->drawing)
|
|
|
|
return FALSE;
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_set_rop3(xfc, gdi_rop3_code(scrblt->bRop));
|
2016-04-05 18:07:45 +03:00
|
|
|
XCopyArea(xfc->display, xfc->primary, xfc->drawing, xfc->gc, scrblt->nXSrc,
|
|
|
|
scrblt->nYSrc,
|
|
|
|
scrblt->nWidth, scrblt->nHeight, scrblt->nLeftRect, scrblt->nTopRect);
|
2011-08-26 02:07:52 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, scrblt->nLeftRect, scrblt->nTopRect,
|
|
|
|
scrblt->nWidth, scrblt->nHeight);
|
2011-10-21 07:15:18 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_opaque_rect(rdpContext* context,
|
|
|
|
const OPAQUE_RECT_ORDER* opaque_rect)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 color;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2014-12-15 18:34:09 +03:00
|
|
|
color = xf_convert_rdp_order_color(xfc, opaque_rect->color);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, color);
|
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
opaque_rect->nLeftRect, opaque_rect->nTopRect,
|
|
|
|
opaque_rect->nWidth, opaque_rect->nHeight);
|
2011-08-26 22:48:51 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, opaque_rect->nLeftRect,
|
|
|
|
opaque_rect->nTopRect,
|
|
|
|
opaque_rect->nWidth, opaque_rect->nHeight);
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_multi_opaque_rect(rdpContext* context,
|
|
|
|
const MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 i;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 color;
|
2016-04-05 18:07:45 +03:00
|
|
|
const DELTA_RECT* rectangle;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2014-12-15 18:34:09 +03:00
|
|
|
color = xf_convert_rdp_order_color(xfc, multi_opaque_rect->color);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, color);
|
2011-08-26 22:48:51 +04:00
|
|
|
|
|
|
|
for (i = 1; i < multi_opaque_rect->numRectangles + 1; i++)
|
|
|
|
{
|
|
|
|
rectangle = &multi_opaque_rect->rectangles[i];
|
2013-06-13 02:57:25 +04:00
|
|
|
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
rectangle->left, rectangle->top,
|
|
|
|
rectangle->width, rectangle->height);
|
2011-08-26 22:48:51 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2015-04-20 12:43:44 +03:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!(ret = gdi_InvalidateRegion(xfc->hdc, rectangle->left, rectangle->top,
|
|
|
|
rectangle->width, rectangle->height)))
|
2015-04-20 12:43:44 +03:00
|
|
|
break;
|
|
|
|
}
|
2011-08-26 22:48:51 +04:00
|
|
|
}
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
void xf_gdi_draw_nine_grid(rdpContext* context,
|
|
|
|
DRAW_NINE_GRID_ORDER* draw_nine_grid)
|
2012-02-13 04:41:39 +04:00
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "DrawNineGrid");
|
2012-02-13 04:41:39 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_line_to(rdpContext* context, const LINE_TO_ORDER* line_to)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 color;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
|
|
|
xf_set_rop2(xfc, line_to->bRop2);
|
2014-12-15 18:34:09 +03:00
|
|
|
color = xf_convert_rdp_order_color(xfc, line_to->penColor);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, color);
|
|
|
|
XDrawLine(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd);
|
2011-09-12 06:32:22 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2011-09-12 06:32:22 +04:00
|
|
|
{
|
2014-12-01 13:19:27 +03:00
|
|
|
int x, y, w, h;
|
|
|
|
x = MIN(line_to->nXStart, line_to->nXEnd);
|
|
|
|
y = MIN(line_to->nYStart, line_to->nYEnd);
|
|
|
|
w = abs(line_to->nXEnd - line_to->nXStart) + 1;
|
|
|
|
h = abs(line_to->nYEnd - line_to->nYStart) + 1;
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, x, y, w, h);
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
2011-10-21 07:15:18 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_invalidate_poly_region(xfContext* xfc, XPoint* points,
|
|
|
|
int npoints)
|
2014-12-01 13:19:27 +03:00
|
|
|
{
|
2015-05-19 02:07:51 +03:00
|
|
|
int x, y, x1, y1, x2, y2;
|
2014-12-01 13:19:27 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
if (npoints < 2)
|
|
|
|
return FALSE;
|
2014-12-01 13:19:27 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
x = x1 = x2 = points->x;
|
|
|
|
y = y1 = y2 = points->y;
|
2014-12-01 13:19:27 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
while (--npoints)
|
|
|
|
{
|
|
|
|
points++;
|
|
|
|
x += points->x;
|
|
|
|
y += points->y;
|
|
|
|
|
|
|
|
if (x > x2)
|
|
|
|
x2 = x;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
if (x < x1)
|
|
|
|
x1 = x;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
if (y > y2)
|
|
|
|
y2 = y;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
if (y < y1)
|
|
|
|
y1 = y;
|
|
|
|
}
|
2014-12-01 13:19:27 +03:00
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
x2++;
|
|
|
|
y2++;
|
|
|
|
return gdi_InvalidateRegion(xfc->hdc, x1, y1, x2 - x1, y2 - y1);
|
2014-12-01 13:19:27 +03:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_polyline(rdpContext* context,
|
|
|
|
const POLYLINE_ORDER* polyline)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2011-09-12 06:32:22 +04:00
|
|
|
int i;
|
2011-10-13 02:10:54 +04:00
|
|
|
int npoints;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 color;
|
2011-09-12 06:32:22 +04:00
|
|
|
XPoint* points;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
|
|
|
xf_set_rop2(xfc, polyline->bRop2);
|
2014-12-15 18:34:09 +03:00
|
|
|
color = xf_convert_rdp_order_color(xfc, polyline->penColor);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, color);
|
2014-10-09 14:11:38 +04:00
|
|
|
npoints = polyline->numDeltaEntries + 1;
|
2012-10-09 07:21:26 +04:00
|
|
|
points = malloc(sizeof(XPoint) * npoints);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-04-14 11:14:23 +03:00
|
|
|
if (!points)
|
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2011-10-13 02:10:54 +04:00
|
|
|
|
2014-11-16 20:48:14 +03:00
|
|
|
points[0].x = polyline->xStart;
|
|
|
|
points[0].y = polyline->yStart;
|
2011-09-12 06:32:22 +04:00
|
|
|
|
2014-10-09 14:11:38 +04:00
|
|
|
for (i = 0; i < polyline->numDeltaEntries; i++)
|
2011-09-12 06:32:22 +04:00
|
|
|
{
|
2014-11-16 20:48:14 +03:00
|
|
|
points[i + 1].x = polyline->points[i].x;
|
|
|
|
points[i + 1].y = polyline->points[i].y;
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
XDrawLines(xfc->display, xfc->drawing, xfc->gc, points, npoints,
|
|
|
|
CoordModePrevious);
|
2011-08-26 02:07:52 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2011-09-12 06:32:22 +04:00
|
|
|
{
|
2015-05-19 02:07:51 +03:00
|
|
|
if (!xf_gdi_invalidate_poly_region(xfc, points, npoints))
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = FALSE;
|
2011-09-12 06:32:22 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
2012-10-09 07:21:26 +04:00
|
|
|
free(points);
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
|
2011-10-05 05:29:01 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
xfBitmap* bitmap = (xfBitmap*) memblt->bitmap;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2011-10-05 05:29:01 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!xfc->display || !xfc->drawing)
|
|
|
|
return FALSE;
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2011-10-12 04:21:35 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (xf_set_rop3(xfc, gdi_rop3_code(memblt->bRop)))
|
|
|
|
{
|
|
|
|
XCopyArea(xfc->display, bitmap->pixmap, xfc->drawing, xfc->gc,
|
|
|
|
memblt->nXSrc, memblt->nYSrc, memblt->nWidth, memblt->nHeight,
|
|
|
|
memblt->nLeftRect, memblt->nTopRect);
|
2011-10-05 05:29:01 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (xfc->drawing == xfc->primary)
|
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, memblt->nLeftRect,
|
|
|
|
memblt->nTopRect, memblt->nWidth,
|
|
|
|
memblt->nHeight);
|
2011-10-21 07:15:18 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
}
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-10-05 05:29:01 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
|
2011-10-05 05:29:01 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
const rdpBrush* brush;
|
2012-02-13 03:12:28 +04:00
|
|
|
xfBitmap* bitmap;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 foreColor;
|
|
|
|
UINT32 backColor;
|
2012-02-13 03:12:28 +04:00
|
|
|
Pixmap pattern = 0;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2012-02-13 03:12:28 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!xfc->display || !xfc->drawing)
|
|
|
|
return FALSE;
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2012-02-13 03:12:28 +04:00
|
|
|
brush = &mem3blt->brush;
|
|
|
|
bitmap = (xfBitmap*) mem3blt->bitmap;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_set_rop3(xfc, gdi_rop3_code(mem3blt->bRop));
|
2014-12-15 18:34:09 +03:00
|
|
|
foreColor = xf_convert_rdp_order_color(xfc, mem3blt->foreColor);
|
|
|
|
backColor = xf_convert_rdp_order_color(xfc, mem3blt->backColor);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
|
|
|
if (brush->style == GDI_BS_PATTERN)
|
|
|
|
{
|
|
|
|
if (brush->bpp > 1)
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_brush_new(xfc, 8, 8, brush->bpp, brush->data);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillTiled);
|
|
|
|
XSetTile(xfc->display, xfc->gc, pattern);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
2012-02-13 03:12:28 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, backColor);
|
|
|
|
XSetBackground(xfc->display, xfc->gc, foreColor);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
|
|
|
|
XSetStipple(xfc->display, xfc->gc, pattern);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
2012-02-13 03:12:28 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (brush->style == GDI_BS_SOLID)
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, backColor);
|
|
|
|
XSetBackground(xfc->display, xfc->gc, foreColor);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
2012-02-13 03:12:28 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "Mem3Blt unimplemented brush style:%d", brush->style);
|
2012-02-13 03:12:28 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XCopyArea(xfc->display, bitmap->pixmap, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
|
|
|
|
mem3blt->nLeftRect, mem3blt->nTopRect);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, mem3blt->nLeftRect, mem3blt->nTopRect,
|
|
|
|
mem3blt->nWidth, mem3blt->nHeight);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
|
|
|
if (pattern != 0)
|
2013-06-13 02:57:25 +04:00
|
|
|
XFreePixmap(xfc->display, pattern);
|
2012-02-13 03:12:28 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2015-05-19 02:07:51 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_polygon_sc(rdpContext* context,
|
|
|
|
const POLYGON_SC_ORDER* polygon_sc)
|
2012-02-13 02:14:59 +04:00
|
|
|
{
|
|
|
|
int i, npoints;
|
|
|
|
XPoint* points;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 brush_color;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
|
|
|
xf_set_rop2(xfc, polygon_sc->bRop2);
|
2014-12-15 18:34:09 +03:00
|
|
|
brush_color = xf_convert_rdp_order_color(xfc, polygon_sc->brushColor);
|
2012-02-13 02:14:59 +04:00
|
|
|
npoints = polygon_sc->numPoints + 1;
|
2012-10-09 07:21:26 +04:00
|
|
|
points = malloc(sizeof(XPoint) * npoints);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-04-14 11:14:23 +03:00
|
|
|
if (!points)
|
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2012-02-13 02:14:59 +04:00
|
|
|
|
|
|
|
points[0].x = polygon_sc->xStart;
|
|
|
|
points[0].y = polygon_sc->yStart;
|
|
|
|
|
|
|
|
for (i = 0; i < polygon_sc->numPoints; i++)
|
|
|
|
{
|
|
|
|
points[i + 1].x = polygon_sc->points[i].x;
|
|
|
|
points[i + 1].y = polygon_sc->points[i].y;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (polygon_sc->fillMode)
|
|
|
|
{
|
|
|
|
case 1: /* alternate */
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillRule(xfc->display, xfc->gc, EvenOddRule);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 2: /* winding */
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillRule(xfc->display, xfc->gc, WindingRule);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "PolygonSC unknown fillMode: %d", polygon_sc->fillMode);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, brush_color);
|
|
|
|
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
points, npoints, Complex, CoordModePrevious);
|
2012-02-13 02:14:59 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->drawing == xfc->primary)
|
2012-02-13 02:14:59 +04:00
|
|
|
{
|
2015-05-19 02:07:51 +03:00
|
|
|
if (!xf_gdi_invalidate_poly_region(xfc, points, npoints))
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = FALSE;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
2012-10-09 07:21:26 +04:00
|
|
|
free(points);
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_polygon_cb(rdpContext* context,
|
|
|
|
POLYGON_CB_ORDER* polygon_cb)
|
2012-02-13 02:14:59 +04:00
|
|
|
{
|
|
|
|
int i, npoints;
|
|
|
|
XPoint* points;
|
|
|
|
Pixmap pattern;
|
2016-04-05 18:07:45 +03:00
|
|
|
const rdpBrush* brush;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 foreColor;
|
|
|
|
UINT32 backColor;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2012-02-13 02:14:59 +04:00
|
|
|
brush = &(polygon_cb->brush);
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_set_rop2(xfc, polygon_cb->bRop2);
|
2014-12-15 18:34:09 +03:00
|
|
|
foreColor = xf_convert_rdp_order_color(xfc, polygon_cb->foreColor);
|
|
|
|
backColor = xf_convert_rdp_order_color(xfc, polygon_cb->backColor);
|
2012-02-13 02:14:59 +04:00
|
|
|
npoints = polygon_cb->numPoints + 1;
|
2012-10-09 07:21:26 +04:00
|
|
|
points = malloc(sizeof(XPoint) * npoints);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-04-14 11:14:23 +03:00
|
|
|
if (!points)
|
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2012-02-13 02:14:59 +04:00
|
|
|
|
|
|
|
points[0].x = polygon_cb->xStart;
|
|
|
|
points[0].y = polygon_cb->yStart;
|
|
|
|
|
|
|
|
for (i = 0; i < polygon_cb->numPoints; i++)
|
|
|
|
{
|
|
|
|
points[i + 1].x = polygon_cb->points[i].x;
|
|
|
|
points[i + 1].y = polygon_cb->points[i].y;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (polygon_cb->fillMode)
|
|
|
|
{
|
2013-12-10 21:30:25 +04:00
|
|
|
case GDI_FILL_ALTERNATE: /* alternate */
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillRule(xfc->display, xfc->gc, EvenOddRule);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
|
2013-12-10 21:30:25 +04:00
|
|
|
case GDI_FILL_WINDING: /* winding */
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillRule(xfc->display, xfc->gc, WindingRule);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2014-11-10 19:15:37 +03:00
|
|
|
WLog_ERR(TAG, "PolygonCB unknown fillMode: %d", polygon_cb->fillMode);
|
2012-02-13 02:14:59 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (brush->style == GDI_BS_PATTERN)
|
|
|
|
{
|
|
|
|
if (brush->bpp > 1)
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_brush_new(xfc, 8, 8, brush->bpp, brush->data);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillTiled);
|
|
|
|
XSetTile(xfc->display, xfc->gc, pattern);
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
|
|
|
|
XSetForeground(xfc->display, xfc->gc, backColor);
|
|
|
|
XSetBackground(xfc->display, xfc->gc, foreColor);
|
2012-02-13 02:14:59 +04:00
|
|
|
|
|
|
|
if (polygon_cb->backMode == BACKMODE_TRANSPARENT)
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillStippled);
|
2012-02-13 02:14:59 +04:00
|
|
|
else if (polygon_cb->backMode == BACKMODE_OPAQUE)
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
|
2012-02-13 02:14:59 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetStipple(xfc->display, xfc->gc, pattern);
|
2014-12-01 13:19:27 +03:00
|
|
|
}
|
2012-02-13 02:14:59 +04:00
|
|
|
|
2014-12-01 13:19:27 +03:00
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
|
|
|
|
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
|
2016-04-05 18:07:45 +03:00
|
|
|
points, npoints, Complex, CoordModePrevious);
|
2014-12-01 13:19:27 +03:00
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
|
|
|
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
|
|
|
|
XFreePixmap(xfc->display, pattern);
|
|
|
|
|
|
|
|
if (xfc->drawing == xfc->primary)
|
|
|
|
{
|
2015-05-19 02:07:51 +03:00
|
|
|
if (!xf_gdi_invalidate_poly_region(xfc, points, npoints))
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = FALSE;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "PolygonCB unimplemented brush style:%d", brush->style);
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
2012-10-09 07:21:26 +04:00
|
|
|
free(points);
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_ellipse_sc(rdpContext* context,
|
|
|
|
const ELLIPSE_SC_ORDER* ellipse_sc)
|
2012-02-13 02:14:59 +04:00
|
|
|
{
|
2015-04-14 11:14:23 +03:00
|
|
|
WLog_ERR(TAG, "Not implemented: EllipseSC");
|
|
|
|
return TRUE;
|
2012-02-13 02:14:59 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_ellipse_cb(rdpContext* context,
|
|
|
|
const ELLIPSE_CB_ORDER* ellipse_cb)
|
2012-02-13 02:14:59 +04:00
|
|
|
{
|
2015-04-14 11:14:23 +03:00
|
|
|
WLog_ERR(TAG, "Not implemented: EllipseCB");
|
|
|
|
return TRUE;
|
2011-10-05 05:29:01 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_frame_marker(rdpContext* context,
|
|
|
|
const FRAME_MARKER_ORDER* frameMarker)
|
2014-09-06 00:06:19 +04:00
|
|
|
{
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2014-09-06 00:06:19 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_surface_frame_marker(rdpContext* context,
|
|
|
|
const SURFACE_FRAME_MARKER* surface_frame_marker)
|
2011-11-25 14:48:51 +04:00
|
|
|
{
|
2013-01-17 08:58:01 +04:00
|
|
|
rdpSettings* settings;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2013-06-13 02:57:25 +04:00
|
|
|
settings = xfc->instance->settings;
|
|
|
|
xf_lock_x11(xfc, FALSE);
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2012-05-26 10:41:38 +04:00
|
|
|
switch (surface_frame_marker->frameAction)
|
|
|
|
{
|
|
|
|
case SURFACECMD_FRAMEACTION_BEGIN:
|
2013-06-13 02:57:25 +04:00
|
|
|
xfc->frame_begin = TRUE;
|
|
|
|
xfc->frame_x1 = 0;
|
|
|
|
xfc->frame_y1 = 0;
|
|
|
|
xfc->frame_x2 = 0;
|
|
|
|
xfc->frame_y2 = 0;
|
2012-05-26 10:41:38 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SURFACECMD_FRAMEACTION_END:
|
2013-06-13 02:57:25 +04:00
|
|
|
xfc->frame_begin = FALSE;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if ((xfc->frame_x2 > xfc->frame_x1) && (xfc->frame_y2 > xfc->frame_y1))
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, xfc->frame_x1, xfc->frame_y1,
|
2016-04-05 18:07:45 +03:00
|
|
|
xfc->frame_x2 - xfc->frame_x1, xfc->frame_y2 - xfc->frame_y1);
|
|
|
|
|
2013-01-17 08:58:01 +04:00
|
|
|
if (settings->FrameAcknowledge > 0)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
IFCALL(xfc->instance->update->SurfaceFrameAcknowledge, context,
|
|
|
|
surface_frame_marker->frameId);
|
2013-01-17 08:58:01 +04:00
|
|
|
}
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2012-05-26 10:41:38 +04:00
|
|
|
break;
|
|
|
|
}
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2012-05-26 10:41:38 +04:00
|
|
|
}
|
2011-11-25 14:48:51 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_surface_update_frame(xfContext* xfc, UINT16 tx, UINT16 ty,
|
|
|
|
UINT16 width, UINT16 height)
|
2012-05-26 10:41:38 +04:00
|
|
|
{
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
if (!xfc->remote_app)
|
2012-05-26 10:41:38 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->frame_begin)
|
2012-05-26 10:41:38 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
if (xfc->frame_x2 > xfc->frame_x1 && xfc->frame_y2 > xfc->frame_y1)
|
2012-05-26 10:41:38 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
xfc->frame_x1 = MIN(xfc->frame_x1, tx);
|
|
|
|
xfc->frame_y1 = MIN(xfc->frame_y1, ty);
|
|
|
|
xfc->frame_x2 = MAX(xfc->frame_x2, tx + width);
|
|
|
|
xfc->frame_y2 = MAX(xfc->frame_y2, ty + height);
|
2012-05-26 10:41:38 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
xfc->frame_x1 = tx;
|
|
|
|
xfc->frame_y1 = ty;
|
|
|
|
xfc->frame_x2 = tx + width;
|
|
|
|
xfc->frame_y2 = ty + height;
|
2012-05-26 10:41:38 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, tx, ty, width, height);
|
2012-05-26 10:41:38 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-04-17 17:21:55 +03:00
|
|
|
ret = gdi_InvalidateRegion(xfc->hdc, tx, ty, width, height);
|
2012-05-26 10:41:38 +04:00
|
|
|
}
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-11-25 14:48:51 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL xf_gdi_surface_bits(rdpContext* context,
|
|
|
|
const SURFACE_BITS_COMMAND* cmd)
|
2011-08-26 02:07:52 +04:00
|
|
|
{
|
2011-09-12 05:22:03 +04:00
|
|
|
int i, tx, ty;
|
2011-09-19 06:34:19 +04:00
|
|
|
XImage* image;
|
2014-09-17 22:29:56 +04:00
|
|
|
BYTE* pSrcData;
|
|
|
|
BYTE* pDstData;
|
2013-06-13 02:57:25 +04:00
|
|
|
xfContext* xfc = (xfContext*) context;
|
2015-04-17 17:21:55 +03:00
|
|
|
BOOL ret = TRUE;
|
2016-04-05 18:07:45 +03:00
|
|
|
rdpGdi* gdi = context->gdi;
|
|
|
|
REGION16 invalidRegion;
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_lock_x11(xfc, FALSE);
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2014-09-12 09:03:19 +04:00
|
|
|
if (cmd->codecID == RDP_CODEC_ID_REMOTEFX)
|
2011-09-12 05:22:03 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_REMOTEFX))
|
2015-04-28 18:00:41 +03:00
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-09-12 09:03:19 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!rfx_process_message(xfc->codecs->rfx, cmd->bitmapData,
|
|
|
|
PIXEL_FORMAT_XRGB32, cmd->bitmapDataLength,
|
|
|
|
cmd->destLeft, cmd->destTop,
|
|
|
|
gdi->primary_buffer, gdi->dstFormat, gdi->stride,
|
|
|
|
gdi->height, &invalidRegion))
|
2015-04-23 16:42:21 +03:00
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "Failed to process RemoteFX message");
|
2015-04-28 18:00:41 +03:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-23 16:42:21 +03:00
|
|
|
return FALSE;
|
|
|
|
}
|
2011-09-12 05:22:03 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
2014-09-17 22:29:56 +04:00
|
|
|
XSetClipRectangles(xfc->display, xfc->gc, cmd->destLeft, cmd->destTop,
|
2016-04-05 18:07:45 +03:00
|
|
|
(XRectangle*) message->rects, message->numRects, YXBanded);
|
2011-09-12 05:22:03 +04:00
|
|
|
|
2014-12-01 13:19:27 +03:00
|
|
|
/* Invalidate the updated region */
|
2013-08-14 01:18:59 +04:00
|
|
|
for (i = 0; i < message->numRects; i++)
|
2011-09-12 05:22:03 +04:00
|
|
|
{
|
2014-09-12 09:03:19 +04:00
|
|
|
tx = message->rects[i].x + cmd->destLeft;
|
|
|
|
ty = message->rects[i].y + cmd->destTop;
|
2014-09-17 22:29:56 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!xf_gdi_surface_update_frame(xfc, tx, ty, message->rects[i].width,
|
|
|
|
message->rects[i].height))
|
2015-04-17 17:21:55 +03:00
|
|
|
{
|
|
|
|
ret = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2011-09-12 05:22:03 +04:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetClipMask(xfc->display, xfc->gc, None);
|
2014-09-10 08:42:41 +04:00
|
|
|
rfx_message_free(xfc->codecs->rfx, message);
|
2011-09-12 05:22:03 +04:00
|
|
|
}
|
2014-09-12 09:03:19 +04:00
|
|
|
else if (cmd->codecID == RDP_CODEC_ID_NSCODEC)
|
2011-10-02 23:16:22 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_NSCODEC))
|
2015-04-28 18:00:41 +03:00
|
|
|
{
|
|
|
|
xf_unlock_x11(xfc, FALSE);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-09-12 09:03:19 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
nsc_process_message(xfc->codecs->nsc, cmd->bpp, cmd->width, cmd->height,
|
|
|
|
cmd->bitmapData, cmd->bitmapDataLength);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
2014-09-17 22:29:56 +04:00
|
|
|
pSrcData = xfc->codecs->nsc->BitmapData;
|
|
|
|
pDstData = xfc->bitmap_buffer;
|
|
|
|
freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
cmd->width, cmd->height, pSrcData,
|
|
|
|
PIXEL_FORMAT_BGRX32_VF, -1, 0, 0, xfc->palette);
|
2014-09-17 22:29:56 +04:00
|
|
|
image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
(char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
|
2013-06-13 02:57:25 +04:00
|
|
|
XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
cmd->destLeft, cmd->destTop, cmd->width, cmd->height);
|
2012-03-29 15:01:42 +04:00
|
|
|
XFree(image);
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
|
|
|
|
cmd->height);
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetClipMask(xfc->display, xfc->gc, None);
|
2011-10-02 23:16:22 +04:00
|
|
|
}
|
2014-09-12 09:03:19 +04:00
|
|
|
else if (cmd->codecID == RDP_CODEC_ID_NONE)
|
2011-09-12 05:22:03 +04:00
|
|
|
{
|
2013-06-13 02:57:25 +04:00
|
|
|
XSetFunction(xfc->display, xfc->gc, GXcopy);
|
|
|
|
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
|
2014-09-17 22:29:56 +04:00
|
|
|
pSrcData = cmd->bitmapData;
|
|
|
|
pDstData = xfc->bitmap_buffer;
|
|
|
|
freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
cmd->width, cmd->height, pSrcData,
|
|
|
|
PIXEL_FORMAT_BGRX32_VF, -1, 0, 0, xfc->palette);
|
2014-09-17 22:29:56 +04:00
|
|
|
image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
(char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
|
2014-09-17 22:29:56 +04:00
|
|
|
XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
|
2016-04-05 18:07:45 +03:00
|
|
|
cmd->destLeft, cmd->destTop,
|
|
|
|
cmd->width, cmd->height);
|
2014-09-17 22:29:56 +04:00
|
|
|
XFree(image);
|
2016-04-05 18:07:45 +03:00
|
|
|
ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
|
|
|
|
cmd->height);
|
2014-09-17 22:29:56 +04:00
|
|
|
XSetClipMask(xfc->display, xfc->gc, None);
|
2011-09-12 05:22:03 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_ERR(TAG, "Unsupported codecID %d", cmd->codecID);
|
2011-09-12 05:22:03 +04:00
|
|
|
}
|
2013-02-07 06:57:49 +04:00
|
|
|
|
2013-06-13 02:57:25 +04:00
|
|
|
xf_unlock_x11(xfc, FALSE);
|
2015-04-17 17:21:55 +03:00
|
|
|
return ret;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void xf_gdi_register_update_callbacks(rdpUpdate* update)
|
|
|
|
{
|
2011-11-22 03:11:43 +04:00
|
|
|
rdpPrimaryUpdate* primary = update->primary;
|
2011-08-26 02:07:52 +04:00
|
|
|
update->Palette = xf_gdi_palette_update;
|
|
|
|
update->SetBounds = xf_gdi_set_bounds;
|
2011-11-22 03:11:43 +04:00
|
|
|
primary->DstBlt = xf_gdi_dstblt;
|
|
|
|
primary->PatBlt = xf_gdi_patblt;
|
|
|
|
primary->ScrBlt = xf_gdi_scrblt;
|
|
|
|
primary->OpaqueRect = xf_gdi_opaque_rect;
|
|
|
|
primary->DrawNineGrid = NULL;
|
|
|
|
primary->MultiDstBlt = NULL;
|
|
|
|
primary->MultiPatBlt = NULL;
|
|
|
|
primary->MultiScrBlt = NULL;
|
|
|
|
primary->MultiOpaqueRect = xf_gdi_multi_opaque_rect;
|
|
|
|
primary->MultiDrawNineGrid = NULL;
|
|
|
|
primary->LineTo = xf_gdi_line_to;
|
|
|
|
primary->Polyline = xf_gdi_polyline;
|
|
|
|
primary->MemBlt = xf_gdi_memblt;
|
|
|
|
primary->Mem3Blt = xf_gdi_mem3blt;
|
|
|
|
primary->SaveBitmap = NULL;
|
|
|
|
primary->GlyphIndex = NULL;
|
|
|
|
primary->FastIndex = NULL;
|
|
|
|
primary->FastGlyph = NULL;
|
2012-02-13 02:14:59 +04:00
|
|
|
primary->PolygonSC = xf_gdi_polygon_sc;
|
|
|
|
primary->PolygonCB = xf_gdi_polygon_cb;
|
|
|
|
primary->EllipseSC = xf_gdi_ellipse_sc;
|
|
|
|
primary->EllipseCB = xf_gdi_ellipse_cb;
|
2011-08-26 02:07:52 +04:00
|
|
|
update->SurfaceBits = xf_gdi_surface_bits;
|
2011-11-25 14:48:51 +04:00
|
|
|
update->SurfaceFrameMarker = xf_gdi_surface_frame_marker;
|
2014-09-06 00:06:19 +04:00
|
|
|
update->altsec->FrameMarker = xf_gdi_frame_marker;
|
2011-08-26 02:07:52 +04:00
|
|
|
}
|
|
|
|
|