static void draw_corners (struct state *st, Drawable w, struct throbber *t) { int s = (t->size + t->thickness) / 2; XPoint points[3]; if (t->y > s) { points[0].x = 0; points[0].y = t->y - s; points[1].x = t->x - s; points[1].y = t->y - s; points[2].x = t->x - s; points[2].y = 0; XDrawLines (st->dpy, w, t->gc, points, countof(points), CoordModeOrigin); points[0].x = t->x + s; points[0].y = 0; points[1].x = t->x + s; points[1].y = t->y - s; points[2].x = t->max_size; points[2].y = t->y - s; XDrawLines (st->dpy, w, t->gc, points, countof(points), CoordModeOrigin); } if (t->x > s) { points[0].x = 0; points[0].y = t->y + s; points[1].x = t->x - s; points[1].y = t->y + s; points[2].x = t->x - s; points[2].y = t->max_size; XDrawLines (st->dpy, w, t->gc, points, countof(points), CoordModeOrigin); points[0].x = t->x + s; points[0].y = t->max_size; points[1].x = t->x + s; points[1].y = t->y + s; points[2].x = t->max_size; points[2].y = t->y + s; XDrawLines (st->dpy, w, t->gc, points, countof(points), CoordModeOrigin); } }
void drawpoly (int numpoints, int *polypoints) { int i; XPoint *Points; Points = malloc (numpoints * sizeof (XPoint)); if (Points == NULL) { TcGraphResult = grNoScanMem; return; } // Convert to viewport coordinates. for (i = 0; i < numpoints; i++) { Points[i].x = TcViewLeft + *polypoints++; Points[i].y = TcViewTop + *polypoints++; } // Now do the actual drawing. XLockDisplay (TcDisplay); XDrawLines (TcDisplay, TcPixmaps[TcActivePage], TcGc, Points, numpoints, CoordModeOrigin); if (TcActivePage == TcVisualPage) { XDrawLines (TcDisplay, TcWindow, TcGc, Points, numpoints, CoordModeOrigin); XSync (TcDisplay, False); } XUnlockDisplay (TcDisplay); free (Points); }
/* * Draws the saucer section of the spaceship. */ void Spaceship::drawSaucer(XPoint ref, int shipw, int shiph, GC gc, Display *display, Pixmap &buffer) { palette->setColor(ColorHandler::LIGHT_GREY, gc); XFillRectangle(display, buffer, gc, ref.x, ref.y, (shipw/2), (shiph/10)); palette->setColor(ColorHandler::GREY, gc); XDrawRectangle(display, buffer, gc, ref.x, ref.y, (shipw/2), (shiph/10)); XPoint points[4] = { ref, {ref.x+shipw/6, ref.y-shiph/12}, {ref.x+shipw/6+shipw/7, ref.y-shiph/12}, {ref.x+shipw/2,ref.y} }; palette->setColor(ColorHandler::LIGHT_GREY, gc); XFillPolygon(display, buffer, gc, points, 4, Convex, CoordModeOrigin); palette->setColor(ColorHandler::GREY, gc); XDrawLines(display, buffer, gc, points, 4, CoordModeOrigin); XPoint bPoints[5] = { {ref.x, ref.y+shiph/10}, {ref.x+shipw/6, ref.y+shiph/10+shiph/11}, {ref.x+shipw/6+shipw/4, ref.y+shiph/10+shiph/11}, {ref.x+shipw/2, ref.y+shiph/10}, {ref.x, ref.y+shiph/10} }; palette->setColor(ColorHandler::LIGHT_GREY, gc); XFillPolygon(display, buffer, gc, bPoints, 5, Convex, CoordModeOrigin); palette->setColor(ColorHandler::GREY, gc); XDrawLines(display, buffer, gc, bPoints, 5, CoordModeOrigin); }
/*------------------------------------------------------------- ** EraseHands ** Erase clock hands. */ static void EraseHands ( DtClockGadget w, struct tm * tm ) { XmManagerWidget mgr = (XmManagerWidget) XtParent (w); Display * dpy = XtDisplay (w); Window win = XtWindow (w); unsigned char behavior = G_Behavior (w); GC gc; if (! XtIsManaged ((Widget)w) || w->clock.numseg <= 0) return; gc = G_ClockBackgroundGC (w); /* Erase old hands. */ if (!tm || tm->tm_min != w->clock.otm.tm_min || tm->tm_hour != w->clock.otm.tm_hour) { XDrawLines (dpy, win, gc, w->clock.segbuff, VERTICES_IN_HANDS, CoordModeOrigin); XDrawLines (dpy, win, gc, w->clock.hour, VERTICES_IN_HANDS, CoordModeOrigin); XFillPolygon (dpy, win, gc, w->clock.segbuff, VERTICES_IN_HANDS, Convex, CoordModeOrigin); XFillPolygon (dpy, win, gc, w->clock.hour, VERTICES_IN_HANDS, Convex, CoordModeOrigin); } }
void xf_gdi_polyline(rdpUpdate* update, POLYLINE_ORDER* polyline) { int i; int x, y; int x1, y1; int x2, y2; int npoints; uint32 color; XPoint* points; int width, height; xfInfo* xfi = GET_XFI(update); xf_set_rop2(xfi, polyline->bRop2); color = freerdp_color_convert(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; } 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); } } xfree(points); }
void xf_gdi_polyline(rdpUpdate* update, POLYLINE_ORDER* polyline) { int i; uint32 color; XPoint* points; xfInfo* xfi = GET_XFI(update); xf_set_rop2(xfi, polyline->bRop2); color = freerdp_color_convert(polyline->penColor, xfi->srcBpp, 32, xfi->clrconv); XSetFillStyle(xfi->display, xfi->gc, FillSolid); XSetForeground(xfi->display, xfi->gc, color); points = xmalloc(sizeof(XPoint) * polyline->numPoints); for (i = 0; i < polyline->numPoints; i++) { points[i].x = polyline->points[i].x; points[i].y = polyline->points[i].y; } XDrawLines(xfi->display, xfi->drawing, xfi->gc, points, polyline->numPoints, CoordModePrevious); if (xfi->drawing == xfi->primary) { if (xfi->remote_app != True) { XDrawLines(xfi->display, xfi->drawable, xfi->gc, points, polyline->numPoints, CoordModePrevious); } } xfree(points); }
void WPigDrawPolyLine(const int *NPoints, const double *xarray, const double *yarray) { /*printf("void WPigDrawPolyLine(Long *NPoints, float *xarray, float *yarray)(NPoints = %li)\n", (long) *NPoints);*/ /*XSetForeground (XtDisplay (MainCanvas), gc,BlackPixelOfScreen (XtScreen (MainCanvas)));*/ #define MAXFASTPOINTS 5 if(*NPoints <= MAXFASTPOINTS) { int NumPoints; static XPoint points[MAXFASTPOINTS]; for (NumPoints = 0; NumPoints < (int) *NPoints; NumPoints++) { points[NumPoints].x = 0.5*width + (xarray[NumPoints]-WCentx)*WtoVScale; points[NumPoints].y = 0.5*height - (yarray[NumPoints]-WCenty)*WtoVScale; } XDrawLines(XtDisplay(MainCanvas), XtWindow(MainCanvas), gc, points, (int)*NPoints, CoordModeOrigin); if (use_pixmap) XDrawLines(XtDisplay(MainCanvas), pixmap, gc, points, (int)*NPoints, CoordModeOrigin); #undef MAXFASTPOINTS } else { /* #define MAXFASTPOINTS 8192 */ #define MAXFASTPOINTS 512 /* #define MAXFASTPOINTS (*NPoints+1) */ int NumPoints, n; int j; static XPoint points[MAXFASTPOINTS]; // short x, y; // double xd, yd; for (j= 0; j < *NPoints; j += MAXFASTPOINTS - 1) { n = ((*NPoints - j) < MAXFASTPOINTS) ? (*NPoints - j) : MAXFASTPOINTS; for (NumPoints = 0; NumPoints < n; NumPoints++) { points[NumPoints].x = 0.5*width + (xarray[j+NumPoints]-WCentx)*WtoVScale; points[NumPoints].y = 0.5*height - (yarray[j+NumPoints]-WCenty)*WtoVScale; } XDrawLines(XtDisplay(MainCanvas), XtWindow(MainCanvas), gc, points, n, CoordModeOrigin); if (use_pixmap) XDrawLines(XtDisplay(MainCanvas), pixmap, gc, points, n, CoordModeOrigin); } /* pause(); */ #undef MAXFASTPOINTS } /* XSetForeground(XtDisplay(MainCanvas), gc, CmsColourDefs[XForegrColour]);*/ }
/* draw lines between float points (with clipping) */ void FXDrawLines(Display *display, Drawable d, FGC fgc, FXPoint fpoints[], int npoints, int mode) { int i,nbuf,flush; float x1,y1,x2,y2,cx1,cy1,cx2,cy2; FXPoint *fbuf; XPoint *points,pbuf[NPBUF]; if (npoints>NPBUF) points = (XPoint *)malloc(npoints*sizeof(*points)); else points = pbuf; if (fgc->clip) { fbuf = malloc(npoints*sizeof(*fbuf)); flush = nbuf = 0; x2 = fpoints[0].fx; y2 = fpoints[0].fy; for (i=1; i<npoints; ++i) { x1 = x2; y1 = y2; x2 = fpoints[i].fx; y2 = fpoints[i].fy; if (mode==CoordModePrevious) { x2 += x1; y2 += x1; } if (!FClipLine(fgc,x1,y1,x2,y2,&cx1,&cy1,&cx2,&cy2)) { continue; } else { if (nbuf==0) { fbuf[nbuf].fx = cx1; fbuf[nbuf].fy = cy1; nbuf++; } fbuf[nbuf].fx = cx2; fbuf[nbuf].fy = cy2; nbuf++; } if (cx2!=x2 || cy2!=y2 || i==npoints-1) flush = 1; if (flush && nbuf>0) { FMapFPoints(fgc,fbuf,nbuf,points); XDrawLines(display,d,fgc->gc,points,nbuf, CoordModeOrigin); flush = nbuf = 0; } } free(fbuf); } else { FMapFPoints(fgc,fpoints,npoints,points); XDrawLines(display,d,fgc->gc,points,npoints,mode); } if (npoints>NPBUF) free(points); }
static void TabElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned int state) { TabElement *tab = elementRecord; Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, tab->backgroundObj); int borderWidth = 1; int cut = 2; XPoint pts[6]; int n = 0; Tcl_GetIntFromObj(NULL, tab->borderWidthObj, &borderWidth); if (state & TTK_STATE_SELECTED) { /* * Draw slightly outside of the allocated parcel, * to overwrite the client area border. */ b.height += borderWidth; } pts[n].x = b.x; pts[n].y = b.y + b.height - 1; ++n; pts[n].x = b.x; pts[n].y = b.y + cut; ++n; pts[n].x = b.x + cut; pts[n].y = b.y; ++n; pts[n].x = b.x + b.width-1-cut; pts[n].y = b.y; ++n; pts[n].x = b.x + b.width-1; pts[n].y = b.y + cut; ++n; pts[n].x = b.x + b.width-1; pts[n].y = b.y + b.height; ++n; XFillPolygon(Tk_Display(tkwin), d, Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC), pts, 6, Convex, CoordModeOrigin); #ifndef WIN32 /* * Account for whether XDrawLines draws endpoints by platform */ --pts[5].y; #endif while (borderWidth--) { XDrawLines(Tk_Display(tkwin), d, Tk_3DBorderGC(tkwin, border, TK_3D_LIGHT_GC), pts, 4, CoordModeOrigin); XDrawLines(Tk_Display(tkwin), d, Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC), pts+3, 3, CoordModeOrigin); ++pts[0].x; ++pts[1].x; ++pts[2].x; --pts[4].x; --pts[5].x; ++pts[2].y; ++pts[3].y; } }
static void draw_thick_arrow (struct state *st, Drawable d, struct disc *disc, int x, int y, int radius) { XPoint points[10]; double th; int radius2, radius3; double tick = ((M_PI * 2) / 72) * 2; radius *= 0.9; radius2 = radius - (radius / 8) * 3; radius3 = radius - (radius / 8) * 2; th = 2 * M_PI * (disc->theta / ((double) 360*64)); points[0].x = x + radius * cos(th); /* tip */ points[0].y = y + radius * sin(th); points[1].x = x + radius2 * cos(th - tick); /* tip left */ points[1].y = y + radius2 * sin(th - tick); points[2].x = x + radius2 * cos(th + tick); /* tip right */ points[2].y = y + radius2 * sin(th + tick); points[3] = points[0]; XDrawLines (st->dpy, d, disc->gc, points, 4, CoordModeOrigin); points[0].x = x + radius2 * cos(th - tick/2); /* top left */ points[0].y = y + radius2 * sin(th - tick/2); points[1].x = x + -radius2 * cos(th + tick/2); /* bottom left */ points[1].y = y + -radius2 * sin(th + tick/2); points[2].x = x + -radius3 * cos(th); /* bottom */ points[2].y = y + -radius3 * sin(th); points[3].x = x + -radius * cos(th); /* bottom spike */ points[3].y = y + -radius * sin(th); points[4] = points[2]; /* return */ points[5].x = x + -radius2 * cos(th - tick/2); /* bottom right */ points[5].y = y + -radius2 * sin(th - tick/2); points[6].x = x + radius2 * cos(th + tick/2); /* top right */ points[6].y = y + radius2 * sin(th + tick/2); XDrawLines (st->dpy, d, disc->gc, points, 7, CoordModeOrigin); }
void draw_map() { //also drew the route int xcord, ycord; for (ycord = 0; ycord < MAP_SIZE; ycord++) { for (xcord = 0; xcord < MAP_SIZE; xcord++) { if (mappoints[xcord][ycord] == 1) { XDrawPoint(dis, win, blue_gc, (xcord + 50), (ycord + 50)); } } } int allroutepoints[100]; int i, j; int x, xx; int y, yy; int sizeorwhat; if (route_points != 0) { for (i = 1; i <= route_points; i++) { allroutepoints[i] = en_route_x[i] + en_route_y[i] * 1000; //x + 1000* y } for (j = 1; j < route_points; j++) { x = allroutepoints[j] % 1000; y = (allroutepoints[j] - x) / 1000; xx = allroutepoints[j + 1] % 1000; yy = (allroutepoints[j + 1] - xx) / 1000; XPoint points[] = { {(x + 50), (y + 50)}, {(xx + 50), (yy + 50)}, }; sizeorwhat = sizeof (points) / sizeof (XPoint); XDrawLines(dis, win, green_gc, points, sizeorwhat, CoordModeOrigin); } } }
void iupDrawPolygon(IdrawCanvas* dc, int* points, int count, unsigned char r, unsigned char g, unsigned char b, int style) { int i; XPoint* pnt = (XPoint*)malloc(count*sizeof(XPoint)); /* XPoint uses short for coordinates */ for (i = 0; i < count; i++) { pnt[i].x = (short)points[2*i]; pnt[i].y = (short)points[2*i+1]; } XSetForeground(iupmot_display, dc->pixmap_gc, iupmotColorGetPixel(r, g, b)); if (style==IUP_DRAW_FILL) XFillPolygon(iupmot_display, dc->pixmap, dc->pixmap_gc, pnt, count, Complex, CoordModeOrigin); else { XGCValues gcval; if (style==IUP_DRAW_STROKE_DASH) gcval.line_style = LineOnOffDash; else gcval.line_style = LineSolid; XChangeGC(iupmot_display, dc->pixmap_gc, GCLineStyle, &gcval); XDrawLines(iupmot_display, dc->pixmap, dc->pixmap_gc, pnt, count, CoordModeOrigin); } free(pnt); }
x_wglpli(int nbPoints, int polygone[][2]) { int i; XPoint p[256], *xptr, *largeP; if (nbPoints > 256) { largeP = (XPoint *) calloc(nbPoints, sizeof(XPoint)); xptr = largeP; } else { xptr = p; } x_wglfshlb(); for (i=0; i < nbPoints; i++) { xptr[i].x = polygone[i][X]; xptr[i].y = h - polygone[i][Y]; } XDrawLines(wglDisp, wglDrawable, wglLineGC, xptr, nbPoints, CoordModeOrigin); if (nbPoints > 256) free(largeP); }
static void DisplayPolyF( Display *dpy, Window win, GC gc, WlzPolygonDomain *poly) { WlzFVertex2 *fvtxs; int i; /* check the polygon */ if( poly == NULL ){ return; } /* copy to an X line list */ fvtxs = (WlzFVertex2 *) poly->vtx; for(i=0; (i < poly->nvertices) && (i < MAXXPOINTS); i++, fvtxs++){ xpoints[i].x = fvtxs->vtX; xpoints[i].y = fvtxs->vtY; } /* display the polyline */ XDrawLines(dpy, win, gc, xpoints, i, CoordModeOrigin); XFlush( dpy ); return; }
/* 36% of execution time */ static void drawImage(struct state *st) { #if 0 int q; XPoint *old0, *old1, *new0, *new1; /* Problem: update the window without too much flickering. I do * this by handling each linesegment separately. First remove a * line, then draw the new line. The problem is that this leaves * small black pixels on the figure. To fix this, we draw the * entire figure using XDrawLines() afterwards. */ if (st->aPrev) { old0 = st->aPrev; old1 = st->aPrev + 1; new0 = st->aCurr; new1 = st->aCurr + 1; for (q = st->numPoints - 1; q; q--) { XDrawLine(st->dpy, st->window, st->gcClear, old0->x, old0->y, old1->x, old1->y); XDrawLine(st->dpy, st->window, st->gcDraw, new0->x, new0->y, new1->x, new1->y); ++old0; ++old1; ++new0; ++new1; } } #else XClearWindow(st->dpy,st->window); #endif XDrawLines(st->dpy, st->window, st->gcDraw, st->aCurr, st->numPoints, CoordModeOrigin); }
void NSPlate::rect3D(Mode m, int x, int y, unsigned int w, unsigned int h) { GC upperLeft, bottomRight; switch (m) { case up: upperLeft = bRimGC; bottomRight = dRimGC; break; case down: upperLeft = dRimGC; bottomRight = bRimGC; break; case flat: default: upperLeft = bottomRight = bgGC; break; } for (int i = 0; i < _thickness; i++) { short xa = x + i, ya = y + i, xe = x + w - i, ye = y + h - i; XPoint xp[5] = { {xa,ye}, {xa,ya}, {xe,ya}, {xe,ye}, {xa,ye}}; XDrawLines(NSdpy, window(), upperLeft, xp, 3, CoordModeOrigin); XDrawLines(NSdpy, window(), bottomRight, xp+2, 3, CoordModeOrigin); } }
void XDrawRoundRect(Display *disp, Window win, GC gc, int x, int y, int w, int h) { #define RAD (OFFS_X/2) #define SetPoint(pn, x0, y0) pn.x = x0; pn.y = y0 if ((w < 10) || (h < 10)) { XDrawRectangle(disp, win, gc, x, y, w, h); } else { XPoint p[9]; SetPoint(p[0], x+RAD, y); SetPoint(p[1], w-2*RAD, 0); SetPoint(p[2], RAD, RAD); SetPoint(p[3], 0, h-2*RAD); SetPoint(p[4], -RAD, RAD); SetPoint(p[5], 2*RAD-w, 0); SetPoint(p[6], -RAD, -RAD); SetPoint(p[7], 0, 2*RAD-h); SetPoint(p[8], RAD, -RAD); XDrawLines(disp, win, gc, p, 9, CoordModePrevious); } }
static void circle( /* indicate a solid angle on image */ FVECT dir, double dom ) { FVECT start, cur; XPoint pt[NSEG+1]; FVECT pp; int ip[2]; register int i; fcross(cur, dir, ourview.vup); if (normalize(cur) == 0.0) goto fail; spinvector(start, dir, cur, acos(1.-dom/(2.*PI))); for (i = 0; i <= NSEG; i++) { spinvector(cur, start, dir, 2.*PI*i/NSEG); cur[0] += ourview.vp[0]; cur[1] += ourview.vp[1]; cur[2] += ourview.vp[2]; viewloc(pp, &ourview, cur); if (pp[2] <= 0.0) goto fail; loc2pix(ip, &pres, pp[0], pp[1]); pt[i].x = ip[0]; pt[i].y = ip[1]; } XDrawLines(theDisplay, gwind, vecGC, pt, NSEG+1, CoordModeOrigin); return; fail: fprintf(stderr, "%s: cannot draw source at (%f,%f,%f)\n", progname, dir[0], dir[1], dir[2]); }
static void draw_star (struct state *st, Drawable w, struct throbber *t) { XPoint points[11]; int x = t->x; int y = t->y; /* The following constant is really: sqrt(5 - sqrt(5)) / sqrt(25 - 11 * sqrt(5)) Reference: http://mathworld.wolfram.com/Pentagram.html */ int s = t->size * 2.6180339887498985; int s2 = t->size; double c = M_PI * 2; double o = -M_PI / 2; points[0].x = x + s * cos(o + 0.0*c); points[0].y = y + s * sin(o + 0.0*c); points[1].x = x + s2 * cos(o + 0.1*c); points[1].y = y + s2 * sin(o + 0.1*c); points[2].x = x + s * cos(o + 0.2*c); points[2].y = y + s * sin(o + 0.2*c); points[3].x = x + s2 * cos(o + 0.3*c); points[3].y = y + s2 * sin(o + 0.3*c); points[4].x = x + s * cos(o + 0.4*c); points[4].y = y + s * sin(o + 0.4*c); points[5].x = x + s2 * cos(o + 0.5*c); points[5].y = y + s2 * sin(o + 0.5*c); points[6].x = x + s * cos(o + 0.6*c); points[6].y = y + s * sin(o + 0.6*c); points[7].x = x + s2 * cos(o + 0.7*c); points[7].y = y + s2 * sin(o + 0.7*c); points[8].x = x + s * cos(o + 0.8*c); points[8].y = y + s * sin(o + 0.8*c); points[9].x = x + s2 * cos(o + 0.9*c); points[9].y = y + s2 * sin(o + 0.9*c); points[10] = points[0]; XDrawLines (st->dpy, w, t->gc, points, countof(points), CoordModeOrigin); }
int Polygon_DX (double *x, double *y, int npts) { XPoint xpoint[1000] ; int k ; if (npts <= 0) return 0 ; if (npts > 1000) { printf("\nPolygon+X has been asked to deal with %d points.\n", npts) ; printf("Points past first 1000 ignored.\n") ; npts = 1000 ; } for (k = 0 ; k < npts ; k++) { xpoint[k].x = (int)x[k] ; xpoint[k].y = (int)(TheHeight -1 - y[k]) ; } XDrawLines(TheDisplay,TheDrawable,ThePixmapContext, xpoint,npts, CoordModeOrigin); XDrawLine(TheDisplay,TheDrawable,ThePixmapContext, xpoint[0].x, xpoint[0].y, xpoint[npts-1].x, xpoint[npts-1].y ) ; return 1 ; }
void drawPolygon(XPoint *points, int npoints, Color fill_color, bool fill, unsigned int line_width, int line_style, int cap_style, int join_style, int fill_rule, int function){ gc_vals.foreground = fill_color; gc_vals.line_width = line_width; gc_vals.fill_rule = fill_rule; XChangeGC(display, gc, GCForeground | GCLineWidth | GCFillRule, &gc_vals); // XSync(display, false); if(fill) XFillPolygon(display, curr_d, gc, points, npoints, Complex, CoordModeOrigin); else{ XPoint pts[npoints + 1]; int iter; // Create array with closed list for(iter = 0; iter < npoints; iter ++){ pts[iter] = points[iter]; } pts[iter] = points[0]; XDrawLines(display, curr_d, gc, pts, npoints + 1, CoordModeOrigin); } //XSync(display, false); }
/*public*/ void TtkDrawArrow( Display *display, Drawable d, GC gc, Ttk_Box b, ArrowDirection dir) { XPoint points[4]; ArrowPoints(b, dir, points); XDrawLines(display, d, gc, points, 4, CoordModeOrigin); }
/* * Draws a segment of a single trace. We draw 'samples' points from the 'tr' * trace array to pixel coordinates (x,y) with scale xs, ys. * * The confidence display is quite wide, and draws more than x0-xn. * To compensate, we need to increase x0-xn. */ static void trace_draw2(DNATrace *t, TRACE *tr, Display *d, Pixmap p, int max, GC gc, int x0, int xn, int yoff, int height, double ys, int off, int sign) { int i, h = height-1, o; XPoint *xp, *xp2; if (xn <= 0 || NULL == (xp = (XPoint *)xmalloc(xn * sizeof(XPoint)))) { return; } o = t->disp_offset * t->scale_x; if (t->read->maxTraceVal) h -= h*(double)off/t->read->maxTraceVal; for (i = 0; i < xn; i++, tr++) { xp[i].x = (int)((x0 + i) * t->scale_x) - o; if (sign) { xp[i].y = h - ys * ((int_2)*tr-off) + yoff; } else { xp[i].y = h - ys * (*tr-off) + yoff; } } for (i = 0; i < xn; i++) if (xp[i].x >= 0) break; xp2 = &xp[i]; xn -= i; if (xn > 0) { XDrawLines(d, p, gc, xp2, xn, CoordModeOrigin); } xfree(xp); }
int InitScroll(XParms xp, Parms p, int reps) { InitBltLines(); XDrawLines(xp->d, xp->w, xp->fggc, points, NUMPOINTS, CoordModeOrigin); return reps; }
int InitCopyPlane(XParms xp, Parms p, int reps) { XGCValues gcv; GC pixgc; InitBltLines(); InitCopyLocations(xp, p, reps); /* Create pixmap to write stuff into, and initialize it */ pix = XCreatePixmap(xp->d, xp->w, WIDTH, HEIGHT, p->font==NULL ? 1 : xp->vinfo.depth); gcv.graphics_exposures = False; gcv.foreground = 0; gcv.background = 1; pixgc = XCreateGC(xp->d, pix, GCForeground | GCBackground | GCGraphicsExposures, &gcv); XFillRectangle(xp->d, pix, pixgc, 0, 0, WIDTH, HEIGHT); gcv.foreground = 1; gcv.background = 0; XChangeGC(xp->d, pixgc, GCForeground | GCBackground, &gcv); XDrawLines(xp->d, pix, pixgc, points, NUMPOINTS, CoordModeOrigin); XFreeGC(xp->d, pixgc); return reps; }
/* * Class: sun_java2d_x11_X11Renderer * Method: XDrawPoly * Signature: (IJII[I[IIZ)V */ JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawPoly (JNIEnv *env, jobject xr, jlong pXSData, jlong xgc, jint transx, jint transy, jintArray xcoordsArray, jintArray ycoordsArray, jint npoints, jboolean isclosed) { #ifndef HEADLESS XPoint pTmp[POLYTEMPSIZE], *points; X11SDOps *xsdo = (X11SDOps *) pXSData; if (xsdo == NULL) { return; } if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) { JNU_ThrowNullPointerException(env, "coordinate array"); return; } if ((*env)->GetArrayLength(env, ycoordsArray) < npoints || (*env)->GetArrayLength(env, xcoordsArray) < npoints) { JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array"); return; } if (npoints < 2) { return; } points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy, pTmp, (int *)&npoints, isclosed); if (points == 0) { JNU_ThrowOutOfMemoryError(env, "translated coordinate array"); } else { if (npoints == 2) { /* * Some X11 implementations fail to draw anything for * simple 2 point polygons where the vertices are the * same point even though this violates the X11 * specification. For simplicity we will dispatch all * 2 point polygons through XDrawLine even if they are * non-degenerate as this may invoke less processing * down the line than a Poly primitive anyway. */ XDrawLine(awt_display, xsdo->drawable, (GC) xgc, points[0].x, points[0].y, points[1].x, points[1].y); } else { XDrawLines(awt_display, xsdo->drawable, (GC) xgc, points, npoints, CoordModeOrigin); } if (points != pTmp) { free(points); } X11SD_DirectRenderNotify(env, xsdo); } #endif /* !HEADLESS */ }
void Graphics::DrawPolygon(const vector<Point> & vertices) { this->PrepareGraphicsContext(); XPoint* xPoints = this->GetTransformedXPoints(vertices); XDrawLines(this->display, this->window, this->gc, xPoints, vertices.size(), CoordModeOrigin); delete[] xPoints; DebugDelay(string("DrawPolygon")); }
inline void NSSelector::drawBorder() { XPoint points[] = { {0, 0}, {NSWindow::width() - 1, 0}, {NSWindow::width() - 1, NSWindow::height() - 1}, {0, NSWindow::height() - 1}, {0, 0} }; XDrawLines(NSdpy, window(), _gc, points, 5, CoordModeOrigin); }
void car_facing_up(int startx, int starty, int finy) { startx -= 10; starty -= 15; finy -= 10; int i; XClearWindow(dis, win); XFlush(dis); //draw triangle if (starty == finy) { i = starty; XPoint points[] = { {(startx), (i + 30)}, {(startx + 10), (i + 45)}, {(startx + 20), (i + 30)}, }; int npoints = sizeof (points) / sizeof (XPoint); //draw background first XClearWindow(dis, win); draw_map(); grid_map(); //draw the car XDrawRectangle(dis, win, green_gc, startx, i, 20, 30); XDrawLines(dis, win, green_gc, points, npoints, CoordModeOrigin); XFlush(dis); } else { for (i = starty; i > finy; i -= 10) { XPoint points[] = { {(startx), (i)}, {(startx + 10), (i - 15)}, {(startx + 20), (i)}, }; int npoints = sizeof (points) / sizeof (XPoint); //draw background first XClearWindow(dis, win); draw_map(); grid_map(); //draw the car XDrawRectangle(dis, win, green_gc, startx, i, 20, 30); XDrawLines(dis, win, green_gc, points, npoints, CoordModeOrigin); XFlush(dis); } } }
void drawpoly(Image *dst, Point *pt, int np, int cap, int w, Color *col) { XPoint *xp; xp = convpts(pt, np); XSetLineAttributes(display, dst->gc, w, LineSolid, cap, JoinMiter); setgccol(dst, col); XDrawLines(display, dst->xid, dst->gc, xp, np, CoordModeOrigin); free(xp); }