void xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
Pixmap pattern;
rdpBrush* brush;
uint32 foreColor;
uint32 backColor;
xfInfo* xfi = ((xfContext*) context)->xfi;
brush = &patblt->brush;
xf_set_rop3(xfi, gdi_rop3_code(patblt->bRop));
foreColor = freerdp_color_convert_rgb(patblt->foreColor, xfi->srcBpp, 32, xfi->clrconv);
backColor = freerdp_color_convert_rgb(patblt->backColor, xfi->srcBpp, 32, xfi->clrconv);
if (brush->style == GDI_BS_SOLID)
{
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetForeground(xfi->display, xfi->gc, foreColor);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
else if (brush->style == GDI_BS_PATTERN)
{
if (brush->bpp > 1)
{
pattern = xf_brush_new(xfi, 8, 8, brush->bpp, brush->data);
XSetFillStyle(xfi->display, xfi->gc, FillTiled);
XSetTile(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XSetTile(xfi->display, xfi->gc, xfi->primary);
XFreePixmap(xfi->display, pattern);
}
else
{
pattern = xf_mono_bitmap_new(xfi, 8, 8, brush->data);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
XSetFillStyle(xfi->display, xfi->gc, FillOpaqueStippled);
XSetStipple(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfi->display, pattern);
}
}
else
{
printf("unimplemented brush style:%d\n", brush->style);
}
if (xfi->drawing == xfi->primary)
{
XSetFunction(xfi->display, xfi->gc, GXcopy);
if (xfi->remote_app != true)
{
XCopyArea(xfi->display, xfi->primary, xfi->drawable, xfi->gc, patblt->nLeftRect, patblt->nTopRect,
patblt->nWidth, patblt->nHeight, patblt->nLeftRect, patblt->nTopRect);
}
gdi_InvalidateRegion(xfi->hdc, patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
}
BOOL xf_create_window(xfContext* xfc)
{
XGCValues gcv;
XEvent xevent;
int width, height;
char* windowTitle;
rdpSettings* settings = xfc->settings;
ZeroMemory(&xevent, sizeof(xevent));
width = xfc->sessionWidth;
height = xfc->sessionHeight;
if (!xfc->hdc)
if (!(xfc->hdc = gdi_CreateDC(CLRBUF_32BPP, xfc->bpp)))
return FALSE;
if (!xfc->remote_app)
{
xfc->attribs.background_pixel = BlackPixelOfScreen(xfc->screen);
xfc->attribs.border_pixel = WhitePixelOfScreen(xfc->screen);
xfc->attribs.backing_store = xfc->primary ? NotUseful : Always;
xfc->attribs.override_redirect = False;
xfc->attribs.colormap = xfc->colormap;
xfc->attribs.bit_gravity = NorthWestGravity;
xfc->attribs.win_gravity = NorthWestGravity;
#ifdef WITH_XRENDER
xfc->offset_x = 0;
xfc->offset_y = 0;
#endif
if (settings->WindowTitle)
{
windowTitle = _strdup(settings->WindowTitle);
if (!windowTitle)
return FALSE;
}
else if (settings->ServerPort == 3389)
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(settings->ServerHostname));
sprintf(windowTitle, "FreeRDP: %s", settings->ServerHostname);
}
else
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(settings->ServerHostname) + sizeof(":00000"));
sprintf(windowTitle, "FreeRDP: %s:%i", settings->ServerHostname, settings->ServerPort);
}
#ifdef WITH_XRENDER
if (settings->SmartSizing && !xfc->fullscreen)
{
if (settings->SmartSizingWidth)
width = settings->SmartSizingWidth;
if (settings->SmartSizingHeight)
height = settings->SmartSizingHeight;
xfc->scaledWidth = width;
xfc->scaledHeight = height;
}
#endif
xfc->window = xf_CreateDesktopWindow(xfc, windowTitle, width, height);
free(windowTitle);
if (xfc->fullscreen)
xf_SetWindowFullscreen(xfc, xfc->window, xfc->fullscreen);
xfc->unobscured = (xevent.xvisibility.state == VisibilityUnobscured);
XSetWMProtocols(xfc->display, xfc->window->handle, &(xfc->WM_DELETE_WINDOW), 1);
xfc->drawable = xfc->window->handle;
}
else
{
xfc->drawable = DefaultRootWindow(xfc->display);
}
ZeroMemory(&gcv, sizeof(gcv));
if (xfc->modifierMap)
XFreeModifiermap(xfc->modifierMap);
xfc->modifierMap = XGetModifierMapping(xfc->display);
if (!xfc->gc)
xfc->gc = XCreateGC(xfc->display, xfc->drawable, GCGraphicsExposures, &gcv);
if (!xfc->primary)
xfc->primary = XCreatePixmap(xfc->display, xfc->drawable, xfc->sessionWidth, xfc->sessionHeight, xfc->depth);
xfc->drawing = xfc->primary;
if (!xfc->bitmap_mono)
xfc->bitmap_mono = XCreatePixmap(xfc->display, xfc->drawable, 8, 8, 1);
if (!xfc->gc_mono)
xfc->gc_mono = XCreateGC(xfc->display, xfc->bitmap_mono, GCGraphicsExposures, &gcv);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, BlackPixelOfScreen(xfc->screen));
XFillRectangle(xfc->display, xfc->primary, xfc->gc, 0, 0, xfc->sessionWidth, xfc->sessionHeight);
XFlush(xfc->display);
if (!xfc->image)
xfc->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
(char*) xfc->primary_buffer, xfc->sessionWidth, xfc->sessionHeight, xfc->scanline_pad, 0);
return TRUE;
}
/*############################# init_gcs() #############################*/
void
init_gcs(void)
{
XGCValues gc_values;
Window window = RootWindow(display, DefaultScreen(display));
/* GC for drawing letters on default background. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[FG];
gc_values.background = color_pool[DEFAULT_BG];
letter_gc = XCreateGC(display, window, GCFont | GCForeground |
GCBackground, &gc_values);
XSetFunction(display, letter_gc, GXcopy);
/* GC for drawing letters for normal selection. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[WHITE];
gc_values.background = color_pool[BLACK];
normal_letter_gc = XCreateGC(display, window, (XtGCMask) GCFont |
GCForeground | GCBackground, &gc_values);
XSetFunction(display, normal_letter_gc, GXcopy);
/* GC for drawing letters for locked selection. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[WHITE];
gc_values.background = color_pool[LOCKED_INVERSE];
locked_letter_gc = XCreateGC(display, window, (XtGCMask) GCFont |
GCForeground | GCBackground, &gc_values);
XSetFunction(display, locked_letter_gc, GXcopy);
/* GC for drawing letters for host name. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[FG];
gc_values.background = color_pool[WHITE];
color_letter_gc = XCreateGC(display, window, (XtGCMask) GCFont |
GCForeground | GCBackground, &gc_values);
XSetFunction(display, color_letter_gc, GXcopy);
/* GC for drawing error letters for EC counters. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[NOT_WORKING];
red_color_letter_gc = XCreateGC(display, window, (XtGCMask) GCFont |
GCForeground, &gc_values);
XSetFunction(display, red_color_letter_gc, GXcopy);
/* GC for drawing error letters for EH counters. */
gc_values.font = font_struct->fid;
gc_values.foreground = color_pool[WHITE];
gc_values.background = color_pool[ERROR_ID];
red_error_letter_gc = XCreateGC(display, window, (XtGCMask) GCFont |
GCForeground | GCBackground, &gc_values);
XSetFunction(display, red_error_letter_gc, GXcopy);
/* GC for drawing the default background. */
gc_values.foreground = color_pool[DEFAULT_BG];
default_bg_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, default_bg_gc, GXcopy);
/* GC for drawing the normal selection background. */
gc_values.foreground = color_pool[BLACK];
normal_bg_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, normal_bg_gc, GXcopy);
/* GC for drawing the locked selection background. */
gc_values.foreground = color_pool[LOCKED_INVERSE];
locked_bg_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, locked_bg_gc, GXcopy);
/* GC for drawing the label background. */
gc_values.foreground = color_pool[LABEL_BG];
label_bg_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, label_bg_gc, GXcopy);
/* GC for drawing the button background. */
gc_values.foreground = color_pool[BUTTON_BACKGROUND];
button_bg_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, button_bg_gc, GXcopy);
/* GC for drawing the background for "bytes on input" bar. */
gc_values.foreground = color_pool[TR_BAR];
tr_bar_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, tr_bar_gc, GXcopy);
/* GC for drawing the background for queue bar and leds. */
gc_values.foreground = color_pool[TR_BAR];
color_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, color_gc, GXcopy);
/* GC for drawing the black lines. */
gc_values.foreground = color_pool[BLACK];
black_line_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, black_line_gc, GXcopy);
/* GC for drawing the white lines. */
gc_values.foreground = color_pool[WHITE];
white_line_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, white_line_gc, GXcopy);
/* GC for drawing led's. */
gc_values.foreground = color_pool[TR_BAR];
led_gc = XCreateGC(display, window, (XtGCMask) GCForeground,
&gc_values);
XSetFunction(display, led_gc, GXcopy);
/* Flush buffers so all GC's are known. */
XFlush(display);
return;
}
void xf_gdi_fast_index(rdpUpdate* update, FAST_INDEX_ORDER* fast_index)
{
int i, j;
int x, y;
int w, h;
Pixmap bmp;
Pixmap* bmps;
uint32 fgcolor;
uint32 bgcolor;
GLYPH_DATA* glyph;
GLYPH_DATA** glyphs;
GLYPH_FRAGMENT* fragment;
xfInfo* xfi = ((xfContext*) update->context)->xfi;
rdpCache* cache = update->context->cache;
fgcolor = freerdp_color_convert(fast_index->foreColor, xfi->srcBpp, 32, xfi->clrconv);
bgcolor = freerdp_color_convert(fast_index->backColor, xfi->srcBpp, 32, xfi->clrconv);
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetForeground(xfi->display, xfi->gc, bgcolor);
XSetBackground(xfi->display, xfi->gc, fgcolor);
if (fast_index->opaqueRect)
{
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
x = fast_index->opLeft;
y = fast_index->opTop;
w = fast_index->opRight - fast_index->opLeft + 1;
h = fast_index->opBottom - fast_index->opTop + 1;
XFillRectangle(xfi->display, xfi->drawing, xfi->gc, x, y, w, h);
if (xfi->drawing == xfi->primary)
{
if (xfi->remote_app != True)
{
XFillRectangle(xfi->display, xfi->drawable, xfi->gc, x, y, w, h);
}
gdi_InvalidateRegion(xfi->hdc, x, y, w, h);
}
}
x = fast_index->bkLeft;
y = fast_index->y;
XSetFillStyle(xfi->display, xfi->gc, FillStippled);
for (i = 0; i < fast_index->nfragments; i++)
{
fragment = &fast_index->fragments[i];
if (fragment->operation == GLYPH_FRAGMENT_USE)
{
fragment->indices = (GLYPH_FRAGMENT_INDEX*) glyph_fragment_get(cache->glyph,
fragment->index, &fragment->nindices, (void**) &bmps);
glyphs = (GLYPH_DATA**) xmalloc(sizeof(GLYPH_DATA*) * fragment->nindices);
for (j = 0; j < fragment->nindices; j++)
{
glyphs[j] = glyph_get(cache->glyph, fast_index->cacheId, fragment->indices[j].index, (void**) &bmps[j]);
}
}
else
{
bmps = (Pixmap*) xmalloc(sizeof(Pixmap*) * fragment->nindices);
glyphs = (GLYPH_DATA**) xmalloc(sizeof(GLYPH_DATA*) * fragment->nindices);
for (j = 0; j < fragment->nindices; j++)
{
glyphs[j] = glyph_get(cache->glyph, fast_index->cacheId, fragment->indices[j].index, (void**) &bmps[j]);
}
}
for (j = 0; j < fragment->nindices; j++)
{
bmp = bmps[j];
glyph = glyphs[j];
XSetStipple(xfi->display, xfi->gc, bmp);
XSetTSOrigin(xfi->display, xfi->gc, glyph->x + x, glyph->y + y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc, glyph->x + x, glyph->y + y, glyph->cx, glyph->cy);
XSetStipple(xfi->display, xfi->gc, xfi->bitmap_mono);
if ((j + 1) < fragment->nindices)
{
if (!(fast_index->flAccel & SO_CHAR_INC_EQUAL_BM_BASE))
{
if (fast_index->flAccel & SO_VERTICAL)
{
y += fragment->indices[j + 1].delta;
}
else
{
x += fragment->indices[j + 1].delta;
}
}
else
{
x += glyph->cx;
}
}
}
if (fragment->operation == GLYPH_FRAGMENT_ADD)
{
glyph_fragment_put(cache->glyph, fragment->index,
fragment->nindices, (void*) fragment->indices, (void*) bmps);
}
}
if (xfi->drawing == xfi->primary)
{
if (xfi->remote_app != True)
{
XCopyArea(xfi->display, xfi->primary, xfi->drawable, xfi->gc,
fast_index->bkLeft, fast_index->bkTop,
fast_index->bkRight - fast_index->bkLeft + 1,
fast_index->bkBottom - fast_index->bkTop + 1,
fast_index->bkLeft, fast_index->bkTop);
}
gdi_InvalidateRegion(xfi->hdc, fast_index->bkLeft, fast_index->bkTop,
fast_index->bkRight - fast_index->bkLeft + 1,
fast_index->bkBottom - fast_index->bkTop + 1);
}
}
void xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
{
int i, npoints;
XPoint* points;
Pixmap pattern;
rdpBrush* brush;
UINT32 foreColor;
UINT32 backColor;
xfInfo* xfi = ((xfContext*) context)->xfi;
brush = &(polygon_cb->brush);
xf_set_rop2(xfi, polygon_cb->bRop2);
foreColor = freerdp_color_convert_rgb(polygon_cb->foreColor, ((xfContext*)context)->settings->color_depth, xfi->bpp, xfi->clrconv);
backColor = freerdp_color_convert_rgb(polygon_cb->backColor, ((xfContext*)context)->settings->color_depth, xfi->bpp, xfi->clrconv);
npoints = polygon_cb->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
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)
{
case 1: /* alternate */
XSetFillRule(xfi->display, xfi->gc, EvenOddRule);
break;
case 2: /* winding */
XSetFillRule(xfi->display, xfi->gc, WindingRule);
break;
default:
printf("PolygonCB unknown fillMode: %d\n", polygon_cb->fillMode);
break;
}
if (brush->style == GDI_BS_PATTERN)
{
if (brush->bpp > 1)
{
pattern = xf_brush_new(xfi, 8, 8, brush->bpp, brush->data);
XSetFillStyle(xfi->display, xfi->gc, FillTiled);
XSetTile(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillPolygon(xfi->display, xfi->drawing, xfi->gc,
points, npoints, Complex, CoordModePrevious);
if (xfi->drawing == xfi->primary)
{
XFillPolygon(xfi->display, xfi->drawable, xfi->gc,
points, npoints, Complex, CoordModePrevious);
}
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetTSOrigin(xfi->display, xfi->gc, 0, 0);
XFreePixmap(xfi->display, pattern);
}
else
{
pattern = xf_mono_bitmap_new(xfi, 8, 8, brush->data);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
if (polygon_cb->backMode == BACKMODE_TRANSPARENT)
XSetFillStyle(xfi->display, xfi->gc, FillStippled);
else if (polygon_cb->backMode == BACKMODE_OPAQUE)
XSetFillStyle(xfi->display, xfi->gc, FillOpaqueStippled);
XSetStipple(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillPolygon(xfi->display, xfi->drawing, xfi->gc,
points, npoints, Complex, CoordModePrevious);
if (xfi->drawing == xfi->primary)
{
XFillPolygon(xfi->display, xfi->drawable, xfi->gc,
points, npoints, Complex, CoordModePrevious);
}
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetTSOrigin(xfi->display, xfi->gc, 0, 0);
XFreePixmap(xfi->display, pattern);
}
}
else
{
printf("PolygonCB unimplemented brush style:%d\n", brush->style);
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
free(points);
}
void xf_xdamage_init(xfInfo* xfi)
{
Bool pixmaps;
int damage_event;
int damage_error;
int major, minor;
XGCValues values;
if (xfi->use_xshm)
{
if (XShmQueryExtension(xfi->display) != False)
{
XShmQueryVersion(xfi->display, &major, &minor, &pixmaps);
if (pixmaps != True)
{
fprintf(stderr, "XShmQueryVersion failed\n");
return;
}
}
else
{
fprintf(stderr, "XShmQueryExtension failed\n");
return;
}
}
if (XDamageQueryExtension(xfi->display, &damage_event, &damage_error) == 0)
{
fprintf(stderr, "XDamageQueryExtension failed\n");
return;
}
XDamageQueryVersion(xfi->display, &major, &minor);
if (XDamageQueryVersion(xfi->display, &major, &minor) == 0)
{
fprintf(stderr, "XDamageQueryVersion failed\n");
return;
}
else if (major < 1)
{
fprintf(stderr, "XDamageQueryVersion failed: major:%d minor:%d\n", major, minor);
return;
}
xfi->xdamage_notify_event = damage_event + XDamageNotify;
xfi->xdamage = XDamageCreate(xfi->display, xfi->root_window, XDamageReportDeltaRectangles);
if (xfi->xdamage == None)
{
fprintf(stderr, "XDamageCreate failed\n");
return;
}
#ifdef WITH_XFIXES
xfi->xdamage_region = XFixesCreateRegion(xfi->display, NULL, 0);
if (xfi->xdamage_region == None)
{
fprintf(stderr, "XFixesCreateRegion failed\n");
XDamageDestroy(xfi->display, xfi->xdamage);
xfi->xdamage = None;
return;
}
#endif
values.subwindow_mode = IncludeInferiors;
xfi->xdamage_gc = XCreateGC(xfi->display, xfi->root_window, GCSubwindowMode, &values);
XSetFunction(xfi->display, xfi->xdamage_gc, GXcopy);
}
/*
* Purpose:
* Setup the video display and windows required
*
* Parameters:
* 1st - WPRETTY structure with display style info
*
* Returns:
* GDISPLAY * to setup display
* NULL on error
*
* History:
* 12/03/2001 (Mike Bennett): Rewrote to setup the input window
* correctly and handle managed windows
* 18/03/2001 (Mike Bennett): Ammended to set window properties and
* receive the close window client message
* 26/03/2001 (Mike Bennett): Put a 1 pixel black border around a
* non-managed always on top input window
*/
GDISPLAY *setupDrawable(WPRETTY *style, int *window, int argc, char **argv) {
GDISPLAY *video;
XSetWindowAttributes winAttrib;
XSizeHints sizeHints;
unsigned long mask, col_border, col_background;
unsigned int width_border;
if(!(video = createDisplay()))
return NULL;
if(!video->display || video->screen == UNSETINT)
return NULL;
/* Default input window look - may be overrode below */
width_border = 5;
col_border = WhitePixel(video->display, video->screen);
col_background = WhitePixel(video->display, video->screen);
mask = CWSaveUnder;
winAttrib.save_under = True; /* Let the X server take care of whats
underneath this window, rather than
the client applications, it'll also
prevent needless Expose events.
NOTE: Not all X servers support this */
/* Don't let the window manager try to set borders or title bars, etc */
if(style->managed[0] == 'n' || style->display[0] == 'y') {
mask |= CWOverrideRedirect;
winAttrib.override_redirect = True;
}
/* Setup an input window to have a 1 pixel black border */
if(style->display[0] == 'i') {
width_border = 1;
col_border = BlackPixel(video->display, video->screen);
}
/* How should the window shape and position be setup? */
if(style->display[0] == 'y') {
window[WI_X] = 0;
window[WI_Y] = 0;
window[WI_WIDTH] = video->dwidth;
window[WI_HEIGHT] = video->dheight;
}
video->window = XCreateSimpleWindow(video->display,
RootWindow(video->display, video->screen),
window[WI_X], window[WI_Y], window[WI_WIDTH],
window[WI_HEIGHT], width_border,
col_border, col_background);
video->gcontext = XCreateGC(video->display, video->window, 0, NULL);
if(style->display[0] == 'y') {
mask |= CWBackPixmap;
winAttrib.background_pixmap = None; /* Don't set a background, i.e.
transparent window */
XSetFunction(video->display, video->gcontext, GXinvert);
}
XChangeWindowAttributes(video->display, video->window,
mask, &winAttrib);
// XSetForeground(video->display, video->gcontext,
// BlackPixel(video->display, video->screen));
XSetLineAttributes(video->display, video->gcontext, style->size, LineSolid,
CapButt, JoinMiter);
sizeHints.x = window[WI_X];
sizeHints.y = window[WI_Y];
sizeHints.width = window[WI_WIDTH];
sizeHints.height = window[WI_HEIGHT];
sizeHints.flags = PPosition | PSize;
XSetStandardProperties(video->display, video->window, PACKAGE, PACKAGE,
(Pixmap)NULL, argv, argc, &sizeHints);
/* Receive the close window client message */
if(style->display[0] == 'i') {
video->wmdelete = XInternAtom(video->display, "WM_DELETE_WINDOW",
False);
XSetWMProtocols(video->display, video->window, &video->wmdelete,
True);
}
return video;
}
void xf_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{
rdpBrush* brush;
xfBitmap* bitmap;
UINT32 foreColor;
UINT32 backColor;
Pixmap pattern = 0;
xfContext* context_ = (xfContext*) context;
xfInfo* xfi = context_->xfi;
brush = &mem3blt->brush;
bitmap = (xfBitmap*) mem3blt->bitmap;
xf_set_rop3(xfi, gdi_rop3_code(mem3blt->bRop));
foreColor = freerdp_color_convert_rgb(mem3blt->foreColor, context_->settings->color_depth, xfi->bpp, xfi->clrconv);
backColor = freerdp_color_convert_rgb(mem3blt->backColor, context_->settings->color_depth, xfi->bpp, xfi->clrconv);
if (brush->style == GDI_BS_PATTERN)
{
if (brush->bpp > 1)
{
pattern = xf_brush_new(xfi, 8, 8, brush->bpp, brush->data);
XSetFillStyle(xfi->display, xfi->gc, FillTiled);
XSetTile(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
}
else
{
pattern = xf_mono_bitmap_new(xfi, 8, 8, brush->data);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
XSetFillStyle(xfi->display, xfi->gc, FillOpaqueStippled);
XSetStipple(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
}
}
else if (brush->style == GDI_BS_SOLID)
{
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
}
else
{
printf("Mem3Blt unimplemented brush style:%d\n", brush->style);
}
XCopyArea(xfi->display, bitmap->pixmap, xfi->drawing, xfi->gc,
mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
mem3blt->nLeftRect, mem3blt->nTopRect);
if (xfi->drawing == xfi->primary)
{
if (xfi->remote_app != TRUE)
{
XCopyArea(xfi->display, bitmap->pixmap, xfi->drawable, xfi->gc,
mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
mem3blt->nLeftRect, mem3blt->nTopRect);
}
gdi_InvalidateRegion(xfi->hdc, mem3blt->nLeftRect, mem3blt->nTopRect, mem3blt->nWidth, mem3blt->nHeight);
}
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetTSOrigin(xfi->display, xfi->gc, 0, 0);
if (pattern != 0)
XFreePixmap(xfi->display, pattern);
XSetFunction(xfi->display, xfi->gc, GXcopy);
}
void initX() {
int x,y;
unsigned int border_width = 4;
unsigned int display_width, display_height;
char *window_name = "postplot";
char *icon_name = "postplot";
Pixmap icon_pixmap;
XSizeHints *size_hints;
XIconSize *size_list;
XWMHints *wm_hints;
XClassHint *class_hints;
XTextProperty windowName, iconName;
XSetWindowAttributes attr;
int icount;
XFontStruct *font_info;
char *display_name = NULL;
int dbug=0;
if (!(size_hints = XAllocSizeHints())) {
fprintf(stderr, "%s: failure allocating SizeHints memory\n", progname);
exit (0);
}
if (!(wm_hints = XAllocWMHints())) {
fprintf(stderr, "%s: failure allocating WMHints memory\n", progname);
exit (0);
}
if (!(class_hints = XAllocClassHint())) {
fprintf(stderr, "%s: failure allocating ClassHint memory\n", progname);
exit (0);
}
/* Connect to X server */
if ( (dpy=XOpenDisplay(display_name)) == NULL ) {
(void) fprintf( stderr, "%s: cannot connect to X server %s\n",
progname, XDisplayName(display_name));
exit(-1);
}
/* Get screen size from display structure macro */
screen_num = DefaultScreen(dpy);
display_width = DisplayWidth(dpy, screen_num);
display_height = DisplayHeight(dpy, screen_num);
/* eventually we want to set x,y from command line or
resource database */
x=y=0;
/* Size window */
width = display_width/2, height = display_height/2;
/* Create opaque window */
win = XCreateSimpleWindow(dpy, RootWindow(dpy,screen_num),
x,y,width, height, border_width, WhitePixel(dpy,screen_num),
BlackPixel(dpy,screen_num));
/* Get available icon sizes from window manager */
if (XGetIconSizes(dpy, RootWindow(dpy, screen_num),
&size_list, &icount) == 0) {
if (dbug) fprintf(stderr,
"%s: WM didn't set icon sizes - using default.\n", progname);
} else {
/* should eventually create a pixmap here */
;
}
/* Create pixmap of depth 1 (bitmap) for icon */
icon_pixmap = XCreateBitmapFromData(dpy, win,
icon_bitmap_bits, icon_bitmap_width, icon_bitmap_height);
size_hints->flags = PPosition | PSize | PMinSize;
size_hints->min_width = 300;
size_hints->min_height = 200;
if (XStringListToTextProperty(&window_name, 1, &windowName) == 0) {
fprintf(stderr, "%s: structure allocation for windowName failed.\n",
progname);
exit(-1);
}
if (XStringListToTextProperty(&icon_name, 1, &iconName) == 0) {
fprintf(stderr, "%s: structure allocation for iconName failed.\n",
progname);
exit(-1);
}
wm_hints->initial_state = NormalState;
wm_hints->input = True;
wm_hints->icon_pixmap = icon_pixmap;
wm_hints->flags = StateHint | IconPixmapHint | InputHint;
class_hints->res_name = progname;
class_hints->res_class = "pdp";
XSetWMProperties(dpy, win, &windowName, &iconName,
(char **) NULL, (int) 0, size_hints, wm_hints, class_hints);
/* Select event types wanted */
XSelectInput(dpy, win, ExposureMask | KeyPressMask |
ButtonPressMask | ButtonReleaseMask | StructureNotifyMask |
Button1MotionMask );
init_colors();
load_font(&font_info);
/* Create GC for text and drawing */
getGC(win, &gc, font_info);
getGC(win, &gcx, font_info);
XSetFunction(dpy, gcx, GXxor);
/* Display window */
XMapWindow(dpy, win);
/* turn on backing store */
attr.backing_store = Always;
XChangeWindowAttributes(dpy,win,CWBackingStore,&attr);
}
/**********************************************************************
* ExtEscape (X11DRV.@)
*/
static INT X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data,
INT out_count, LPVOID out_data )
{
X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
switch(escape)
{
case QUERYESCSUPPORT:
if (in_data)
{
switch (*(const INT *)in_data)
{
case X11DRV_ESCAPE:
return TRUE;
}
}
break;
case X11DRV_ESCAPE:
if (in_data && in_count >= sizeof(enum x11drv_escape_codes))
{
switch(*(const enum x11drv_escape_codes *)in_data)
{
case X11DRV_SET_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_set_drawable))
{
const struct x11drv_escape_set_drawable *data = in_data;
physDev->dc_rect = data->dc_rect;
physDev->drawable = data->drawable;
XFreeGC( gdi_display, physDev->gc );
physDev->gc = XCreateGC( gdi_display, physDev->drawable, 0, NULL );
XSetGraphicsExposures( gdi_display, physDev->gc, False );
XSetSubwindowMode( gdi_display, physDev->gc, data->mode );
TRACE( "SET_DRAWABLE hdc %p drawable %lx dc_rect %s\n",
dev->hdc, physDev->drawable, wine_dbgstr_rect(&physDev->dc_rect) );
return TRUE;
}
break;
case X11DRV_GET_DRAWABLE:
if (out_count >= sizeof(struct x11drv_escape_get_drawable))
{
struct x11drv_escape_get_drawable *data = out_data;
data->drawable = physDev->drawable;
return TRUE;
}
break;
case X11DRV_FLUSH_GL_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_flush_gl_drawable))
{
const struct x11drv_escape_flush_gl_drawable *data = in_data;
RECT rect = physDev->dc_rect;
OffsetRect( &rect, -physDev->dc_rect.left, -physDev->dc_rect.top );
/* The GL drawable may be lagged behind if we don't flush first, so
* flush the display make sure we copy up-to-date data */
XFlush( gdi_display );
XSetFunction( gdi_display, physDev->gc, GXcopy );
XCopyArea( gdi_display, data->gl_drawable, physDev->drawable, physDev->gc,
0, 0, rect.right, rect.bottom,
physDev->dc_rect.left, physDev->dc_rect.top );
add_device_bounds( physDev, &rect );
return TRUE;
}
break;
case X11DRV_START_EXPOSURES:
XSetGraphicsExposures( gdi_display, physDev->gc, True );
physDev->exposures = 0;
return TRUE;
case X11DRV_END_EXPOSURES:
if (out_count >= sizeof(HRGN))
{
HRGN hrgn = 0, tmp = 0;
XSetGraphicsExposures( gdi_display, physDev->gc, False );
if (physDev->exposures)
{
for (;;)
{
XEvent event;
XWindowEvent( gdi_display, physDev->drawable, ~0, &event );
if (event.type == NoExpose) break;
if (event.type == GraphicsExpose)
{
RECT rect;
rect.left = event.xgraphicsexpose.x - physDev->dc_rect.left;
rect.top = event.xgraphicsexpose.y - physDev->dc_rect.top;
rect.right = rect.left + event.xgraphicsexpose.width;
rect.bottom = rect.top + event.xgraphicsexpose.height;
if (GetLayout( dev->hdc ) & LAYOUT_RTL)
mirror_rect( &physDev->dc_rect, &rect );
TRACE( "got %s count %d\n", wine_dbgstr_rect(&rect),
event.xgraphicsexpose.count );
if (!tmp) tmp = CreateRectRgnIndirect( &rect );
else SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom );
if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR );
else
{
hrgn = tmp;
tmp = 0;
}
if (!event.xgraphicsexpose.count) break;
}
else
{
ERR( "got unexpected event %d\n", event.type );
break;
}
}
if (tmp) DeleteObject( tmp );
}
*(HRGN *)out_data = hrgn;
return TRUE;
}
break;
default:
break;
}
}
break;
}
return 0;
}
void
draw_goop(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
goopstruct *gp;
if (goops == NULL)
return;
gp = &goops[MI_SCREEN(mi)];
if (gp->layers == NULL)
return;
MI_IS_DRAWN(mi) = True;
switch (gp->mode) {
case transparent:
for (i = 0; i < gp->nlayers; i++)
draw_layer_plane(display, &(gp->layers[i]), gp->width, gp->height);
XSetForeground(display, gp->pixmap_gc, gp->background);
XSetPlaneMask(display, gp->pixmap_gc, AllPlanes);
XFillRectangle(display, gp->pixmap, gp->pixmap_gc, 0, 0,
gp->width, gp->height);
XSetForeground(display, gp->pixmap_gc, ~0L);
for (i = 0; i < gp->nlayers; i++) {
XSetPlaneMask(display, gp->pixmap_gc, gp->layers[i].pixel);
#if 0
XSetForeground (display, gp->pixmap_gc, ~0L);
XFillRectangle (display, gp->pixmap, gp->pixmap_gc, 0, 0,
gp->width, gp->height);
XSetForeground (display, gp->pixmap_gc, 0L);
#endif
draw_layer_blobs(display, gp->pixmap, gp->pixmap_gc,
&(gp->layers[i]), gp->width, gp->height,
True);
}
XCopyArea(display, gp->pixmap, window, MI_GC(mi), 0, 0,
gp->width, gp->height, 0, 0);
break;
case xored:
XSetFunction(display, gp->pixmap_gc, GXcopy);
XSetForeground(display, gp->pixmap_gc, 0);
XFillRectangle(display, gp->pixmap, gp->pixmap_gc, 0, 0,
gp->width, gp->height);
XSetFunction(display, gp->pixmap_gc, GXxor);
XSetForeground(display, gp->pixmap_gc, 1);
for (i = 0; i < gp->nlayers; i++)
draw_layer_blobs(display, gp->pixmap, gp->pixmap_gc,
&(gp->layers[i]), gp->width, gp->height,
(gp->mode != outline));
XCopyPlane(display, gp->pixmap, window, MI_GC(mi), 0, 0,
gp->width, gp->height, 0, 0, 1L);
break;
case opaque:
case outline:
XSetForeground(display, gp->pixmap_gc, MI_BLACK_PIXEL(mi));
XFillRectangle(display, gp->pixmap, gp->pixmap_gc, 0, 0,
gp->width, gp->height);
for (i = 0; i < gp->nlayers; i++) {
XSetForeground(display, gp->pixmap_gc, gp->layers[i].pixel);
draw_layer_blobs(display, gp->pixmap, gp->pixmap_gc,
&(gp->layers[i]), gp->width, gp->height,
(gp->mode != outline));
}
XCopyArea(display, gp->pixmap, window, MI_GC(mi), 0, 0,
gp->width, gp->height, 0, 0);
break;
default:
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr,
"Weirdness in draw_goop()\n");
(void) fprintf(stderr,
"gp->mode = %d\n", gp->mode);
}
break;
}
}
static void
draw_one_image(Imfsample *imfsample, Drawable d, GC gc, Image *img,
int sx, int sy, int sw, int sh)
{
int sx2, sy2;
TkImage *tkimg;
Tk_Window tkwin = imfsample->tkwin;
Display *dpy = Tk_Display(tkwin);
XColor *imagecolor = black_color;
XColor *maskcolor = white_color;
if (!img->istile) {
/* Offset the image to draw in the middle of its area,
whether larger or smaller than the given area. */
sx2 = sx + (sw - img->w) / 2;
sy2 = sy + (sh - img->h) / 2;
/* Only change the size of the rectangle being drawn if it's
smaller than what was passed in. */
if (img->w < sw) {
sx = sx2;
sw = img->w;
}
if (img->h < sh) {
sy = sy2;
sh = img->h;
}
}
/* Pick out a specific subimage if necessary. */
if (img->numsubimages > 0 && img->subimages)
img = img->subimages[img->numsubimages - 1];
tkimg = (TkImage *) img->hook;
if (tkimg == NULL)
return;
XSetClipMask(dpy, gc, None);
if (tkimg->colr != None && imfsample->show_color) {
if (img->istile) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
XFillRectangle(dpy, d, gc, sx, sy, sw, sh);
} else {
if (use_clip_mask) {
if (tkimg->mask != None && imfsample->show_masks) {
XSetClipOrigin(dpy, gc, sx2, sy2);
/* Use the image's mask to do clipped drawing. */
XSetClipMask(dpy, gc, tkimg->mask);
}
} else {
if (tkimg->mask != None && imfsample->show_masks) {
XSetFunction(dpy, gc, GXand);
XCopyArea(dpy, tkimg->mask, d, gc, 0, 0, sw, sh, sx, sy);
}
XSetFunction(dpy, gc, GXor);
}
/* Draw the color image. */
XCopyArea(dpy, tkimg->colr, d, gc, 0, 0, sw, sh, sx, sy);
if (!use_clip_mask)
XSetFunction(dpy, gc, GXcopy);
}
} else if (tkimg->solid != NULL && imfsample->show_color) {
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc, tkimg->solid->pixel);
XFillRectangle(dpy, d, gc, sx, sy, sw, sh);
} else if (tkimg->mono != None || tkimg->mask != None) {
if (use_clip_mask) {
/* The XFillRectangle code below does not work when we draw
directly to the screen on the Mac, so we use XCopyArea with a
small colored offscreen pixmap instead (this method does not
work on Unix or during double buffered drawing on the Mac). */
#ifdef MAC
if (!imfsample->double_buffer) {
Pixmap pm =
Tk_GetPixmap(dpy, Tk_WindowId(tkwin), sw, sh,
DefaultDepthOfScreen(Tk_Screen(tkwin)));
/* Draw the mask. */
if (tkimg->mask && imfsample->show_masks) {
XSetClipMask(dpy, gc, tkimg->mask);
} else {
XSetClipMask(dpy, gc, tkimg->mono);
}
if (tkimg->mono != None) {
Tk_Fill3DRectangle(tkwin, pm, white_border, 0, 0,
sw, sh, 0, 0);
} else {
Tk_Fill3DRectangle(tkwin, pm, black_border, 0, 0,
sw, sh, 0, 0);
}
XCopyArea(dpy, pm, Tk_WindowId(tkwin), gc, 0, 0,
sw, sh, sx, sy);
/* Draw the image proper. */
if (tkimg->mono != None) {
XSetClipMask(dpy, gc, tkimg->mono);
Tk_Fill3DRectangle(tkwin, pm, black_border, 0, 0,
sw, sh, 0, 0);
XCopyArea(dpy, pm, Tk_WindowId(tkwin), gc, 0, 0,
sw, sh, sx, sy);
}
Tk_FreePixmap(dpy, pm);
return;
}
#endif
XSetFillStyle(dpy, gc, FillSolid);
/* Set the color we're going to use for the mask; use the
imagecolor if we'll be using the mask as the only image. */
XSetForeground(dpy, gc,
(tkimg->mono == None ? imagecolor : maskcolor)->pixel);
XSetClipOrigin(dpy, gc, sx2, sy2);
/* Set the clip mask to be explicit mask or unit's image. */
if (tkimg->mask && imfsample->show_masks) {
XSetClipMask(dpy, gc, tkimg->mask);
} else {
XSetClipMask(dpy, gc, tkimg->mono);
}
/* Draw the mask. */
XFillRectangle(dpy, d, gc, sx, sy, sw, sh);
/* Draw the image proper. */
if (tkimg->mono != None) {
XSetForeground(dpy, gc, imagecolor->pixel);
XSetClipMask(dpy, gc, tkimg->mono);
XFillRectangle(dpy, d, gc, sx, sy, sw, sh);
}
/* The Win32 case. */
} else {
if (tkimg->mask != None && imfsample->show_masks) {
XSetFunction(dpy, gc, GXand);
XCopyArea(dpy, tkimg->mask, d, gc, 0, 0, sw, sh, sx, sy);
}
if (tkimg->mono != None) {
XSetFunction(dpy, gc, GXor);
XCopyArea(dpy, tkimg->mono, d, gc, 0, 0, sw, sh, sx, sy);
}
XSetFunction(dpy, gc, GXcopy);
}
}
}
void xf_gdi_surface_bits(rdpUpdate* update, SURFACE_BITS_COMMAND* surface_bits_command)
{
int i, tx, ty;
XImage* image;
RFX_MESSAGE* message;
xfInfo* xfi = ((xfContext*) update->context)->xfi;
RFX_CONTEXT* context = (RFX_CONTEXT*) xfi->rfx_context;
NSC_CONTEXT* ncontext = (NSC_CONTEXT*) xfi->nsc_context;
if (surface_bits_command->codecID == CODEC_ID_REMOTEFX)
{
message = rfx_process_message(context, surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetClipRectangles(xfi->display, xfi->gc,
surface_bits_command->destLeft, surface_bits_command->destTop,
(XRectangle*) message->rects, message->num_rects, YXBanded);
/* Draw the tiles to primary surface, each is 64x64. */
for (i = 0; i < message->num_tiles; i++)
{
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) message->tiles[i]->data, 64, 64, 32, 0);
tx = message->tiles[i]->x + surface_bits_command->destLeft;
ty = message->tiles[i]->y + surface_bits_command->destTop;
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0, tx, ty, 64, 64);
XFree(image);
}
/* Copy the updated region from backstore to the window. */
for (i = 0; i < message->num_rects; i++)
{
tx = message->rects[i].x + surface_bits_command->destLeft;
ty = message->rects[i].y + surface_bits_command->destTop;
if (xfi->remote_app != True)
{
XCopyArea(xfi->display, xfi->primary, xfi->drawable, xfi->gc,
tx, ty, message->rects[i].width, message->rects[i].height, tx, ty);
}
gdi_InvalidateRegion(xfi->hdc, tx, ty, message->rects[i].width, message->rects[i].height);
}
XSetClipMask(xfi->display, xfi->gc, None);
rfx_message_free(context, message);
}
else if (surface_bits_command->codecID == CODEC_ID_NSCODEC)
{
ncontext->width = surface_bits_command->width;
ncontext->height = surface_bits_command->height;
nsc_process_message(ncontext, surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
xfi->bmp_codec_nsc = (uint8*) xrealloc(xfi->bmp_codec_nsc,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(ncontext->bmpdata, xfi->bmp_codec_nsc,
surface_bits_command->width, surface_bits_command->height, 32);
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) xfi->bmp_codec_nsc, surface_bits_command->width, surface_bits_command->height, 32, 0);
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
if (xfi->remote_app != True)
{
XCopyArea(xfi->display, xfi->primary, xfi->window->handle, xfi->gc,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height,
surface_bits_command->destLeft, surface_bits_command->destTop);
}
gdi_InvalidateRegion(xfi->hdc, surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XSetClipMask(xfi->display, xfi->gc, None);
nsc_context_destroy(ncontext);
}
else if (surface_bits_command->codecID == CODEC_ID_NONE)
{
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
xfi->bmp_codec_none = (uint8*) xrealloc(xfi->bmp_codec_none,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(surface_bits_command->bitmapData, xfi->bmp_codec_none,
surface_bits_command->width, surface_bits_command->height, 32);
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) xfi->bmp_codec_none, surface_bits_command->width, surface_bits_command->height, 32, 0);
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
if (xfi->remote_app != True)
{
XCopyArea(xfi->display, xfi->primary, xfi->window->handle, xfi->gc,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height,
surface_bits_command->destLeft, surface_bits_command->destTop);
}
gdi_InvalidateRegion(xfi->hdc, surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XSetClipMask(xfi->display, xfi->gc, None);
}
else
{
printf("Unsupported codecID %d\n", surface_bits_command->codecID);
}
}
void xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
Pixmap pattern;
rdpBrush* brush;
UINT32 foreColor;
UINT32 backColor;
xfContext* context_ = (xfContext*) context;
xfInfo* xfi = context_->xfi;
xf_lock_x11(xfi, FALSE);
brush = &patblt->brush;
xf_set_rop3(xfi, gdi_rop3_code(patblt->bRop));
foreColor = freerdp_color_convert_var(patblt->foreColor, context_->settings->ColorDepth, xfi->bpp, xfi->clrconv);
backColor = freerdp_color_convert_var(patblt->backColor, context_->settings->ColorDepth, xfi->bpp, xfi->clrconv);
if (brush->style == GDI_BS_SOLID)
{
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetForeground(xfi->display, xfi->gc, foreColor);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
else if (brush->style == GDI_BS_HATCHED)
{
pattern = xf_mono_bitmap_new(xfi, 8, 8, GDI_BS_HATCHED_PATTERNS + 8 * brush->hatch);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
XSetFillStyle(xfi->display, xfi->gc, FillOpaqueStippled);
XSetStipple(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfi->display, pattern);
}
else if (brush->style == GDI_BS_PATTERN)
{
if (brush->bpp > 1)
{
pattern = xf_brush_new(xfi, 8, 8, brush->bpp, brush->data);
XSetFillStyle(xfi->display, xfi->gc, FillTiled);
XSetTile(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XSetTile(xfi->display, xfi->gc, xfi->primary);
XFreePixmap(xfi->display, pattern);
}
else
{
pattern = xf_mono_bitmap_new(xfi, 8, 8, brush->data);
XSetForeground(xfi->display, xfi->gc, backColor);
XSetBackground(xfi->display, xfi->gc, foreColor);
XSetFillStyle(xfi->display, xfi->gc, FillOpaqueStippled);
XSetStipple(xfi->display, xfi->gc, pattern);
XSetTSOrigin(xfi->display, xfi->gc, brush->x, brush->y);
XFillRectangle(xfi->display, xfi->drawing, xfi->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfi->display, pattern);
}
}
else
{
printf("unimplemented brush style:%d\n", brush->style);
}
if (xfi->drawing == xfi->primary)
{
gdi_InvalidateRegion(xfi->hdc, patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
xf_unlock_x11(xfi, FALSE);
}
int x11_shadow_xshm_init(x11ShadowSubsystem* subsystem)
{
Bool pixmaps;
int major, minor;
XGCValues values;
if (!XShmQueryExtension(subsystem->display))
return -1;
if (!XShmQueryVersion(subsystem->display, &major, &minor, &pixmaps))
return -1;
if (!pixmaps)
return -1;
subsystem->fb_shm_info.shmid = -1;
subsystem->fb_shm_info.shmaddr = (char*) -1;
subsystem->fb_shm_info.readOnly = False;
subsystem->fb_image = XShmCreateImage(subsystem->display, subsystem->visual, subsystem->depth,
ZPixmap, NULL, &(subsystem->fb_shm_info), subsystem->width, subsystem->height);
if (!subsystem->fb_image)
{
WLog_ERR(TAG, "XShmCreateImage failed");
return -1;
}
subsystem->fb_shm_info.shmid = shmget(IPC_PRIVATE,
subsystem->fb_image->bytes_per_line * subsystem->fb_image->height, IPC_CREAT | 0600);
if (subsystem->fb_shm_info.shmid == -1)
{
WLog_ERR(TAG, "shmget failed");
return -1;
}
subsystem->fb_shm_info.shmaddr = shmat(subsystem->fb_shm_info.shmid, 0, 0);
subsystem->fb_image->data = subsystem->fb_shm_info.shmaddr;
if (subsystem->fb_shm_info.shmaddr == ((char*) -1))
{
WLog_ERR(TAG, "shmat failed");
return -1;
}
if (!XShmAttach(subsystem->display, &(subsystem->fb_shm_info)))
return -1;
XSync(subsystem->display, False);
shmctl(subsystem->fb_shm_info.shmid, IPC_RMID, 0);
subsystem->fb_pixmap = XShmCreatePixmap(subsystem->display,
subsystem->root_window, subsystem->fb_image->data, &(subsystem->fb_shm_info),
subsystem->fb_image->width, subsystem->fb_image->height, subsystem->fb_image->depth);
XSync(subsystem->display, False);
if (!subsystem->fb_pixmap)
return -1;
values.subwindow_mode = IncludeInferiors;
values.graphics_exposures = False;
subsystem->xshm_gc = XCreateGC(subsystem->display, subsystem->root_window,
GCSubwindowMode | GCGraphicsExposures, &values);
XSetFunction(subsystem->display, subsystem->xshm_gc, GXcopy);
XSync(subsystem->display, False);
return 1;
}
void xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
{
int i;
int x, y;
int x1, y1;
int x2, y2;
int npoints;
UINT32 color;
XPoint* points;
int width, height;
xfContext* context_ = (xfContext*) context;
xfInfo* xfi = context_->xfi;
xf_set_rop2(xfi, polyline->bRop2);
color = freerdp_color_convert_var(polyline->penColor, context_->settings->color_depth, xfi->bpp, xfi->clrconv);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetForeground(xfi->display, xfi->gc, color);
npoints = polyline->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
points[0].x = polyline->xStart;
points[0].y = polyline->yStart;
for (i = 0; i < polyline->numPoints; i++)
{
points[i + 1].x = polyline->points[i].x;
points[i + 1].y = polyline->points[i].y;
}
XDrawLines(xfi->display, xfi->drawing, xfi->gc, points, npoints, CoordModePrevious);
if (xfi->drawing == xfi->primary)
{
if (xfi->remote_app != TRUE)
XDrawLines(xfi->display, xfi->drawable, xfi->gc, points, npoints, CoordModePrevious);
x1 = points[0].x;
y1 = points[0].y;
for (i = 1; i < npoints; i++)
{
x2 = points[i].x + x1;
y2 = points[i].y + y1;
x = (x2 < x1) ? x2 : x1;
width = (x2 > x1) ? x2 - x1 : x1 - x2;
y = (y2 < y1) ? y2 : y1;
height = (y2 > y1) ? y2 - y1 : y1 - y2;
x1 = x2;
y1 = y2;
gdi_InvalidateRegion(xfi->hdc, x, y, width, height);
}
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
free(points);
}
static BOOL xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
const rdpBrush* brush;
UINT32 foreColor;
UINT32 backColor;
xfContext* xfc = (xfContext*) context;
BOOL ret = FALSE;
if (!xf_decode_color(context->gdi, patblt->foreColor, &foreColor, NULL))
return FALSE;
if (!xf_decode_color(context->gdi, patblt->backColor, &backColor, NULL))
return FALSE;
xf_lock_x11(xfc, FALSE);
brush = &patblt->brush;
if (!xf_set_rop3(xfc, gdi_rop3_code(patblt->bRop)))
goto fail;
switch (brush->style)
{
case GDI_BS_SOLID:
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetBackground(xfc->display, xfc->gc, backColor);
XSetForeground(xfc->display, xfc->gc, foreColor);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
break;
case GDI_BS_HATCHED:
{
Pixmap pattern = xf_mono_bitmap_new(xfc, 8, 8,
&GDI_BS_HATCHED_PATTERNS[8 * brush->hatch]);
XSetBackground(xfc->display, xfc->gc, backColor);
XSetForeground(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,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfc->display, pattern);
}
break;
case GDI_BS_PATTERN:
if (brush->bpp > 1)
{
Pixmap 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,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XSetTile(xfc->display, xfc->gc, xfc->primary);
XFreePixmap(xfc->display, pattern);
}
else
{
Pixmap pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
XSetBackground(xfc->display, xfc->gc, backColor);
XSetForeground(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,
patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfc->display, pattern);
}
break;
default:
WLog_ERR(TAG, "unimplemented brush style:%d", brush->style);
goto fail;
}
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, patblt->nLeftRect, patblt->nTopRect,
patblt->nWidth, patblt->nHeight);
ret = TRUE;
fail:
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
return ret;
}
BOOL xf_set_rop3(xfInfo* xfi, int rop3)
{
int function = -1;
switch (rop3)
{
case GDI_BLACKNESS:
function = GXclear;
break;
case GDI_DPon:
function = GXnor;
break;
case GDI_DPna:
function = GXandInverted;
break;
case GDI_Pn:
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;
case GDI_PDna:
function = GXandReverse;
break;
case GDI_DSTINVERT:
function = GXinvert;
break;
case GDI_PATINVERT:
function = GXxor;
break;
case GDI_DPan:
function = GXnand;
break;
case GDI_SRCINVERT:
function = GXxor;
break;
case GDI_DSan:
function = GXnand;
break;
case GDI_SRCAND:
function = GXand;
break;
case GDI_DSxn:
function = GXequiv;
break;
case GDI_DPa:
function = GXand;
break;
case GDI_PDxn:
function = GXequiv;
break;
case GDI_D:
function = GXnoop;
break;
case GDI_DPno:
function = GXorInverted;
break;
case GDI_MERGEPAINT:
function = GXorInverted;
break;
case GDI_SRCCOPY:
function = GXcopy;
break;
case GDI_SDno:
function = GXorReverse;
break;
case GDI_SRCPAINT:
function = GXor;
break;
case GDI_PATCOPY:
function = GXcopy;
break;
case GDI_PDno:
function = GXorReverse;
break;
case GDI_DPo:
function = GXor;
break;
case GDI_WHITENESS:
function = GXset;
break;
case GDI_PSDPxax:
function = GXand;
break;
default:
break;
}
if (function < 0)
{
printf("Unsupported ROP3: 0x%08X\n", rop3);
XSetFunction(xfi->display, xfi->gc, GXclear);
return FALSE;
}
XSetFunction(xfi->display, xfi->gc, function);
return TRUE;
}
static BOOL xf_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{
const rdpBrush* brush;
xfBitmap* bitmap;
UINT32 foreColor;
UINT32 backColor;
Pixmap pattern = 0;
xfContext* xfc = (xfContext*) context;
BOOL ret = FALSE;
if (!xfc->display || !xfc->drawing)
return FALSE;
if (!xf_decode_color(context->gdi, mem3blt->foreColor, &foreColor, NULL))
return FALSE;
if (!xf_decode_color(context->gdi, mem3blt->backColor, &backColor, NULL))
return FALSE;
xf_lock_x11(xfc, FALSE);
brush = &mem3blt->brush;
bitmap = (xfBitmap*) mem3blt->bitmap;
if (!xf_set_rop3(xfc, gdi_rop3_code(mem3blt->bRop)))
goto fail;
switch (brush->style)
{
case GDI_BS_PATTERN:
if (brush->bpp > 1)
{
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);
}
else
{
pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
XSetBackground(xfc->display, xfc->gc, backColor);
XSetForeground(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);
}
break;
case GDI_BS_SOLID:
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetBackground(xfc->display, xfc->gc, backColor);
XSetForeground(xfc->display, xfc->gc, foreColor);
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
break;
default:
WLog_ERR(TAG, "Mem3Blt unimplemented brush style:%d", brush->style);
goto fail;
}
XCopyArea(xfc->display, bitmap->pixmap, xfc->drawing, xfc->gc,
mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
mem3blt->nLeftRect, mem3blt->nTopRect);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, mem3blt->nLeftRect, mem3blt->nTopRect,
mem3blt->nWidth, mem3blt->nHeight);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
if (pattern != 0)
XFreePixmap(xfc->display, pattern);
ret = TRUE;
fail:
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
return ret;
}
void xf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits_command)
{
int i, tx, ty;
XImage* image;
RFX_MESSAGE* message;
xfInfo* xfi = ((xfContext*) context)->xfi;
RFX_CONTEXT* rfx_context = (RFX_CONTEXT*) xfi->rfx_context;
NSC_CONTEXT* nsc_context = (NSC_CONTEXT*) xfi->nsc_context;
if (surface_bits_command->codecID == CODEC_ID_REMOTEFX)
{
message = rfx_process_message(rfx_context,
surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
XSetClipRectangles(xfi->display, xfi->gc,
surface_bits_command->destLeft, surface_bits_command->destTop,
(XRectangle*) message->rects, message->num_rects, YXBanded);
/* Draw the tiles to primary surface, each is 64x64. */
for (i = 0; i < message->num_tiles; i++)
{
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) message->tiles[i]->data, 64, 64, 32, 0);
tx = message->tiles[i]->x + surface_bits_command->destLeft;
ty = message->tiles[i]->y + surface_bits_command->destTop;
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0, tx, ty, 64, 64);
XFree(image);
}
/* Copy the updated region from backstore to the window. */
for (i = 0; i < message->num_rects; i++)
{
tx = message->rects[i].x + surface_bits_command->destLeft;
ty = message->rects[i].y + surface_bits_command->destTop;
xf_gdi_surface_update_frame(xfi, tx, ty, message->rects[i].width, message->rects[i].height);
}
XSetClipMask(xfi->display, xfi->gc, None);
rfx_message_free(rfx_context, message);
}
else if (surface_bits_command->codecID == CODEC_ID_NSCODEC)
{
nsc_process_message(nsc_context, surface_bits_command->bpp, surface_bits_command->width, surface_bits_command->height,
surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
xfi->bmp_codec_nsc = (BYTE*) realloc(xfi->bmp_codec_nsc,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(nsc_context->bmpdata, xfi->bmp_codec_nsc,
surface_bits_command->width, surface_bits_command->height, 32);
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) xfi->bmp_codec_nsc, surface_bits_command->width, surface_bits_command->height, 32, 0);
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XFree(image);
xf_gdi_surface_update_frame(xfi,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XSetClipMask(xfi->display, xfi->gc, None);
}
else if (surface_bits_command->codecID == CODEC_ID_NONE)
{
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
/* Validate that the data received is large enough */
if( surface_bits_command->width * surface_bits_command->height * surface_bits_command->bpp / 8 <= surface_bits_command->bitmapDataLength )
{
xfi->bmp_codec_none = (BYTE*) realloc(xfi->bmp_codec_none,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(surface_bits_command->bitmapData, xfi->bmp_codec_none,
surface_bits_command->width, surface_bits_command->height, 32);
image = XCreateImage(xfi->display, xfi->visual, 24, ZPixmap, 0,
(char*) xfi->bmp_codec_none, surface_bits_command->width, surface_bits_command->height, 32, 0);
XPutImage(xfi->display, xfi->primary, xfi->gc, image, 0, 0,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XFree(image);
xf_gdi_surface_update_frame(xfi,
surface_bits_command->destLeft, surface_bits_command->destTop,
surface_bits_command->width, surface_bits_command->height);
XSetClipMask(xfi->display, xfi->gc, None);
} else {
printf("Invalid bitmap size - data is %d bytes for %dx%d\n update", surface_bits_command->bitmapDataLength, surface_bits_command->width, surface_bits_command->height);
}
}
else
{
printf("Unsupported codecID %d\n", surface_bits_command->codecID);
}
}
static BOOL xf_gdi_polygon_sc(rdpContext* context,
const POLYGON_SC_ORDER* polygon_sc)
{
int i, npoints;
XPoint* points;
UINT32 brush_color;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
if (!xf_decode_color(context->gdi, polygon_sc->brushColor, &brush_color, NULL))
return FALSE;
xf_lock_x11(xfc, FALSE);
xf_set_rop2(xfc, polygon_sc->bRop2);
npoints = polygon_sc->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
if (!points)
{
xf_unlock_x11(xfc, FALSE);
return FALSE;
}
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 */
XSetFillRule(xfc->display, xfc->gc, EvenOddRule);
break;
case 2: /* winding */
XSetFillRule(xfc->display, xfc->gc, WindingRule);
break;
default:
WLog_ERR(TAG, "PolygonSC unknown fillMode: %d", polygon_sc->fillMode);
break;
}
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, brush_color);
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
points, npoints, Complex, CoordModePrevious);
if (xfc->drawing == xfc->primary)
{
if (!xf_gdi_invalidate_poly_region(xfc, points, npoints))
ret = FALSE;
}
XSetFunction(xfc->display, xfc->gc, GXcopy);
free(points);
xf_unlock_x11(xfc, FALSE);
return ret;
}
int xf_OutputUpdate(xfContext* xfc, xfGfxSurface* surface)
{
UINT16 width, height;
UINT32 surfaceX, surfaceY;
RECTANGLE_16 surfaceRect;
const RECTANGLE_16* extents;
surfaceX = surface->outputOriginX;
surfaceY = surface->outputOriginY;
surfaceRect.left = surfaceX;
surfaceRect.top = surfaceY;
surfaceRect.right = surfaceX + surface->width;
surfaceRect.bottom = surfaceY + surface->height;
XSetClipMask(xfc->display, xfc->gc, None);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
if (!region16_is_empty(&surface->invalidRegion))
{
extents = region16_extents(&surface->invalidRegion);
width = extents->right - extents->left;
height = extents->bottom - extents->top;
if (width > surface->width)
width = surface->width;
if (height > surface->height)
height = surface->height;
if (surface->stage)
{
freerdp_image_copy(surface->stage, xfc->format, surface->stageStep, 0, 0,
surface->width, surface->height, surface->data, surface->format, surface->scanline, 0, 0, NULL);
}
#ifdef WITH_XRENDER
if (xfc->settings->SmartSizing || xfc->settings->MultiTouchGestures)
{
XPutImage(xfc->display, xfc->primary, xfc->gc, surface->image,
extents->left, extents->top, extents->left + surfaceX, extents->top + surfaceY, width, height);
xf_draw_screen(xfc, extents->left, extents->top, width, height);
}
else
#endif
{
XPutImage(xfc->display, xfc->drawable, xfc->gc, surface->image,
extents->left, extents->top, extents->left + surfaceX, extents->top + surfaceY, width, height);
}
}
region16_clear(&surface->invalidRegion);
XSetClipMask(xfc->display, xfc->gc, None);
XSync(xfc->display, False);
return 1;
}
static BOOL xf_gdi_polygon_cb(rdpContext* context,
POLYGON_CB_ORDER* polygon_cb)
{
int i, npoints;
XPoint* points;
Pixmap pattern;
const rdpBrush* brush;
UINT32 foreColor;
UINT32 backColor;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
if (!xf_decode_color(context->gdi, polygon_cb->foreColor, &foreColor, NULL))
return FALSE;
if (!xf_decode_color(context->gdi, polygon_cb->backColor, &backColor, NULL))
return FALSE;
xf_lock_x11(xfc, FALSE);
brush = &(polygon_cb->brush);
xf_set_rop2(xfc, polygon_cb->bRop2);
npoints = polygon_cb->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
if (!points)
{
xf_unlock_x11(xfc, FALSE);
return FALSE;
}
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)
{
case GDI_FILL_ALTERNATE: /* alternate */
XSetFillRule(xfc->display, xfc->gc, EvenOddRule);
break;
case GDI_FILL_WINDING: /* winding */
XSetFillRule(xfc->display, xfc->gc, WindingRule);
break;
default:
WLog_ERR(TAG, "PolygonCB unknown fillMode: %d", polygon_cb->fillMode);
break;
}
if (brush->style == GDI_BS_PATTERN)
{
if (brush->bpp > 1)
{
pattern = xf_brush_new(xfc, 8, 8, brush->bpp, brush->data);
XSetFillStyle(xfc->display, xfc->gc, FillTiled);
XSetTile(xfc->display, xfc->gc, pattern);
}
else
{
pattern = xf_mono_bitmap_new(xfc, 8, 8, brush->data);
XSetForeground(xfc->display, xfc->gc, backColor);
XSetBackground(xfc->display, xfc->gc, foreColor);
if (polygon_cb->backMode == BACKMODE_TRANSPARENT)
XSetFillStyle(xfc->display, xfc->gc, FillStippled);
else if (polygon_cb->backMode == BACKMODE_OPAQUE)
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
XSetStipple(xfc->display, xfc->gc, pattern);
}
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
points, npoints, Complex, CoordModePrevious);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
XFreePixmap(xfc->display, pattern);
if (xfc->drawing == xfc->primary)
{
if (!xf_gdi_invalidate_poly_region(xfc, points, npoints))
ret = FALSE;
}
}
else
{
WLog_ERR(TAG, "PolygonCB unimplemented brush style:%d", brush->style);
}
XSetFunction(xfc->display, xfc->gc, GXcopy);
free(points);
xf_unlock_x11(xfc, FALSE);
return ret;
}
ENTRYPOINT void
init_strange(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
#ifndef NO_DBUF
GC gc = MI_GC(mi);
#endif
ATTRACTOR *Attractor;
#ifdef POINTS_HISTORY
startedClearing=0;
oldPointsIndex=0;
#endif
if (Root == NULL) {
if ((Root = (ATTRACTOR *) calloc(MI_NUM_SCREENS(mi),
sizeof (ATTRACTOR))) == NULL)
return;
}
Attractor = &Root[MI_SCREEN(mi)];
if (Attractor->Fold == NULL) {
int i;
if ((Attractor->Fold = (PRM *) calloc(UNIT2 + 1,
sizeof (PRM))) == NULL) {
free_strange(display, Attractor);
return;
}
for (i = 0; i <= UNIT2; ++i) {
DBL x;
/* x = ( DBL )(i)/UNIT2; */
/* x = sin( M_PI/2.0*x ); */
/* x = sqrt( x ); */
/* x = x*x; */
/* x = x*(1.0-x)*4.0; */
x = (DBL) (i) / UNIT;
x = sin(x);
Attractor->Fold[i] = DBL_To_PRM(x);
}
}
Attractor->Max_Pt = points;
if (Attractor->Buffer1 == NULL)
if ((Attractor->Buffer1 = (XPoint *) calloc(Attractor->Max_Pt,
sizeof (XPoint))) == NULL) {
free_strange(display, Attractor);
return;
}
if (Attractor->Buffer2 == NULL)
if ((Attractor->Buffer2 = (XPoint *) calloc(Attractor->Max_Pt,
sizeof (XPoint))) == NULL) {
free_strange(display, Attractor);
return;
}
Attractor->Width = MI_WIDTH(mi);
Attractor->Height = MI_HEIGHT(mi);
Attractor->Cur_Pt = 0;
Attractor->Count = 0;
Attractor->Col = NRAND(MI_NPIXELS(mi));
Attractor->Speed = 4;
Attractor->Iterate = Funcs[NRAND(2)];
Random_Prm(Attractor->Prm1);
Random_Prm(Attractor->Prm2);
#ifndef NO_DBUF
if (Attractor->dbuf != None)
XFreePixmap(display, Attractor->dbuf);
#ifdef useAccumulator
#define colorDepth ( useAccumulator ? MI_DEPTH(mi) : 1 )
#else
#define colorDepth 1
#endif
Attractor->dbuf = XCreatePixmap(display, window,
Attractor->Width, Attractor->Height, colorDepth);
/* Allocation checked */
if (Attractor->dbuf != None) {
XGCValues gcv;
gcv.foreground = 0;
gcv.background = 0;
#ifndef HAVE_COCOA
gcv.graphics_exposures = False;
#endif /* HAVE_COCOA */
gcv.function = GXcopy;
if (Attractor->dbuf_gc != None)
XFreeGC(display, Attractor->dbuf_gc);
if ((Attractor->dbuf_gc = XCreateGC(display, Attractor->dbuf,
#ifndef HAVE_COCOA
GCGraphicsExposures |
#endif /* HAVE_COCOA */
GCFunction | GCForeground | GCBackground,
&gcv)) == None) {
XFreePixmap(display, Attractor->dbuf);
Attractor->dbuf = None;
} else {
XFillRectangle(display, Attractor->dbuf, Attractor->dbuf_gc,
0, 0, Attractor->Width, Attractor->Height);
XSetBackground(display, gc, MI_BLACK_PIXEL(mi));
XSetFunction(display, gc, GXcopy);
}
}
#endif
#ifdef useAccumulator
#define A Attractor
if (useAccumulator) {
XWindowAttributes xgwa;
int i,j;
XGetWindowAttributes (display, window, &xgwa);
/* cmap = xgwa.colormap; */
/* cmap = XCreateColormap(display, window, MI_VISUAL(mi), AllocAll); */
Attractor->accMap = (int**)calloc(Attractor->Width,sizeof(int*));
for (i=0;i<Attractor->Width;i++) {
Attractor->accMap[i] = (int*)calloc(Attractor->Height,sizeof(int));
for (j=0;j<Attractor->Height;j++) {
Attractor->accMap[i][j] = 0;
}
}
#ifdef POINTS_HISTORY
numOldPoints = A->Max_Pt * MERGE_FRAMES;
oldPointsX = (int*)calloc(numOldPoints,sizeof(int));
oldPointsY = (int*)calloc(numOldPoints,sizeof(int));
#endif
cols = (XColor*)calloc(NUM_COLS,sizeof(XColor));
for (i=0;i<NUM_COLS;i++) {
float li;
#define MINBLUE 1
#define FULLBLUE 128
li = MINBLUE + (255.0-MINBLUE) * log(1.0 + ACC_GAMMA*(float)i/NUM_COLS) / log(1.0 + ACC_GAMMA);
if (li<FULLBLUE) {
cols[i].red = 0;
cols[i].green = 0;
cols[i].blue = 65536*li/FULLBLUE;
} else {
cols[i].red = 65536*(li-FULLBLUE)/(256-FULLBLUE);
cols[i].green = 65536*(li-FULLBLUE)/(256-FULLBLUE);
cols[i].blue = 65535;
}
XAllocColor (display, xgwa.colormap, &cols[i]);
/*
if (!XAllocColor(MI_DISPLAY(mi), cmap, &cols[i])) {
if (!XAllocColor(display, cmap, &cols[i])) {
cols[i].pixel = WhitePixel (display, DefaultScreen (display));
cols[i].red = cols[i].green = cols[i].blue = 0xFFFF;
}
*/
}
/*
XSetWindowColormap(display, window, cmap);
(void) XSetWMColormapWindows(display, window, &window, 1);
XInstallColormap(display, cmap);
XStoreColors(display, cmap, cols, 256);
*/
}
#undef A
#endif
MI_CLEARWINDOW(mi);
/* Do not want any exposure events from XCopyPlane */
XSetGraphicsExposures(display, MI_GC(mi), False);
}
boolean xf_set_rop3(xfInfo* xfi, int rop3)
{
int function = -1;
switch (rop3)
{
case GDI_BLACKNESS:
function = GXclear;
break;
case 0x000500A9:
function = GXnor;
break;
case 0x000A0329:
function = GXandInverted;
break;
case 0x000F0001:
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;
case 0x00500325:
function = GXandReverse;
break;
case GDI_DSTINVERT:
function = GXinvert;
break;
case GDI_PATINVERT:
function = GXxor;
break;
case 0x005F00E9:
function = GXnand;
break;
case GDI_SRCINVERT:
function = GXxor;
break;
case 0x007700E6:
function = GXnand;
break;
case GDI_SRCAND:
function = GXand;
break;
case 0x00990066:
function = GXequiv;
break;
case 0x00A000C9:
function = GXand;
break;
case GDI_PDxn:
function = GXequiv;
break;
case 0x00AA0029:
function = GXnoop;
break;
case 0x00AF0229:
function = GXorInverted;
break;
case GDI_MERGEPAINT:
function = GXorInverted;
break;
case GDI_SRCCOPY:
function = GXcopy;
break;
case 0x00DD0228:
function = GXorReverse;
break;
case GDI_SRCPAINT:
function = GXor;
break;
case GDI_PATCOPY:
function = GXcopy;
break;
case 0x00F50225:
function = GXorReverse;
break;
case 0x00FA0089:
function = GXor;
break;
case GDI_WHITENESS:
function = GXset;
break;
default:
break;
}
if (function < 0)
{
printf("Unsupported ROP3: 0x%08X\n", rop3);
XSetFunction(xfi->display, xfi->gc, GXclear);
return False;
}
XSetFunction(xfi->display, xfi->gc, function);
return True;
}
