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
}
}
void reset(int m[][6], int line_count){
int i, j;
for (i= 0; i<k; i++){
if (valid_vertex[i][6] == 0.0 || valid_vertex[i][6] == -4.0){
printf("from (%d, %d) to (%d, %d) length: %f and path length: %f\n", (int)valid_vertex[i][0], (int)valid_vertex[i][1], (int)valid_vertex[i][2], (int)valid_vertex[i][3], valid_vertex[i][4], valid_vertex[i][5]);
XDrawLine(display, win, white_gc, valid_vertex[i][0], valid_vertex[i][1], valid_vertex[i][2], valid_vertex[i][3]);
}
}
XFillArc( display, win, white_gc, start_x, start_y, win_width/200, win_width/200, 0, 360*64);
XFillArc( display, win, white_gc, target_x, target_y, win_width/200, win_width/200, 0, 360*64);
for(i=0; i<k; i++){
for (j=0; j<7; j++){
valid_vertex[i][j] = 0.0;
}
}
k=0;
for (i = 0; i <=line_count; i++){
//Draw the triangles
XDrawLine(display, win, green_gc, m[i][0], m[i][1], m[i][2], m[i][3]);
XDrawLine(display, win, green_gc, m[i][2], m[i][3], m[i][4], m[i][5]);
XDrawLine(display, win, green_gc, m[i][4], m[i][5], m[i][0], m[i][1]);
}
}
static void
three_circle_wipe (eraser_state *st)
{
int rad = (st->width > st->height ? st->width : st->height);
int max = 360 * 64;
int th, oth;
int i;
if (st->ratio == 0.0)
st->start = random() % max;
th = max/6 * st->ratio;
oth = max/6 * st->prev_ratio;
for (i = 0; i < 3; i++)
{
int off = i * max / 3;
XFillArc (st->dpy, st->window, st->bg_gc,
(st->width / 2) - rad,
(st->height / 2) - rad,
rad*2, rad*2,
(st->start + off + oth) % max,
th-oth);
XFillArc (st->dpy, st->window, st->bg_gc,
(st->width / 2) - rad,
(st->height / 2) - rad,
rad*2, rad*2,
(st->start + off - oth) % max,
oth-th);
}
}
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 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);
}
void HelloWorld::_drawO(const GC& gc, int x, int y, int w, int h) {
XSetBackground(_display, gc, _whiteColor);
XSetForeground(_display, gc, _blackColor);
XFillArc(_display, _window, gc, x + w/10, y + h/10, (w*4)/5, (h*4)/5, 0,
360*64);
XSetForeground(_display, gc, _whiteColor);
XFillArc(_display, _window, gc, x + w/5, y + h/5, (w*3)/5, (h*3)/5, 0,
360*64);
}
int Disp_DrawFilledCircle(Disp disp, GC gc, int x, int y, int r)
{
if (x + r < 0 || disp->width - 1 < x - r ||
y + r < 0 || disp->height - 1 < y - r) return (0);
if (disp->direct_draw)
XFillArc(disp->display, disp->root_window, gc,
x - r, y - r, r * 2 + 1, r * 2 + 1, 0, 360 * 64);
else
XFillArc(disp->display, disp->pixmap, gc,
x - r, y - r, r * 2 + 1, r * 2 + 1, 0, 360 * 64);
return (0);
}
void draw () {
w->invert_colors ();
XFillArc (w->display, w->win, w->gc,
pos.x - outer, pos.y - outer,
2*outer, 2*outer, 0, 365*64);
w->default_colors ();
XDrawArc (w->display, w->win, w->gc,
pos.x - outer, pos.y - outer,
2*outer, 2*outer, 0, 365*64);
if (selected)
XFillArc (w->display, w->win, w->gc,
pos.x - inner, pos.y - inner,
2*inner, 2*inner, 0, 365*64);
}
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 ;
}
}
static void
TFillArc(register Display * dpy, Drawable d, GC gc, Transform * t, double x, double y, double width, double height, int angle1, int angle2, XRectangle * rect)
{
int xx, xy, xw, xh;
xx = Xx(x, y, t);
xy = Xy(x, y, t);
xw = Xwidth(width, height, t);
xh = Xheight(width, height, t);
if (xw < 0) {
xx += xw;
xw = -xw;
}
if (xh < 0) {
xy += xh;
xh = -xh;
}
XFillArc(dpy, d, gc, xx, xy, xw, xh, angle1, angle2);
if (rect != NULL) {
rect->x = xx;
rect->y = xy;
rect->width = xw;
rect->height = xh;
}
}
void tela_circulo(tela_t* tela, circulo_t c)
{
/* preenche o circulo r na tela com a cor padrao */
XFillArc(tela->display, tela->pixmap, tela->gc,
XU2X(c.centro.x - c.raio), YU2X(c.centro.y - c.raio),
XU2X(2*c.raio), YU2X(2*c.raio), 0, 360*64);
}
static void
paint_fly(ModeInfo * mi, Fly * f)
{
EyeScrInfo *ep = &eye_info[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int x = f->x, y = f->y;
if (MI_IS_ICONIC(mi)) {
/* don't need to unpaint when iconic
* ep->flyGC has stipple set, don't use when iconic
*/
XSetForeground(display, MI_GC(mi), f->pixel);
XFillArc(display, window, MI_GC(mi), x, y,
f->width, f->height, 90 * 64, 360 * 64);
} else {
unpaint_fly(mi, f);
XSetForeground(display, ep->flyGC, f->pixel);
#ifdef XBM_GRELB
if (ep->fly2pix != None) {
XSetStipple(display, ep->flyGC, (f->vy <= 0) ? ep->flypix : ep->fly2pix);
} else
#endif
XSetStipple(display, ep->flyGC, ep->flypix);
XSetTSOrigin(display, ep->flyGC, x, y);
#ifdef FLASH
XSetFillStyle(display, ep->flyGC, FillStippled);
#else
XSetFillStyle(display, ep->flyGC, FillOpaqueStippled);
#endif
XFillRectangle(display, window, ep->flyGC,
x, y, f->width, f->height);
XFlush(display);
}
}
static void
circle_wipe (eraser_state *st)
{
int rad = (st->width > st->height ? st->width : st->height);
int max = 360 * 64;
int th, oth;
if (st->ratio == 0.0)
{
st->flip_p = random() & 1;
st->start = random() % max;
}
th = max * st->ratio;
oth = max * st->prev_ratio;
if (st->flip_p)
{
th = max - th;
oth = max - oth;
}
XFillArc (st->dpy, st->window, st->bg_gc,
(st->width / 2) - rad,
(st->height / 2) - rad,
rad*2, rad*2,
(st->start + oth) % max,
th-oth);
}
static PyObject *
PaxGC_FillArc(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;
XFillArc(self->display, self->drawable, self->gc,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6);
Py_INCREF(Py_None);
return Py_None;
}
/******************************************************************************
*
* DrawVisual:
* Called by ExmSimple whenever it needs to draw or redraw the
* widget visual (either an oval or a rectangle).
*
*****************************************************************************/
static void
DrawVisual (
Widget w
)
{
ExmSimpleWidgetClass wc = (ExmSimpleWidgetClass)XtClass(w);
ExmSimpleWidget sw = (ExmSimpleWidget)w;
/* Draw the oval or the rectangle, space permitting. */
if (sw->simple.visual.width > 0 && sw->simple.visual.height > 0) {
switch (sw->simple.simple_shape) {
case(ExmSHAPE_OVAL):
default:
XFillArc (XtDisplay(w), XtWindow(w),
wc->simple_class.select_gc(w),
sw->simple.visual.x, sw->simple.visual.y,
sw->simple.visual.width, sw->simple.visual.height,
0, 360 * 64);
break;
case(ExmSHAPE_RECTANGLE):
XFillRectangle (XtDisplay(w), XtWindow(w),
wc->simple_class.select_gc(w),
sw->simple.visual.x, sw->simple.visual.y,
sw->simple.visual.width, sw->simple.visual.height);
break;
}
}
}
static void DrawFilledCircle ( Window w, GC gc, int x, int y, int x2, int y2 )
{
FixDataOrdering ( &x, &y, &x2, &y2 );
XFillArc ( display, w, gc, x, y,
x2 - x, y2 - y, 0, 64 * 360 );
}
void EZX_FillCircle(EZXW_p w, int x, int y, int r)
{
int r2 = (int) (r /* / 1.41421356 */ + 0.5); /*(st) */
unsigned int wh = 2 * r2;
XFillArc( theDisplay, w->w, theGC, x - r2, y - r2, wh, wh, 0, 360*64);
}
void
XPSFillArc(Display *display, Drawable drawable, GC context,
int x, int y, int w, int h, int angle1, int angle2)
{
if (output_flag == XOUT)
{
XFillArc(display, drawable, context, x, y, w, h, angle1, angle2);
}
else
{
XGCValues values;
XGetGCValues(display, context, GCForeground | GCLineWidth
| GCArcMode, &values);
PSNewpath();
PSSetPixel(display, values.foreground);
PSSetLineWidth(values.line_width);
if (values.arc_mode == ArcPieSlice)
PSMoveto(x + w / 2, y + h / 2);
PSArc(x + w / 2.0, y + h / 2.0, w / 2.0, angle1 / 64.0,
angle2 / 64.0);
PSClosefill();
}
}
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++;
}
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 dijsktra(int source,int target)
{
int dist[302], prev[302], finished[302], path[302];
int next, x1, y1, x2, y2, min, start, i, d;
int no_of_path = 0;
for(i=0;i<pixel_count;i++)
{
dist[i] = 9999;
prev[i] = -1;
finished[i]=0;
}
start = source;
finished[start]=1;
dist[start] = 0;
while(finished[target] ==0)
{
min = 9999;
next = 0;
for(i=0;i < pixel_count;i++)
{
d = dist[start] + cost[start][i];
if(d < dist[i] && finished[i]==0)
{
dist[i] = d;
prev[i] = start;
}
if(min > dist[i] && finished[i]==0)
{
min = dist[i];
next = i;
}
}
start = next;
finished[start] = 1;
}
start = target;
while(start != -1)
{
path[no_of_path] = start;
no_of_path++;
start = prev[start];
}
printf("Distance : %d\n" , dist[target]);
for(i=0;i<no_of_path-1;i++)
{
x1 = get_x(path[i]);
y1 = get_y(path[i]);
x2 = get_x(path[i+1]);
y2 = get_y(path[i+1]);
XDrawLine(display_ptr, win, gc_white, x1, y1, x2, y2);
XDrawLine(display_ptr, win, gc_blue, x1, y1, x2, y2);
}
for(i=1;i<no_of_path-1;i++)
{
x1 = get_x(path[i]);
y1 = get_y(path[i]);
XFillArc( display_ptr, win, gc_red, x1- win_height/200, y1 - win_height/200, win_height/100, win_height/100, 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);
}
static void
surface_draw_circle(XSurface *surf, zr_short x, zr_short y, zr_ushort w,
zr_ushort h, struct zr_color col)
{
unsigned long c = color_from_byte(&col.r);
XSetForeground(surf->dpy, surf->gc, c);
XFillArc(surf->dpy, surf->drawable, surf->gc, (int)x, (int)y,
(unsigned)w, (unsigned)h, 0, 360 * 64);
}
void
XSpadFillArc(Display *dsply, Drawable drawable, int x, int y,
unsigned int width, unsigned int height,
int angle1, int angle2, int hue, int theshade)
{
XFillArc(dsply, drawable,
SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"),
x, y, width, height, angle1, angle2);
}
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);
}
void xdot ( int *ix, int *iy, int *ilwid, int *iret )
/************************************************************************
* xdot *
* *
* This subroutine draws circles. It is used to draw round dots in an *
* X window. *
* *
* xdot ( ix, iy, ilwid, iret ) *
* *
* Input parameters: *
* *ix int X coordinate *
* *iy int Y coordinate *
* *ilwid int Current line width *
* *
* Output parameters: *
* *iret int Return code *
* G_NORMAL = normal return. *
** *
* Log: *
* J. Whistler/SSAI 7/91 C call for XW device driver *
* M. desJardins/NMC 12/91 xfcirc --> xcirc; center circle *
* S. Jacobs/NMC 7/94 General clean up *
* C. Lin/EAI 7/94 multi-window, multi-pixmap *
* A. Hardy/GSC 11/98 Renamed xcirc to xdot *
* E. Safford/GSC 12/99 update for new xwcmn.h *
* S. Law/GSC 01/00 changed curpxm to an array *
* S. Law/GSC 08/00 removed nmap vs nmap2 references *
***********************************************************************/
{
int ixnew, iynew, ipxm, lp;
Window_str *cwin;
GC gemgc;
/*---------------------------------------------------------------------*/
*iret = G_NORMAL;
cwin = &(gemwindow[current_window]);
/*
* Transform x and y to the upper left corner of bounding
* rectangle.
*/
ixnew = *ix - *ilwid / 2;
iynew = *iy - *ilwid / 2;
/*
* Fill in entire circle. Note that start and end angles of
* arc are in 64ths of degrees.
*/
ipxm = gemwindow[current_window].curpxm[cwin->curr_loop];
gemgc = gemwindow[current_window].gc;
lp = cwin->curr_loop;
XFillArc (gemdisplay, cwin->pxms[lp][ipxm], gemgc,
ixnew, iynew, *ilwid, *ilwid, 0, 360*64);
}
void rysujPionek(pion pionek) {
if(pionek.typ != ' '){
if(pionek.typ == OWCA) {
XSetForeground(mydisplay,mygc,white.pixel);
} else {
XSetForeground(mydisplay,mygc,black.pixel);
}
//zeby zgadzal sie obraz wyswietlany z planszą trzeba zamienic x y.
XFillArc(mydisplay,mywindow,mygc,5+pionek.y*50,5+pionek.x*50,40,40,0,360*64);
}
}
void
XShadeArc(Display *display, Drawable drawable, int x, int y,
unsigned int width, unsigned int height, int angle1, int angle2)
{
if (!INIT) {
fprintf(stderr, "XShade Error: Tried to fill before INIT called\n");
exit(-1);
}
XFillArc(display, drawable, TileGC, x, y, width,
height, angle1, angle2);
}
static void
smoothen(struct state *st, int x, int lastx, int y, int lasty, int size, int last_color, XColor *colors, Display *dpy, Window window, GC bgc, int screen, struct info *info)
{
double xdistance = abs((double)x-(double)lastx);
double ydistance = abs((double)y-(double)lasty);
double distance = sqrt(((xdistance * xdistance) + (ydistance * ydistance)) );
double slope = (((double)y-(double)lasty) / ((double)x-(double)lastx));
printf("Starting smoothen with values: %f, %f, %f, %f\n", xdistance, ydistance, distance, slope);
if (distance > 2.0) {
int newx = (int)((xdistance / distance) * slope);
int newy = (int)((ydistance / distance) * slope);
if (! st->info->trail) {
XSetForeground(st->dpy, st->bgc, BlackPixel(st->dpy, st->screen));
XFillArc(st->dpy, st->window, st->bgc, lastx, lasty, size, size, START_ARC, END_ARC);
}
XSetForeground(st->dpy, st->bgc, st->colors[last_color].pixel);
XFillArc(st->dpy, st->window, st->bgc, newx, newy, size, size, START_ARC, END_ARC);
smoothen(st, newx, x, newy, y, size, last_color, st->colors, st->dpy, st->window, st->bgc, st->screen, st->info);
}
}
/* EXPORT-> HFillArc: Draw filled arc from stAngle thru arcAngle degrees */
void HFillArc(int x0,int y0,int x1,int y1,int stAngle,int arcAngle)
{
unsigned int rw, rh;
CheckCorners(&x0,&y0,&x1,&y1);
/* calculate width and height */
rw = abs(x1 - x0); rh = abs(y1 - y0);
/* the angles are signed integers in 64ths of a degree */
stAngle *=64; arcAngle*=64;
XFillArc(theDisp, theWindow, theGC, x0, y0, rw, rh, stAngle, arcAngle);
}
