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 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);
}
/*
* Kreslení
*/
static void expose(XExposeEvent *event)
{
static XPoint points[15] = {
{20, 70},
{0, 120},
{80, 0},
{0, -160},
{-35, 0},
{0, 130},
{-20, 0},
{0, -60},
{65, 0},
{-15, -15},
{-5, 5},
{20, 50},
{5, -30},
{-5, -40},
{-90, 0}
};
if(event->count > 0)
return; /* Kreslit jen po poslední události v øadì */
points[0].x = 20;
XDrawLines(display, topwin, def_gc, points, 15, CoordModePrevious);
points[0].x += 150;
XSetFillRule(display, my_gc, EvenOddRule);
XFillPolygon(display, topwin, my_gc, points, 14, Complex,
CoordModePrevious);
XDrawLines(display, topwin, def_gc, points, 15, CoordModePrevious);
XDrawString(display, topwin, def_gc, 170, 20, "EvenOddRule", 11);
points[0].x += 150;
XSetFillRule(display, my_gc, WindingRule);
XFillPolygon(display, topwin, my_gc, points, 14, Complex,
CoordModePrevious);
XDrawLines(display, topwin, def_gc, points, 15, CoordModePrevious);
XDrawString(display, topwin, def_gc, 320, 20, "WindingRule", 11);
}
static PyObject *
PaxGC_SetFillRule(PaxGCObject *self, PyObject*args)
{
int arg1;
if (self->shared) {
PyErr_SetString(PyExc_TypeError, "can't modify shared GC");
return NULL;
}
if (!PyArg_ParseTuple(args, "i",
&arg1))
return NULL;
XSetFillRule(self->display, self->gc,
arg1);
Py_INCREF(Py_None);
return Py_None;
}
static BOOL xf_gdi_polygon_cb(rdpContext* context,
POLYGON_CB_ORDER* polygon_cb)
{
int i, npoints;
XPoint* points;
Pixmap pattern;
const rdpBrush* brush;
XColor foreColor;
XColor backColor;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
if (!xf_decode_color(xfc, polygon_cb->foreColor, &foreColor))
return FALSE;
if (!xf_decode_color(xfc, polygon_cb->backColor, &backColor))
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: %"PRIu32"", 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.pixel);
XSetBackground(xfc->display, xfc->gc, foreColor.pixel);
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:%"PRIu32"", brush->style);
}
XSetFunction(xfc->display, xfc->gc, GXcopy);
free(points);
xf_unlock_x11(xfc, FALSE);
return ret;
}
static BOOL xf_gdi_polygon_sc(rdpContext* context,
const POLYGON_SC_ORDER* polygon_sc)
{
int i, npoints;
XPoint* points;
XColor brush_color;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
if (!xf_decode_color(xfc, polygon_sc->brushColor, &brush_color))
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: %"PRIu32"", polygon_sc->fillMode);
break;
}
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, brush_color.pixel);
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;
}
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->ColorDepth, xfi->bpp, xfi->clrconv);
backColor = freerdp_color_convert_rgb(polygon_cb->backColor, ((xfContext*) context)->settings->ColorDepth, 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 QGraphInit( void )
{
int dummy;
XSizeHints myhint;
XWMHints mywmhint;
XWindowAttributes myattrib;
if(MyDisplayName == NULL)
MyDisplayName = NullName;
if(MyTitle == NULL)
MyTitle = MyText;
if(MyWidget)
MyDisplay = XtDisplay(MyWidget);
else
MyDisplay = XOpenDisplay(MyDisplayName);
MyScreen = DefaultScreen(MyDisplay);
MyRootWindow = DefaultRootWindow(MyDisplay);
MyDepth = XDefaultDepth(MyDisplay,MyScreen);
MyBackGround = WhitePixel(MyDisplay,MyScreen);
MyForeGround = BlackPixel(MyDisplay,MyScreen);
MyBorderColor = MyForeGround;
#ifdef grid_width
MyIcon = XCreatePixmapFromBitmapData(
MyDisplay,MyRootWindow,
(char *) grid_bits,grid_width,grid_height,
MyForeGround,MyBackGround,1);
#endif
myhint.x = XMinPix;
myhint.y = YMinPix;
myhint.width = XMaxPix - XMinPix + 1;
myhint.height = YMaxPix - YMinPix + 1;
myhint.flags = PPosition | PSize;
mywmhint.flags = InputHint | IconPixmapHint;
mywmhint.input = True;
mywmhint.icon_pixmap = MyIcon;
if(MyWidget)
MyWindow = XtWindow(MyWidget);
else {
MyWindow = XCreateSimpleWindow(MyDisplay,MyRootWindow
,myhint.x,myhint.y,myhint.width,myhint.height
,MyBorder,MyBorderColor,MyBackGround);
XSetStandardProperties(MyDisplay,MyWindow,MyTitle,MyTitle
,MyIcon,MyCommand,1,&myhint);
XSetWMHints(MyDisplay,MyWindow,&mywmhint);
}
MyGc = XCreateGC(MyDisplay,MyWindow,0,0);
XSetBackground(MyDisplay,MyGc,MyBackGround);
XSetForeground(MyDisplay,MyGc,MyForeGround);
/* MyCursor=XCreateFontCursor(MyDisplay,XC_cross); */
/* MyCursor=XCreateFontCursor(MyDisplay,XC_crosshair); */
MyCursor=XCreateFontCursor(MyDisplay,XC_top_left_arrow);
XDefineCursor(MyDisplay,MyWindow,MyCursor);
XSetFillRule(MyDisplay,MyGc,WindingRule); /* p. 178 */
XSetFillStyle(MyDisplay,MyGc,FillSolid); /* p. 195 */
XSetFunction(MyDisplay,MyGc,GXcopy); /* p. 158 */
XSetLineAttributes(MyDisplay,MyGc,MyLineWidth,LineSolid
,CapRound,JoinRound); /* p. 158 */
XSelectInput(MyDisplay,MyWindow,
ButtonPressMask | KeyPressMask | ExposureMask
| StructureNotifyMask );
MyFontStruct = XLoadQueryFont(MyDisplay,"fixed");
if(MyFontStruct == 0) {
printf("Cannot load font\n");
exit(1);
}
XSetFont(MyDisplay,MyGc,MyFontStruct->fid);
XTextExtents(MyFontStruct,"M",1,&dummy,&MyFontAscent,&MyFontDescent,
&MyCharStruct);
QInitColors();
if( !MyWidget ) {
XMapRaised(MyDisplay,MyWindow);
XSync(MyDisplay,0); /* wait till window is raised and ready */
}
Initialized = 1;
/* Viewport is total window */
XGetWindowAttributes( MyDisplay , MyWindow , &myattrib );
QViewport( 0 , 0 , myattrib.width , myattrib.height );
QWindow( 0. , 0. , 1. , 1. );
}
void xopenw ( char win_name[], int win_index, float xsize,
float ysize, int *ixsize, int *iysize, int *iret )
/************************************************************************
* xopenw *
* *
* This subroutine opens one xw window and sets the initial *
* graphics context along with basic window attributes. *
* *
* xopenw ( win_name, win_index, xsize, ysize, ixsize, iysize, iret ) *
* *
* Input parameters: *
* win_name[] char window name *
* win_index int window index *
* xsize float Right edge of window *
* ysize float Bottom edge of window *
* *
* Output parameters: *
* *ixsize int Right edge of window *
* *iysize int Bottom edge of window *
* *iret int Return code *
* G_NORMAL = normal return *
** *
* Log: *
* A. Hardy/GSC 2/01 Copied from the XW driver and *
* removed size limitations *
***********************************************************************/
{
int dhght, dwdth, gemscreen, xpos, ypos, ier;
unsigned int xwdth, xhght, xbord, xdpth;
char gemname [WNAME_LEN];
Cursor curs;
Window gwin;
GC gemgc;
XGCValues values;
XSizeHints gemhint;
XSetWindowAttributes gemxswa;
XColor cred;
Window_str *cwin;
winloop_t *cloop;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
current_window = win_index;
cwin = &(gemwindow[current_window]);
cloop = &(cwin->loop[cwin->curr_loop]);
strcpy(cwin->name, win_name);
strcpy(gemname, win_name);
gemscreen = DefaultScreen( (XtPointer)gemdisplay );
/*
* Determine window height and width.
*/
dwdth = DisplayWidth( (XtPointer)gemdisplay, gemscreen );
dhght = DisplayHeight( (XtPointer)gemdisplay, gemscreen );
if ( G_ABS ( xsize - RMISSD ) < RDIFFD )
gemhint.width = 0.7 * (float) dwdth ;
else if ( ( xsize > 0.0 ) && ( xsize <= 1.0 ) )
gemhint.width = (float) dwdth * xsize ;
else if ( xsize < 100.0 ) gemhint.width = 100 ;
else gemhint.width = (int) xsize ;
if ( G_ABS ( ysize - RMISSD ) < RDIFFD )
gemhint.height = 0.7 * (float) dhght ;
else if ( ( ysize > 0.0 ) && ( ysize <= 1.0 ) )
gemhint.height = (float) dhght * ysize ;
else if ( ysize < 100.0 ) gemhint.height = 100 ;
else gemhint.height = (int) ysize ;
if ( gemhint.width < 100 ) gemhint.width = 100 ;
if ( gemhint.height < 100 ) gemhint.height = 100 ;
/*
* Determine window location.
*/
gemhint.x = dwdth - ( gemhint.width ) - ( current_window * 30 ) - 20;
if ( gemhint.x < 0 ) gemhint.x = 0;
gemhint.y = ( current_window * 30 );
gemhint.flags = USPosition | USSize;
/*
* Create the window and set standard properties and attributes.
*/
gwin = XCreateSimpleWindow( gemdisplay, root, gemhint.x, gemhint.y,
gemhint.width, gemhint.height, 5,
WhitePixel ( (XtPointer)gemdisplay, gemscreen ),
BlackPixel ( (XtPointer)gemdisplay, gemscreen ) );
cwin->window = gwin;
XSetStandardProperties( gemdisplay, gwin, gemname, gemname, None,
NULL, 0, &gemhint );
gemxswa.bit_gravity = CenterGravity;
XChangeWindowAttributes (gemdisplay, gwin, (CWBitGravity), &gemxswa );
/*
* Get the geometry and window size information.
*/
XGetGeometry( gemdisplay, gwin, &root, &xpos,
&ypos, &xwdth, &xhght, &xbord, &xdpth );
cwin->width = xwdth;
cwin->height = xhght;
cwin->depth = xdpth;
/*
* Create graphics contexts.
*/
gemgc = XCreateGC( gemdisplay, gwin, 0, 0 );
/*
* Turn of NoExpose and GraphicsExpose events. They
* don't seem to be needed and were causing many events
* to seen in xxevent().
*/
values.graphics_exposures = False;
XChangeGC( gemdisplay, gemgc, GCGraphicsExposures, &values);
cwin->gc = gemgc;
/*
* Set backgound colors.
*/
XSetBackground( gemdisplay, gemgc,
BlackPixel ( (XtPointer)gemdisplay, gemscreen ) ) ;
/*
* Set fill rule.
*/
XSetFillRule ( gemdisplay, gemgc, EvenOddRule );
/*
* Create one pixmap.
*/
cwin->pxms[cwin->curr_loop][0] =
XCreatePixmap(gemdisplay, root, xwdth, xhght, xdpth);
cwin->curpxm[cwin->curr_loop] = 0;
cloop->pxm_wdth = xwdth;
cloop->pxm_hght = xhght;
cloop->roamflg = 0;
cloop->xoffset = 0;
cloop->yoffset = 0;
cloop->pxm_x = 0;
cloop->pxm_y = 0;
cwin->area_w = xwdth;
cwin->area_h = xhght;
cwin->win_x = 0;
cwin->win_y = 0;
/*
* return device size
*/
*ixsize = xwdth;
*iysize = xhght;
/*
* clear the pixmap,
*/
xclrpxm(&(cwin->curpxm[cwin->curr_loop]), &ier);
/*
* Select the events to be processed.
*/
XSelectInput ( gemdisplay, gwin, ExposureMask );
/*
* Set the cursor to be the customary red arrow.
*/
curs = XCreateFontCursor ( gemdisplay, XC_top_left_arrow );
XDefineCursor ( gemdisplay, gwin, curs );
cred.red = 65535;
cred.blue = 0;
cred.green = 0;
cred.flags = DoRed | DoBlue | DoGreen;
XRecolorCursor ( gemdisplay, curs, &cred, &cred );
}
