GC create_gc(Display* display, Window win, int reverse_video) { GC gc; unsigned long valuemask = 0; XGCValues values; unsigned int line_width = 2; int line_style = LineSolid; int cap_style = CapButt; int join_style = JoinBevel; int screen_num = DefaultScreen(display); gc = XCreateGC(display, win, valuemask, &values); if (gc < 0) { fprintf(stderr, "XCreateGC: \n"); } if (reverse_video) { XSetForeground(display, gc, WhitePixel(display, screen_num)); XSetBackground(display, gc, BlackPixel(display, screen_num)); } else { XSetForeground(display, gc, BlackPixel(display, screen_num)); XSetBackground(display, gc, WhitePixel(display, screen_num)); } XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style); XSetFillStyle(display, gc, FillSolid); return gc; }
void xf_gdi_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surface_frame_marker) { xfInfo* xfi = ((xfContext*) context)->xfi; switch (surface_frame_marker->frameAction) { case SURFACECMD_FRAMEACTION_BEGIN: xfi->frame_begin = TRUE; xfi->frame_x1 = 0; xfi->frame_y1 = 0; xfi->frame_x2 = 0; xfi->frame_y2 = 0; break; case SURFACECMD_FRAMEACTION_END: xfi->frame_begin = FALSE; if (xfi->frame_x2 > xfi->frame_x1 && xfi->frame_y2 > xfi->frame_y1) { XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XCopyArea(xfi->display, xfi->primary, xfi->drawable, xfi->gc, xfi->frame_x1, xfi->frame_y1, xfi->frame_x2 - xfi->frame_x1, xfi->frame_y2 - xfi->frame_y1, xfi->frame_x1, xfi->frame_y1); gdi_InvalidateRegion(xfi->hdc, xfi->frame_x1, xfi->frame_y1, xfi->frame_x2 - xfi->frame_x1, xfi->frame_y2 - xfi->frame_y1); } break; } }
void xdrawgrid(X11Stuff *xstuff) { int i, j; double step; XPoint xp; unsigned long black = BlackPixel(xstuff->disp, xstuff->screennumber); unsigned long white = WhitePixel(xstuff->disp, xstuff->screennumber); XSetForeground(xstuff->disp, xstuff->gc, white); XSetFillStyle(xstuff->disp, xstuff->gc, FillSolid); XFillRectangle(xstuff->disp, xstuff->bufpixmap, xstuff->gc, 0, 0, xstuff->win_w, xstuff->win_h); XSetForeground(xstuff->disp, xstuff->gc, black); step = (double) (xstuff->win_scale)/10; for (i = 0; i < xstuff->win_w/step; i++) { for (j = 0; j < xstuff->win_h/step; j++) { xp.x = rint(i*step); xp.y = xstuff->win_h - rint(j*step); XDrawPoint(xstuff->disp, xstuff->bufpixmap, xstuff->gc, xp.x, xp.y); } } XSetLineAttributes(xstuff->disp, xstuff->gc, 1, LineSolid, CapButt, JoinMiter); XDrawRectangle(xstuff->disp, xstuff->bufpixmap, xstuff->gc, 0, 0, xstuff->win_w - 1, xstuff->win_h - 1); }
void xf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect) { UINT32 color; xfContext* xfc = (xfContext*) context; xf_lock_x11(xfc, FALSE); color = freerdp_convert_gdi_order_color(opaque_rect->color, context->settings->ColorDepth, xfc->format, xfc->palette); color = xf_gdi_get_color(xfc, color); 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, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); if (xfc->drawing == xfc->primary) { if (!xfc->remote_app) { XFillRectangle(xfc->display, xfc->drawable, xfc->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } gdi_InvalidateRegion(xfc->hdc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } xf_unlock_x11(xfc, FALSE); }
void xf_gdi_opaque_rect(rdpUpdate* update, OPAQUE_RECT_ORDER* opaque_rect) { uint32 color; xfInfo* xfi = ((xfContext*) update->context)->xfi; color = freerdp_color_convert(opaque_rect->color, xfi->srcBpp, xfi->bpp, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); XFillRectangle(xfi->display, xfi->drawing, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); if (xfi->drawing == xfi->primary) { if (xfi->remote_app != True) { XFillRectangle(xfi->display, xfi->drawable, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } gdi_InvalidateRegion(xfi->hdc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } }
static BOOL xf_gdi_opaque_rect(rdpContext* context, const OPAQUE_RECT_ORDER* opaque_rect) { XColor color; xfContext* xfc = (xfContext*) context; BOOL ret = TRUE; if (!xf_decode_color(xfc, opaque_rect->color, &color)) return FALSE; xf_lock_x11(xfc, FALSE); XSetFunction(xfc->display, xfc->gc, GXcopy); XSetFillStyle(xfc->display, xfc->gc, FillSolid); XSetForeground(xfc->display, xfc->gc, color.pixel); XFillRectangle(xfc->display, xfc->drawing, xfc->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); if (xfc->drawing == xfc->primary) ret = gdi_InvalidateRegion(xfc->hdc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); xf_unlock_x11(xfc, FALSE); return ret; }
static BOOL xf_gdi_multi_opaque_rect(rdpContext* context, const MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect) { UINT32 i; xfContext* xfc = (xfContext*) context; BOOL ret = TRUE; XColor color; if (!xf_decode_color(xfc, multi_opaque_rect->color, &color)) return FALSE; xf_lock_x11(xfc, FALSE); XSetFunction(xfc->display, xfc->gc, GXcopy); XSetFillStyle(xfc->display, xfc->gc, FillSolid); XSetForeground(xfc->display, xfc->gc, color.pixel); for (i = 0; i < multi_opaque_rect->numRectangles; i++) { const DELTA_RECT* rectangle = &multi_opaque_rect->rectangles[i]; XFillRectangle(xfc->display, xfc->drawing, xfc->gc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); if (xfc->drawing == xfc->primary) { if (!(ret = gdi_InvalidateRegion(xfc->hdc, rectangle->left, rectangle->top, rectangle->width, rectangle->height))) break; } } xf_unlock_x11(xfc, FALSE); return ret; }
void xf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect) { UINT32 color; xfContext* context_ = (xfContext*) context; xfInfo* xfi = context_->xfi; color = freerdp_color_convert_var(opaque_rect->color, context_->settings->ColorDepth, xfi->bpp, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); XFillRectangle(xfi->display, xfi->drawing, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); if (xfi->drawing == xfi->primary) { if (xfi->remote_app != TRUE) { XFillRectangle(xfi->display, xfi->drawable, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } gdi_InvalidateRegion(xfi->hdc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } }
void xf_hw_desktop_resize(rdpContext *context) { BOOL same; rdpSettings *settings; xfContext *xfc = (xfContext *) context; settings = xfc->instance->settings; xf_lock_x11(xfc, TRUE); if(!xfc->fullscreen) { xfc->width = settings->DesktopWidth; xfc->height = settings->DesktopHeight; if(xfc->window) xf_ResizeDesktopWindow(xfc, xfc->window, settings->DesktopWidth, settings->DesktopHeight); if(xfc->primary) { same = (xfc->primary == xfc->drawing) ? TRUE : FALSE; XFreePixmap(xfc->display, xfc->primary); xfc->primary = XCreatePixmap(xfc->display, xfc->drawable, xfc->width, xfc->height, xfc->depth); if(same) xfc->drawing = xfc->primary; } } else { XSetFunction(xfc->display, xfc->gc, GXcopy); XSetFillStyle(xfc->display, xfc->gc, FillSolid); XSetForeground(xfc->display, xfc->gc, 0); XFillRectangle(xfc->display, xfc->drawable, xfc->gc, 0, 0, xfc->width, xfc->height); } xf_unlock_x11(xfc, TRUE); }
void xf_gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt) { xfContext* xfc = (xfContext*) context; 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, dstblt->nLeftRect, dstblt->nTopRect, dstblt->nWidth, dstblt->nHeight); if (xfc->drawing == xfc->primary) { if (!xfc->remote_app) { XFillRectangle(xfc->display, xfc->drawable, xfc->gc, dstblt->nLeftRect, dstblt->nTopRect, dstblt->nWidth, dstblt->nHeight); } gdi_InvalidateRegion(xfc->hdc, dstblt->nLeftRect, dstblt->nTopRect, dstblt->nWidth, dstblt->nHeight); } XSetFunction(xfc->display, xfc->gc, GXcopy); xf_unlock_x11(xfc, FALSE); }
static BOOL xf_gdi_update_screen(xfContext* xfc, const SURFACE_BITS_COMMAND* cmd, const BYTE* pSrcData) { BOOL ret; XImage* image; if (!xfc || !pSrcData) return FALSE; XSetFunction(xfc->display, xfc->gc, GXcopy); XSetFillStyle(xfc->display, xfc->gc, FillSolid); image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0, (char*) pSrcData, cmd->width, cmd->height, xfc->scanline_pad, 0); if (image) { XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0, cmd->destLeft, cmd->destTop, cmd->width, cmd->height); XFree(image); ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width, cmd->height); } XSetClipMask(xfc->display, xfc->gc, None); return ret; }
void xf_gdi_line_to(rdpContext* context, LINE_TO_ORDER* line_to) { Drawable dst; uint32 color; xfInfo* xfi = ((xfContext*) context)->xfi; xf_set_rop2(xfi, line_to->bRop2); color = freerdp_color_convert_rgb(line_to->penColor, xfi->srcBpp, 32, xfi->clrconv); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); GET_DST(xfi, dst); XDrawLine(xfi->display, dst, xfi->gc, line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd); if (xfi->drawing == xfi->primary) { int width, height; if (!xfi->remote_app && !xfi->skip_bs) { XDrawLine(xfi->display, xfi->drawable, xfi->gc, line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd); } width = line_to->nXStart - line_to->nXEnd; height = line_to->nYStart - line_to->nYEnd; if (width < 0) width *= (-1); if (height < 0) height *= (-1); gdi_InvalidateRegion(xfi->hdc, line_to->nXStart, line_to->nYStart, width, height); } XSetFunction(xfi->display, xfi->gc, GXcopy); }
void xf_gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect) { int i; UINT32 color; DELTA_RECT* rectangle; xfContext* context_ = (xfContext*) context; xfInfo* xfi = context_->xfi; color = freerdp_color_convert_var(multi_opaque_rect->color, context_->settings->ColorDepth, xfi->bpp, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); for (i = 1; i < multi_opaque_rect->numRectangles + 1; i++) { rectangle = &multi_opaque_rect->rectangles[i]; XFillRectangle(xfi->display, xfi->drawing, xfi->gc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); if (xfi->drawing == xfi->primary) { if (xfi->remote_app != TRUE) { XFillRectangle(xfi->display, xfi->drawable, xfi->gc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); } gdi_InvalidateRegion(xfi->hdc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); } } }
void xf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect) { Drawable dst; uint32 color; xfInfo* xfi = ((xfContext*) context)->xfi; color = freerdp_color_convert_var(opaque_rect->color, xfi->srcBpp, 32, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); GET_DST(xfi, dst); XFillRectangle(xfi->display, dst, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); if (xfi->drawing == xfi->primary) { if (!xfi->remote_app && !xfi->skip_bs) { XFillRectangle(xfi->display, xfi->drawable, xfi->gc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } gdi_InvalidateRegion(xfi->hdc, opaque_rect->nLeftRect, opaque_rect->nTopRect, opaque_rect->nWidth, opaque_rect->nHeight); } }
void xf_gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect) { Drawable dst; int i; uint32 color; DELTA_RECT* rectangle; xfInfo* xfi = ((xfContext*) context)->xfi; color = freerdp_color_convert_var(multi_opaque_rect->color, xfi->srcBpp, 32, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); GET_DST(xfi, dst); for (i = 1; i < multi_opaque_rect->numRectangles + 1; i++) { rectangle = &multi_opaque_rect->rectangles[i]; XFillRectangle(xfi->display, dst, xfi->gc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); if (xfi->drawing == xfi->primary) { if (!xfi->remote_app && !xfi->skip_bs) { XFillRectangle(xfi->display, xfi->drawable, xfi->gc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); } gdi_InvalidateRegion(xfi->hdc, rectangle->left, rectangle->top, rectangle->width, rectangle->height); } } }
int main( int argc, char* argv[] ) { // see openwindow.min for the setup code ... display = XOpenDisplay(""); if (!display) exit (-1); int screen = XDefaultScreen(display); int w = 300; int h = 300; window = XCreateSimpleWindow(display,DefaultRootWindow(display), 10, 10, w, h, 2, XBlackPixel(display, screen), XWhitePixel(display, screen)); XMapRaised(display, window); XFlush(display); sleep(1); // let server get set up before sending drawing commands // this is a hack until we get to events // drawing demo with graphics context here ... GC gc = XCreateGC(display, window, 0, 0); // create a graphics context XSetForeground(display, gc, XBlackPixel(display, screen)); XSetBackground(display, gc, XWhitePixel(display, screen)); XSetFillStyle(display, gc, FillSolid); XSetLineAttributes(display, gc, 3, // 3 is line width LineSolid, CapButt, JoinRound); // other line options // draw some things XDrawLine(display, window, gc, 10, 10, w-10, h-10); XFillRectangle(display, window, gc, 50, 50, w-(2*50), h-(2*50)); XSetForeground(display, gc, XWhitePixel(display, screen)); XDrawLine(display, window, gc, w-10, 10, 10, h-10); XFlush(display); std::cout << "ENTER2exit"; std::cin.get(); // wait for input XCloseDisplay(display); }
void putimage_test(void) { int num_copies = 200; int i; long totaltime; char buf[80]; num_copies *= X.percent; XSetFillStyle(X.dpy,X.miscgc,FillTiled); XFillRectangle(X.dpy,X.win,X.miscgc,0,0,400,400); X.image = XGetImage(X.dpy,X.win,0,0,200,200,~0,XYPixmap); XSync(X.dpy,0); timer(StartTimer); for (i=0;i<num_copies;++i) XPutImage(X.dpy,X.win,X.gc,X.image,0,0,i,i,200,200); XSync(X.dpy,0); totaltime = timer(EndTimer); snprintf(buf,sizeof buf,"%.2f seconds.",(double)totaltime/1000000.); show_result(buf); }
void copyplane_test(void) { int num_copies = 200; int i; long totaltime; char buf[80]; if(!X.gcv.plane_mask || (X.gcv.plane_mask & (X.gcv.plane_mask - 1))) { show_result("exactly one bit in plane mask must be set for this test"); return; } num_copies *= X.percent; XSetPlaneMask(X.dpy, X.gc, ~0L); XSetFillStyle(X.dpy,X.miscgc,FillTiled); XFillRectangle(X.dpy,X.win,X.miscgc,0,0,400,400); XSync(X.dpy,0); timer(StartTimer); for (i=0;i<num_copies;++i) XCopyPlane(X.dpy,X.win,X.win,X.gc,i,200-i, 200,200,200-i,i,X.gcv.plane_mask); XSync(X.dpy,0); totaltime = timer(EndTimer); XSetPlaneMask(X.dpy, X.gc, X.gcv.plane_mask); snprintf(buf,sizeof buf,"%.2f seconds.",(double)totaltime/1000000.); show_result(buf); }
static BOOL xf_gdi_line_to(rdpContext* context, const LINE_TO_ORDER* line_to) { XColor color; xfContext* xfc = (xfContext*) context; BOOL ret = TRUE; if (!xf_decode_color(xfc, line_to->penColor, &color)) return FALSE; xf_lock_x11(xfc, FALSE); xf_set_rop2(xfc, line_to->bRop2); XSetFillStyle(xfc->display, xfc->gc, FillSolid); XSetForeground(xfc->display, xfc->gc, color.pixel); XDrawLine(xfc->display, xfc->drawing, xfc->gc, line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd); if (xfc->drawing == xfc->primary) { 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; ret = gdi_InvalidateRegion(xfc->hdc, x, y, w, h); } XSetFunction(xfc->display, xfc->gc, GXcopy); xf_unlock_x11(xfc, FALSE); return ret; }
static void xf_process_tsmf_redraw_event(xfInfo* xfi, RDP_REDRAW_EVENT* revent) { XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XCopyArea(xfi->display, xfi->primary, xfi->window->handle, xfi->gc, revent->x, revent->y, revent->width, revent->height, revent->x, revent->y); }
Pixmap XCreateInsensitivePixmap( Display *display, Pixmap pixmap ) { static char stipple_data[] = { 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA }; GC gc; Pixmap ipixmap, stipple; unsigned width, height, depth; Window window; /* These return values */ unsigned border; /* from XGetGeometry() */ int x, y; /* are not needed. */ ipixmap = 0; if ( NULL == display || 0 == pixmap ) return ipixmap; if ( 0 == XGetGeometry( display, pixmap, &window, &x, &y, &width, &height, &border, &depth ) ) return ipixmap; /* BadDrawable: probably an invalid pixmap */ /* Get the stipple pixmap to be used to 'gray-out' the argument pixmap. */ stipple = XCreateBitmapFromData( display, pixmap, stipple_data, 16, 16 ); if ( 0 != stipple ) { gc = XCreateGC( display, pixmap, (XtGCMask)0, NULL ); if ( NULL != gc ) { /* Create an identical copy of the argument pixmap. */ ipixmap = XCreatePixmap( display, pixmap, width, height, depth ); if ( 0 != ipixmap ) { /* Copy the argument pixmap into the new pixmap. */ XCopyArea( display, pixmap, ipixmap, gc, 0, 0, width, height, 0, 0 ); /* Refill the new pixmap using the stipple algorithm/pixmap. */ XSetStipple( display, gc, stipple ); XSetFillStyle( display, gc, FillStippled ); XFillRectangle( display, ipixmap, gc, 0, 0, width, height ); } XFreeGC( display, gc ); } XFreePixmap( display, stipple ); } return ipixmap; }
void xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc) { int i, npoints; XPoint* points; UINT32 brush_color; xfContext* xfc = (xfContext*) context; xf_lock_x11(xfc, FALSE); xf_set_rop2(xfc, polygon_sc->bRop2); brush_color = freerdp_convert_gdi_order_color(polygon_sc->brushColor, context->settings->ColorDepth, xfc->format, xfc->palette); brush_color = xf_gdi_get_color(xfc, brush_color); npoints = polygon_sc->numPoints + 1; points = malloc(sizeof(XPoint) * npoints); 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) { XFillPolygon(xfc->display, xfc->drawable, xfc->gc, points, npoints, Complex, CoordModePrevious); } XSetFunction(xfc->display, xfc->gc, GXcopy); free(points); xf_unlock_x11(xfc, FALSE); }
void createGC(Display *d, Window *w, int screen, int lineWidth, GC *gc, const char *str, XColor *color) { *gc = XCreateGC(d, *w, 0, 0); XParseColor(d, DefaultColormap(d, screen), str, color); XAllocColor(d, DefaultColormap(d, screen), color); XSetForeground(d, *gc, color->pixel); XSetLineAttributes(d, *gc, lineWidth, LineSolid, CapRound, JoinRound); XSetFillStyle(d, *gc, FillSolid); return; }
void clearWindowSnow(int winid,bool newrsrc) { if(newrsrc==true) { if(windowSnow[winid].lasty!=NULL) free(windowSnow[winid].lasty); if(windowSnow[winid].pixmap!=0) XFreePixmap(display,windowSnow[winid].pixmap); if(windowSnow[winid].mask!=0) XFreePixmap(display,windowSnow[winid].mask); if(windowSnow[winid].maskgc!=0) XFreeGC(display,windowSnow[winid].maskgc); windowSnow[winid].pixmap=XCreatePixmap(display,drawOnThis,windowSnow[winid].width,windowSnow[winid].maxHeight,depth); windowSnow[winid].mask=XCreatePixmap(display,drawOnThis,windowSnow[winid].width,windowSnow[winid].maxHeight,1); windowSnow[winid].maskgc=XCreateGC(display,windowSnow[winid].mask,0,NULL); windowSnow[winid].lasty=(int*)malloc(sizeof(int)*windowSnow[winid].width); } for(int j=0; j<windowSnow[winid].width; j++) windowSnow[winid].lasty[j]=windowSnow[winid].maxHeight; if(windowSnow[winid].mask!=0) { XSetClipMask(display,windowSnow[winid].maskgc,0); XSetClipOrigin(display,windowSnow[winid].maskgc,0,0); XSetForeground(display,windowSnow[winid].maskgc,blackColor); //XSetForeground(display,windowSnow[winid].maskgc,whiteColor); XSetFillStyle(display,windowSnow[winid].maskgc,FillSolid); XFillRectangle(display,windowSnow[winid].mask,windowSnow[winid].maskgc,0,0,windowSnow[winid].width,windowSnow[winid].maxHeight); XSetClipMask(display,gc,0); XSetClipOrigin(display,gc,0,0); XSetForeground(display,gc,blackColor); //XSetForeground(display,gc,whiteColor); XSetFillStyle(display,gc,FillSolid); XFillRectangle(display,windowSnow[winid].pixmap,gc,0,0,windowSnow[winid].width,windowSnow[winid].maxHeight); windowSnow[winid].keepSettling=true; } }
int main(int argc, char *argv[]) { Status rc; GC cont; dpy = XOpenDisplay(NULL); if( !dpy ) { fprintf(stderr, "Failed to open display"); return EXIT_FAILURE; } scr = DefaultScreen(dpy); scr_cmap = DefaultColormap(dpy, scr); rc = XAllocNamedColor(dpy, scr_cmap, "green", &green, &green); if( !rc ) { fprintf(stderr, "XAllocNamedColor: failed to allocate color"); return EXIT_FAILURE; } rc = XAllocNamedColor(dpy, scr_cmap, "blue", &blue, &blue); if ( !rc ) { fprintf(stderr, "XAllocNamedColor: failed to allocate color"); return EXIT_FAILURE; } win = XCreateSimpleWindow(dpy, RootWindow(dpy, scr), 0, 0, width, width, 0, blue.pixel, blue.pixel); XMapWindow(dpy, win); cont = XCreateGC(dpy, win, 0, NULL); XSetFillStyle(dpy, cont, FillSolid); int s; int t = 0, q = 1; while(1) { s = 0; while( s<width/2 ) { XSetForeground(dpy, cont, t ? (( (s% (2*step) )==0) ? green.pixel: blue.pixel) : (( (s% (2*step) )==0) ? blue.pixel: green.pixel) ); if(q) XFillRectangle(dpy, win, cont, s, s, width - 2*s, width - 2*s); else XFillRectangle(dpy, win, cont, width/2 - s, width/2 - s, 2*s, 2*s); s+=step; XFlush(dpy); // sleep(1); if( s!=step ) napms(500); } t=!t; q=!q; } XCloseDisplay(dpy); return EXIT_SUCCESS; }
void draw_box(int w,int h,int x,int y,int r,int g,int b){ reset_clip(); XColor bg=_rgb2XColor(0,0,0); // GC bg_gc=XCreateGC(dpy,win,0,0); XAllocColor(dpy,attr.colormap,&bg); XSetForeground(dpy,gc,bg.pixel); XSetFillStyle(dpy,gc,FillSolid); XFillRectangle(dpy,d,gc,x,y,w,h); }
void xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, uint32 bgcolor, uint32 fgcolor) { xfInfo* xfi = ((xfContext*) context)->xfi; bgcolor = (xfi->clrconv->invert)? freerdp_color_convert_var_bgr(bgcolor, xfi->srcBpp, 32, xfi->clrconv): freerdp_color_convert_var_rgb(bgcolor, xfi->srcBpp, 32, xfi->clrconv); fgcolor = (xfi->clrconv->invert)? freerdp_color_convert_var_bgr(fgcolor, xfi->srcBpp, 32, xfi->clrconv): freerdp_color_convert_var_rgb(fgcolor, xfi->srcBpp, 32, xfi->clrconv); XSetFunction(xfi->display, xfi->gc, GXcopy); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, fgcolor); XFillRectangle(xfi->display, xfi->drawing, xfi->gc, x, y, width, height); XSetForeground(xfi->display, xfi->gc, bgcolor); XSetBackground(xfi->display, xfi->gc, fgcolor); XSetFillStyle(xfi->display, xfi->gc, FillStippled); }
void xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline) { Drawable dst; int i; int x, y; int x1, y1; int x2, y2; int npoints; uint32 color; XPoint* points; int width, height; xfInfo* xfi = ((xfContext*) context)->xfi; xf_set_rop2(xfi, polyline->bRop2); color = freerdp_color_convert_rgb(polyline->penColor, xfi->srcBpp, 32, xfi->clrconv); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); npoints = polyline->numPoints + 1; points = xmalloc(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; } GET_DST(xfi, dst); XDrawLines(xfi->display, dst, xfi->gc, points, npoints, CoordModePrevious); if (xfi->drawing == xfi->primary) { if (!xfi->remote_app && !xfi->skip_bs) { 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); xfree(points); }
void xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc) { int i, npoints; XPoint* points; UINT32 brush_color; xfInfo* xfi = ((xfContext*) context)->xfi; xf_set_rop2(xfi, polygon_sc->bRop2); brush_color = freerdp_color_convert_var(polygon_sc->brushColor, ((xfContext*)context)->settings->ColorDepth, xfi->bpp, xfi->clrconv); npoints = polygon_sc->numPoints + 1; points = malloc(sizeof(XPoint) * npoints); 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(xfi->display, xfi->gc, EvenOddRule); break; case 2: /* winding */ XSetFillRule(xfi->display, xfi->gc, WindingRule); break; default: printf("PolygonSC unknown fillMode: %d\n", polygon_sc->fillMode); break; } XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, brush_color); 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); } XSetFunction(xfi->display, xfi->gc, GXcopy); free(points); }
int xf_OutputUpdate(xfContext* xfc) { UINT16 width, height; xfGfxSurface* surface; RECTANGLE_16 surfaceRect; const RECTANGLE_16* extents; if (!xfc->graphicsReset) return 1; surface = (xfGfxSurface*) xfc->gfx->GetSurfaceData(xfc->gfx, xfc->outputSurfaceId); if (!surface) return -1; surfaceRect.left = 0; surfaceRect.top = 0; surfaceRect.right = xfc->width; surfaceRect.bottom = xfc->height; region16_intersect_rect(&(xfc->invalidRegion), &(xfc->invalidRegion), &surfaceRect); XSetClipMask(xfc->display, xfc->gc, None); XSetFunction(xfc->display, xfc->gc, GXcopy); XSetFillStyle(xfc->display, xfc->gc, FillSolid); if (!region16_is_empty(&(xfc->invalidRegion))) { extents = region16_extents(&(xfc->invalidRegion)); width = extents->right - extents->left; height = extents->bottom - extents->top; if (width > xfc->width) width = xfc->width; if (height > xfc->height) height = xfc->height; XPutImage(xfc->display, xfc->drawable, xfc->gc, surface->image, extents->left, extents->top, extents->left, extents->top, width, height); } region16_clear(&(xfc->invalidRegion)); XSetClipMask(xfc->display, xfc->gc, None); XSync(xfc->display, True); return 1; }