static void RadioIndicatorElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned state)
{
IndicatorElement *indicator = elementRecord;
GC gcb=Ttk_GCForColor(tkwin,indicator->backgroundObj,d);
GC gcf=Ttk_GCForColor(tkwin,indicator->foregroundObj,d);
GC gcu=Ttk_GCForColor(tkwin,indicator->upperColorObj,d);
GC gcl=Ttk_GCForColor(tkwin,indicator->lowerColorObj,d);
Ttk_Padding padding;
Ttk_GetPaddingFromObj(NULL, tkwin, indicator->marginObj, &padding);
b = Ttk_PadBox(b, padding);
XFillArc(Tk_Display(tkwin),d,gcb, b.x,b.y,b.width,b.height, 0,360*64);
XDrawArc(Tk_Display(tkwin),d,gcl, b.x,b.y,b.width,b.height, 225*64,180*64);
XDrawArc(Tk_Display(tkwin),d,gcu, b.x,b.y,b.width,b.height, 45*64,180*64);
if (state & TTK_STATE_SELECTED) {
b = Ttk_PadBox(b,Ttk_UniformPadding(3));
XFillArc(Tk_Display(tkwin),d,gcf, b.x,b.y,b.width,b.height, 0,360*64);
XDrawArc(Tk_Display(tkwin),d,gcf, b.x,b.y,b.width,b.height, 0,360*64);
#if WIN32_XDRAWLINE_HACK
XDrawArc(Tk_Display(tkwin),d,gcf, b.x,b.y,b.width,b.height, 300*64,360*64);
#endif
}
}
static void LoopBooms(struct state *st, int xlim, int ylim)
{
int i;
for (i = 0; i < kMaxBooms; i++) {
Boom *m = &st->boom[i];
if (!m->alive)
continue;
if (st->loop & 1) {
if (m->outgoing) {
m->rad++;
if (m->rad >= m->max)
m->outgoing = 0;
XSetLineAttributes(st->dpy, st->draw_gc, 1, 0,0,0);
XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
XDrawArc(st->dpy, st->window, st->draw_gc, m->x - m->rad, m->y - m->rad, m->rad * 2, m->rad * 2, 0, 360 * 64);
}
else {
XSetLineAttributes(st->dpy, st->erase_gc, 1, 0,0,0);
XDrawArc(st->dpy, st->window, st->erase_gc, m->x - m->rad, m->y - m->rad, m->rad * 2, m->rad * 2, 0, 360 * 64);
m->rad--;
if (m->rad <= 0)
m->alive = 0;
}
}
}
}
void UpdateSquare(int x, int y)
{
if(x%2 != y%2) {
if(square[y][x].state) {
SetColor(square[y][x].col);
XFillArc(dpy,XtWindow(square[y][x].widget),gc,
circle1,circle1,circle2,circle2,0,360*64);
SetColor(Black);
XDrawArc(dpy,XtWindow(square[y][x].widget),gc,
circle1,circle1,circle2,circle2,0,360*64);
if(square[y][x].state == King) {
SetColor(square[y][x].col);
XFillArc(dpy,XtWindow(square[y][x].widget),gc,
circle1+4,circle1+4,circle2,circle2,0,360*64);
SetColor(Black);
XDrawArc(dpy,XtWindow(square[y][x].widget),gc,
circle1+4,circle1+4,circle2,circle2,0,360*64);
}
}
else {
SetColor(Green);
XFillArc(dpy,XtWindow(square[y][x].widget),gc,
circle1-2,circle1-2,circle2+8,circle2+8,0,360*64);
}
SetColor(square[y][x].hilite);
XDrawRectangle(dpy,XtWindow(square[y][x].widget),gc,0,0,squaresize,squaresize);
}
XSync(dpy,False);
}
ENTRYPOINT void
draw_grav(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
register unsigned char ball;
gravstruct *gp;
if (gravs == NULL)
return;
gp = &gravs[MI_SCREEN(mi)];
if (gp->planets == NULL)
return;
if (!MI_IS_DRAWN(mi)) {
for (ball = 0; ball < (unsigned char) gp->nplanets; ball++) {
planetstruct *planet = &gp->planets[ball];
/* Draw planets */
Planet(planet->xi, planet->yi);
}
/* Draw centrepoint */
XDrawArc(display, MI_WINDOW(mi), gc,
gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr,
0, 23040);
}
MI_IS_DRAWN(mi) = True;
/* Mask centrepoint */
XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
XDrawArc(display, window, gc,
gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr,
0, 23040);
/* Resize centrepoint */
switch (NRAND(4)) {
case 0:
if (gp->sr < (int) STARRADIUS)
gp->sr++;
break;
case 1:
if (gp->sr > 2)
gp->sr--;
}
/* Draw centrepoint */
XSetForeground(display, gc, gp->starcolor);
XDrawArc(display, window, gc,
gp->width / 2 - gp->sr / 2, gp->height / 2 - gp->sr / 2, gp->sr, gp->sr,
0, 23040);
for (ball = 0; ball < (unsigned char) gp->nplanets; ball++)
draw_planet(mi, &gp->planets[ball]);
}
void DrawElements(Display *display, Window window, GC graphicalContext) {
/* draw a pixel at position '5,60' (line 5, column 60) of the given window. */
XDrawPoint(display, window, graphicalContext, 5, 5);
/* draw a line between point '20,20' and point '40,100' of the window. */
XDrawLine(display, window, graphicalContext, 20, 20, 40, 100);
/* draw an arc whose center is at position 'x,y', its width (if it was a */
/* full ellipse) is 'w', and height is 'h'. Start the arc at angle 'angle1' */
/* (angle 0 is the hour '3' on a clock, and positive numbers go */
/* counter-clockwise. the angles are in units of 1/64 of a degree (so 360*64 */
/* is 360 degrees). */
int x = 30, y = 40;
int h = 15, w = 45;
int angle1 = 0, angle2 = 2.109;
XDrawArc(display, window, graphicalContext, x-(w/2), y-(h/2), w, h, angle1, angle2);
/* now use the XDrawArc() function to draw a circle whose diameter */
/* is 15 pixels, and whose center is at location '50,100'. */
XDrawArc(display, window, graphicalContext, 50-(15/2), 100-(15/2), 15, 15, 0, 360*64);
/* the XDrawLines() function draws a set of consecutive lines, whose */
/* edges are given in an array of XPoint structures. */
/* The following block will draw a triangle. We use a block here, since */
/* the C language allows defining new variables only in the beginning of */
/* a block. */
{
/* this array contains the pixels to be used as the line's end-points. */
XPoint points[] = {
{0, 0},
{15, 15},
{0, 15},
{0, 0}
};
/* and this is the number of pixels in the array. The number of drawn */
/* lines will be 'npoints - 1'. */
int npoints = sizeof(points)/sizeof(XPoint);
/* draw a small triangle at the top-left corner of the window. */
/* the triangle is made of a set of consecutive lines, whose */
/* end-point pixels are specified in the 'points' array. */
XDrawLines(display, window, graphicalContext, points, npoints, CoordModeOrigin);
}
/* draw a rectangle whose top-left corner is at '120,150', its width is */
/* 50 pixels, and height is 60 pixels. */
XDrawRectangle(display, window, graphicalContext, 120, 150, 50, 60);
/* draw a filled rectangle of the same size as above, to the left of the */
/* previous rectangle. note that this rectangle is one pixel smaller then */
/* the previous line, since 'XFillRectangle()' assumes it is filling up */
/* an already drawn rectangle. This may be used to draw a rectangle using */
/* one color, and later to fill it using another color. */
XFillRectangle(display, window, graphicalContext, 60, 150, 50, 60);
}
void GraphicWindow::point(double x, double y)
{
const int POINT_RADIUS = 3;
int disp_x = user_to_disp_x(x);
int disp_y = user_to_disp_y(y);
XSetForeground(display, xgc, BlackPixel(display, screen_num));
XDrawArc(display, win, xgc, disp_x - POINT_RADIUS, disp_y - POINT_RADIUS,
2 * POINT_RADIUS, 2 * POINT_RADIUS, 0 , 360 * 64);
XDrawArc(display, _ppm, xgc, disp_x - POINT_RADIUS,
disp_y - POINT_RADIUS, 2 * POINT_RADIUS, 2 * POINT_RADIUS, 0 , 360 * 64);
}
static void draw_truchet(struct state *st)
{
int cx = 0, cy = 0;
while(st->xgwa.height+st->overlap > cy*st->height)
{
while(st->xgwa.width+st->overlap > cx*st->width)
{
if(random()%2)
{
/* block1 */
XDrawArc(st->dpy, st->frame, st->agc,
((cx*st->width)-(st->width/2)),
((cy*st->height)-(st->height/2)),
st->width,
st->height,
0, -5760);
XDrawArc(st->dpy,st->frame, st->agc,
((cx*st->width)+(st->width/2)),
((cy*st->height)+(st->height/2)),
st->width,
st->height,
11520,
-5760);
}
else
{
/* block 2 */
XDrawArc(st->dpy,st->frame,st->agc,
((cx*st->width)+(st->width/2)),
((cy*st->height)-(st->height/2)),
st->width,
st->height,
17280,
-5760);
XDrawArc(st->dpy,st->frame,st->agc,
((cx*st->width)-(st->width/2)),
((cy*st->height)+(st->height/2)),
st->width,
st->height,
0,
5760);
}
cx++;
}
cy++;
cx=0;
}
}
static void
CanvasCB(Widget canvas, XtPointer client, XEvent *ev, Boolean *cont)
{
Display *dpy = XtDisplay(canvas) ;
Window win = XtWindow(canvas) ;
int x0,y0 ;
if( !canvas_init )
{
Colormap cmap ;
XColor y,b, dummy ;
XtVaGetValues(canvas, XtNcolormap, &cmap, 0) ;
canvasGc = XCreateGC(dpy,win, 0,NULL) ;
XSetLineAttributes(dpy, canvasGc, 8, LineSolid, CapButt, JoinRound);
XSetGraphicsExposures(dpy, canvasGc, True) ;
XAllocNamedColor(dpy, cmap, "yellow", &y, &dummy) ; yellow = y.pixel ;
XAllocNamedColor(dpy, cmap, "black", &b, &dummy) ; black = b.pixel ;
canvas_init = True ;
}
switch( ev->type ) {
case GraphicsExpose:
case Expose:
x0 = MwRulerValue2Position(topRuler, 1.) ;
y0 = MwRulerValue2Position(leftRuler, 1.) - 100 ;
XSetForeground(dpy,canvasGc, yellow) ;
XFillArc(dpy,win,canvasGc, x0,y0, 100,100, 0,360*64) ;
XSetForeground(dpy,canvasGc, black) ;
XDrawArc(dpy,win,canvasGc, x0,y0, 100,100, 0,360*64) ;
XFillArc(dpy,win,canvasGc, x0+30,y0+30, 10,10, 0,360*64) ;
XFillArc(dpy,win,canvasGc, x0+60,y0+30, 10,10, 0,360*64) ;
XDrawArc(dpy,win,canvasGc, x0+20,y0+20, 60,60, 225*64,90*64) ;
break ;
case EnterNotify:
MwRulerShowPointer(leftRuler, True) ;
MwRulerShowPointer(topRuler, True) ;
break ;
case LeaveNotify:
MwRulerShowPointer(leftRuler, False) ;
MwRulerShowPointer(topRuler, False) ;
break ;
case MotionNotify:
MwRulerSetIValue(leftRuler, ev->xmotion.y) ;
MwRulerSetIValue(topRuler, ev->xmotion.x) ;
break ;
}
}
void FloodFill (int X,int Y, int BorderColor)
{
/* a real floodfill would be rather non-trivial and inefficient on X11;
since puff only seems to use it to clean up the regio around the Smith
chart, we can get away with a much simpler function:
we just draw a _very thick_ circle in the background colour around
the Smith chart, but clipped by the square viewport around the circle.
*/
if (X==0 || Y==0) return; // FloodFill is called 4 times by the original pascal code, this check only leaves the last one
XDrawArc(dpy, pm, gcfill, Ox-500,Oy-500,X+1000,Y+1000,0,64*360);
XDrawArc(dpy, pm, gc, Ox,Oy,X,Y,0,64*360);
drawcounter++;
}
void FillEllipse (int X,int Y, int Xradius,int Yradius)
{
XFillArc(dpy, pm, gcfill, Ox+X-Xradius,Oy+Y-Yradius,Xradius*2,Yradius*2,0,64*360);
XDrawArc(dpy, pm, gc, Ox+X-Xradius,Oy+Y-Yradius,Xradius*2,Yradius*2,0,64*360);
drawcounter++;
}
static PyObject *
PaxGC_DrawArc(PaxGCObject * self, PyObject *args)
{
int arg1;
int arg2;
unsigned int arg3;
unsigned int arg4;
int arg5;
int arg6;
if (!PyArg_ParseTuple(args, "iiiiii",
&arg1,
&arg2,
&arg3,
&arg4,
&arg5,
&arg6))
return NULL;
XDrawArc(self->display, self->drawable, self->gc,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6);
Py_INCREF(Py_None);
return Py_None;
}
static void
draw_boxes (state *st)
{
int i;
for (i = 0; i < st->nboxes; i++)
{
box *b = &st->boxes[i];
if (b->flags & UNDEAD) continue;
if (! (b->flags & CHANGED)) continue;
b->flags &= ~CHANGED;
if (!st->growing_p)
{
/* When shrinking, black out an area outside of the border
before re-drawing the box.
*/
int margin = st->inc + st->border_size;
XSetForeground (st->dpy, st->gc, st->bg_color);
if (st->circles_p)
XFillArc (st->dpy, st->window, st->gc,
b->x - margin, b->y - margin,
b->w + (margin*2), b->h + (margin*2),
0, 360*64);
else
XFillRectangle (st->dpy, st->window, st->gc,
b->x - margin, b->y - margin,
b->w + (margin*2), b->h + (margin*2));
if (b->w <= 0 || b->h <= 0)
b->flags |= UNDEAD; /* really very dead now */
}
if (b->w <= 0 || b->h <= 0) continue;
XSetForeground (st->dpy, st->gc, b->fill_color);
if (st->circles_p)
XFillArc (st->dpy, st->window, st->gc, b->x, b->y, b->w, b->h,
0, 360*64);
else
XFillRectangle (st->dpy, st->window, st->gc, b->x, b->y, b->w, b->h);
if (st->border_size > 0)
{
unsigned int bd = (st->image
? st->fg_color
: st->colors [(b->fill_color + st->ncolors/2)
% st->ncolors].pixel);
XSetForeground (st->dpy, st->gc, bd);
if (st->circles_p)
XDrawArc (st->dpy, st->window, st->gc, b->x, b->y, b->w, b->h,
0, 360*64);
else
XDrawRectangle (st->dpy, st->window, st->gc,
b->x, b->y, b->w, b->h);
}
}
}
void stk_canvas_draw_arc(stk_widget *pl, uint x, uint y, uint w, uint h,
uint angle0, uint angle1)
{
stk_canvas *spl = (stk_canvas*)pl->ext_struct;
XDrawArc(pl->dsp, spl->pmap, pl->gc2, x, y, w, h, angle0, angle1);
stk_canvas_expose(pl);
}
void draw_popup(popup_window *w) {
XDrawArc(w->dsp, w->canvas, w->ctx, 60, 40, 40, 40, 45, 135);
XClearArea(w->dsp, w->win, 0, 0, w->w, w->h, 0);
XCopyArea(dc->dpy, dc->canvas, w->win, w->ctx, 0, 0, w->w, w->h, 0, 0);
XFlush(dc->dpy);
}
static gboolean
draw_arc (gpointer data)
{
Pixmap pixmap = GPOINTER_TO_UINT (data);
Display *dpy = clutter_x11_get_default_display ();
static GC gc = None;
static int x = 100, y = 100;
if (gc == None)
{
XGCValues gc_values = { 0 };
gc_values.line_width = 12;
/* This is an attempt to get a black pixel will full
opacity. Seemingly the BlackPixel macro and the default GC
value are a fully transparent color */
gc_values.foreground = 0xff000000;
gc = XCreateGC (dpy,
pixmap,
GCLineWidth | GCForeground,
&gc_values);
}
XDrawArc (dpy, pixmap, gc, x, y, 100, 100, 0, 360 * 64);
x -= 5;
y -= 5;
return G_SOURCE_CONTINUE;
}
static void DrawCircle ( Window w, GC gc, int x, int y, int x2, int y2 )
{
FixDataOrdering ( &x, &y, &x2, &y2 );
XDrawArc ( display, w, gc, x, y,
x2 - x, y2 - y, 0, 64 * 360 );
}
// Draw self edge
void LineGraphEdge::drawSelf(Widget w,
const BoxRegion& exposed,
const GraphGC& gc) const
{
assert(from() == to());
// Get region
BoxRegion region = from()->region(gc);
if (from()->selected())
region.origin() += gc.offsetIfSelected;
LineGraphEdgeSelfInfo info(region, gc);
XDrawArc(XtDisplay(w), XtWindow(w), gc.edgeGC, info.arc_pos[X],
info.arc_pos[Y], info.diameter, info.diameter,
info.arc_start * 64, info.arc_extend * 64);
if (annotation() != 0)
{
// Draw annotation
annotation()->draw(w, info.anno_pos, exposed, gc);
}
// Find arrow angle
drawArrowHead(w, exposed, gc, info.arrow_pos, info.arrow_alpha);
}
int main (int argc, char *argv[])
{
/* connect to the X server and make a window */
Display *dpy = XOpenDisplay (getenv ("DISPLAY"));
Window w = XCreateSimpleWindow (dpy, DefaultRootWindow (dpy),
100, 100, 640, 480, 1,
BlackPixel (dpy, DefaultScreen (dpy)),
WhitePixel (dpy, DefaultScreen (dpy)));
/* raise it and wait */
XSelectInput (dpy, w, StructureNotifyMask);
XMapRaised (dpy, w);
for(XEvent e; ( e.type != MapNotify );
XWindowEvent (dpy, w, StructureNotifyMask, &e));
/* create a graphics context for drawing in the window */
GC g = XCreateGC (dpy, w, 0, NULL);
/* draw a circle */
XDrawArc(dpy,w,g,200,100,150,150,0,360*64);
XFlush(dpy);
/*wait for key press*/
XSelectInput (dpy, w, KeyReleaseMask);
for(XEvent e; ( e.type != KeyRelease );
XWindowEvent (dpy, w, KeyReleaseMask, &e));
/*clean up*/
XDestroyWindow( dpy, w );
XCloseDisplay (dpy);
}
static void draw_arc(int x, int y, unsigned int diam)
{
(void)XDrawArc(XtDisplay(draww), pixmap, drawGC,
x - diam / 2, y - diam / 2, /* x,y */
diam, diam, /* width, height */
0, 360 * 64); /* angle1, angle2 */
}
void drawCircle(XPoint centre, int radius, Color fill_color, bool fill, unsigned int line_width, int line_style, int cap_style, int join_style, int function){
if(fill){
line_width = radius;
radius /= 2;
}
XGCValues local_gc_vals;
local_gc_vals.function = function;
local_gc_vals.foreground = fill_color;
local_gc_vals.line_width = line_width;
local_gc_vals.line_style = line_style;
local_gc_vals.cap_style = cap_style;
local_gc_vals.join_style = join_style;
// Create gc for current drawable
GC local_gc = XCreateGC(display, curr_d, GCFunction | GCForeground |
GCLineWidth | GCLineStyle | GCCapStyle |
GCJoinStyle, &local_gc_vals);
XSync(display, false);
// Draw full arc
XDrawArc(display, curr_d, local_gc, centre.x - radius, centre.y - radius, radius * 2, radius * 2, 0, 23040);
XSync(display, false);
// Free temporary GC
XFreeGC(display, local_gc);
}
void
arc(Bitmap *b, Point p0, Point p1, Point p2, int v, Fcode f)
{
unsigned int d;
int x, y, r, start, end, delta;
GC g;
p1.x -= p0.x;
p1.y -= p0.y;
p2.x -= p0.x;
p2.y -= p0.y;
r = (int)sqrt((double)(p1.x*p1.x + p1.y*p1.y));
start = (int)(64*rad2deg(atan2(-p2.y, p2.x)));
end = (int)(64*rad2deg(atan2(-p1.y, p1.x)));
if(start < 0)
start += 64*360;
if(end < 0)
end += 64*360;
delta = end - start;
if(delta < 0)
delta += 64*360;
x = p0.x - r;
y = p0.y - r;
if(b->flag&SHIFT){
x -= b->r.min.x;
y -= b->r.min.y;
}
d = 2*r;
g = _getfillgc(f, b, v);
/*
* delta is positive, so this draws counterclockwise arc
* from start to start+delta
*/
XDrawArc(_dpy, (Drawable)b->id, g, x, y, d, d, start, delta);
}
void GuiCalibratorX11::redraw()
{
#ifdef HAVE_X11_XRANDR
// check that screensize did not change
int nsizes;
XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
if (nsizes != 0 && (display_width != randrsize->width ||
display_height != randrsize->height)) {
set_display_size(randrsize->width, randrsize->height);
}
#endif
// Print the text
int text_height = font_info->ascent + font_info->descent;
int text_width = -1;
for (int i = 0; i != help_lines; i++) {
text_width = std::max(text_width, XTextWidth(font_info,
help_text[i].c_str(), help_text[i].length()));
}
int x = (display_width - text_width) / 2;
int y = (display_height - text_height) / 2 - 60;
XSetForeground(display, gc, pixel[BLACK]);
XSetLineAttributes(display, gc, 2, LineSolid, CapRound, JoinRound);
XDrawRectangle(display, win, gc, x - 10, y - (help_lines*text_height) - 10,
text_width + 20, (help_lines*text_height) + 20);
// Print help lines
y -= 3;
for (int i = help_lines-1; i != -1; i--) {
int w = XTextWidth(font_info, help_text[i].c_str(), help_text[i].length());
XDrawString(display, win, gc, x + (text_width-w)/2, y,
help_text[i].c_str(), help_text[i].length());
y -= text_height;
}
// Draw the points
for (int i = 0; i <= calibrator->get_numclicks(); i++) {
// set color: already clicked or not
if (i < calibrator->get_numclicks())
XSetForeground(display, gc, pixel[WHITE]);
else
XSetForeground(display, gc, pixel[RED]);
XSetLineAttributes(display, gc, 1, LineSolid, CapRound, JoinRound);
XDrawLine(display, win, gc, X[i] - cross_lines, Y[i],
X[i] + cross_lines, Y[i]);
XDrawLine(display, win, gc, X[i], Y[i] - cross_lines,
X[i], Y[i] + cross_lines);
XDrawArc(display, win, gc, X[i] - cross_circle, Y[i] - cross_circle,
(2 * cross_circle), (2 * cross_circle), 0, 360 * 64);
}
// Draw the clock background
XSetForeground(display, gc, pixel[DIMGRAY]);
XSetLineAttributes(display, gc, 0, LineSolid, CapRound, JoinRound);
XFillArc(display, win, gc, (display_width-clock_radius)/2, (display_height - clock_radius)/2,
clock_radius, clock_radius, 0, 360 * 64);
}
void draw_circle (int x, int y, int r, int color)
{
color = (int) ((color / 255.0) * (num_colors - 1));
gcvalues.foreground = colors[color].pixel;
XChangeGC (display, gc, GCForeground, &gcvalues);
XDrawArc (display, root, gc, x-r, y-r, r+r, r+r, 0, 360 * 64);
}
void Catcher::paint(XInfo &xInfo) {
XDrawArc(xInfo.display, xInfo.window, xInfo.gc[0],
(x-10)*xInfo.width/800, (600-y-15)*xInfo.height/600,
30*xInfo.width/800, 30*xInfo.height/600, 0, 360*64);
XFillArc(xInfo.display, xInfo.window, xInfo.gc[2],
(x-10)*xInfo.width/800, (600-y-15)*xInfo.height/600,
30*xInfo.width/800, 30*xInfo.height/600, 0, 360*64);
}
void Crcl(int i, int j, int r)
/* The function crcl draws a circle centered at i,j of radius r */
{
if (isgraphic)
{
XDrawArc(display,win,drawgc,i,j+top_marg_size,2*r,2*r,0,2304);
}
}
/* draw arc with float x,y,width,height,angle1,angle2 */
void FXDrawArc(Display *display, Drawable d, FGC fgc,
float fx, float fy, float fwidth, float fheight,
float fangle1, float fangle2)
{
XDrawArc(display,d,fgc->gc,
MapFX(fgc,fx),MapFY(fgc,fy),
MapFWidth(fgc,fwidth),MapFHeight(fgc,fheight),
MapFAngle(fgc,fangle1),MapFAngle(fgc,fangle2));
}
static void
draw_circle (struct state *st, Drawable w, struct throbber *t)
{
XDrawArc (st->dpy, w, t->gc,
t->x - t->size / 2,
t->y - t->size / 2,
t->size, t->size,
0, 360*64);
}
void DrawAim(Display * dpy, Window w, GC gc, int x, int y, char c, int color) {
XTextItem text = { &c, 1, 5, None };
XSetForeground(dpy, gc, color);
XDrawArc(dpy, w, gc, x - R / 2, y - R / 2, R, R, 0, 23040);
XDrawLine(dpy, w, gc, x - R / 2 - 10, y, x + R / 2 + 10, y);
XDrawLine(dpy, w, gc, x, y - R / 2 - 10, x, y + R / 2 + 10);
XDrawText(dpy, w, gc, x, y - 4, &text, 1);
}
void GraphicWindow::ellipse(double x, double y, double ra, double rb)
{
int disp_x = user_to_disp_x(x);
int disp_y = user_to_disp_y(y);
int disp_rx = abs(user_to_disp_dx(ra));
int disp_ry = abs(user_to_disp_dy(rb));
XSetForeground(display, xgc, BlackPixel(display, screen_num));
XDrawArc(display, win,
xgc, // the drawable
disp_x - disp_rx, // the x coord of upperleft corner of bounding rect
disp_y - disp_ry, // the y coord of upperleft corner of bounding rect
disp_rx * 2, // the major axis length
disp_ry * 2, // the minor axis length
0, // offset from 3 o'clock
360 * 64); // complete circle (360 degrees * 64 clicks per degree)
XDrawArc(display, _ppm, xgc, disp_x - disp_rx,
disp_y - disp_ry, disp_rx * 2, disp_ry * 2, 0, 360 * 64);
}
void neo_draw_pen_draw_circle(NeoDrawPen *pen, NeoDrawWindow *win, int x, int y, int width, int height, bool fill)
{
if(!pen || !win)
return;
if(!fill)
XDrawArc(win->handle->display, win->id,pen->draw, x,y,width, height, 0, 360 * 64);
else
XFillArc(win->handle->display, win->id,pen->draw, x,y,width, height, 0, 360 * 64);
}
