void do_draw_option_shadow(GdkWindow * window, GdkRectangle * area, GdkGC * tl_gc, GdkGC * br_gc, gint x, gint y, gint width, gint height) { if (area) { gdk_gc_set_clip_rectangle(tl_gc, area); gdk_gc_set_clip_rectangle(br_gc, area); } gdk_draw_arc(window, tl_gc, FALSE, x, y, width, height, 45 * 64, 225 * 64); gdk_draw_arc(window, br_gc, FALSE, x, y, width, height, 225 * 64, 180 * 64); if (area) { gdk_gc_set_clip_rectangle(tl_gc, NULL); gdk_gc_set_clip_rectangle(br_gc, NULL); } }
int GCarc(Gwidget_t * widget, Gpoint_t gc, Gsize_t gs, double ang1, double ang2, Ggattr_t * ap) { PIXpoint_t pc; PIXsize_t ps; Grect_t gr; gr.o.x = gc.x - gs.x, gr.o.y = gc.y - gs.y; gr.c.x = gc.x + gs.x, gr.c.y = gc.y + gs.y; /* if(!ISVISIBLE(gr)) return 1; */ pc = pdrawtopix(widget, gc), ps = sdrawtopix(widget, gs); setgattr(widget, ap); if (WCU->gattr.fill) { gdk_draw_arc(widget->w->window, GC, TRUE, pc.x - ps.x, pc.y - ps.y, ps.x * 2, ps.y * 2, (int) (ang1 * 64), (ang2 * 64)); } else { gdk_draw_arc(widget->w->window, GC, FALSE, pc.x - ps.x, pc.y - ps.y, ps.x * 2, ps.y * 2, (int) (ang1 * 64), (ang2 * 64)); } return 0; }
GdkBitmap * arc_clip_mask(gint width, gint height) { GdkBitmap *result; GdkGC *gc; GdkColor color; result = (GdkBitmap *)gdk_pixmap_new(NULL, width, height, 1); gc = gdk_gc_new(result); color.pixel = 0; gdk_gc_set_foreground(gc, &color); gdk_draw_rectangle(result, gc, TRUE, 0, 0, width, height); gdk_draw_rectangle(result, gc, FALSE, 0, 0, width, height); color.pixel = 1; gdk_gc_set_foreground(gc, &color); gdk_draw_arc(result, gc, TRUE, 0, 0, width, height, 0, 360*64); gdk_draw_arc(result, gc, FALSE, 0, 0, width, height, 0, 360*64); gdk_gc_destroy(gc); return result; }
static void draw_circle(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int r) { if (gr->mode == draw_mode_begin || gr->mode == draw_mode_end) gdk_draw_arc(gr->drawable, gc->gc, FALSE, p->x-r/2, p->y-r/2, r, r, 0, 64*360); if (gr->mode == draw_mode_end || gr->mode == draw_mode_cursor) gdk_draw_arc(gr->widget->window, gc->gc, FALSE, p->x-r/2, p->y-r/2, r, r, 0, 64*360); }
void UI_buildui(IBusHandwriteEngine * engine) { GdkPixmap * pxmp; GdkGC * gc; GdkColor black, white; GdkColormap* colormap = gdk_colormap_get_system(); gdk_color_black(colormap, &black); gdk_color_white(colormap, &white); g_object_unref(colormap); int R = 5; if (!engine->drawpanel) //建立绘图窗口, 建立空点 { engine->drawpanel = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_move((GtkWindow*) engine->drawpanel, 500, 550); gtk_widget_add_events(GTK_WIDGET(engine->drawpanel), GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK); g_signal_connect_after(G_OBJECT(engine->drawpanel),"motion_notify_event",G_CALLBACK(on_mouse_move),engine); g_signal_connect(G_OBJECT(engine->drawpanel),"expose-event",G_CALLBACK(paint_ui),engine); g_signal_connect(G_OBJECT(engine->drawpanel),"button-release-event",G_CALLBACK(on_button),engine); g_signal_connect(G_OBJECT(engine->drawpanel),"button-press-event",G_CALLBACK(on_button),engine); gtk_window_resize(GTK_WINDOW(engine->drawpanel), 200, 250); gtk_widget_show(engine->drawpanel); pxmp = gdk_pixmap_new(NULL, 200, 250, 1); gc = gdk_gc_new(GDK_DRAWABLE(pxmp)); gdk_gc_set_foreground(gc, &black); gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, 200, 250); gdk_gc_set_foreground(gc, &white); gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, R*2, R*2, 0, 360 * 64); gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 0, R*2, R*2, 0, 360 * 64); gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 250 - R*2, R*2, R*2, 0, 360 * 64); gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 250 - R*2, R*2, R*2, 0, 360 * 64); gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, R, 200, 250 - R*2); gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, R, 0, 200 - R*2, 250); gdk_window_shape_combine_mask(engine->drawpanel->window, pxmp, 0, 0); g_object_unref(gc); g_object_unref(pxmp); gtk_window_set_opacity(GTK_WINDOW(engine->drawpanel), 0.62); // engine->GdkPoints = NULL; } // gtk_widget_show_all(engine->drawpanel); }
static gint user_install_corner_expose(GtkWidget *widget, GdkEventExpose *eevent, gpointer data) { switch ((GtkCornerType)data) { case GTK_CORNER_TOP_LEFT: gdk_draw_arc(widget->window, white_gc, TRUE, 0, 0, widget->allocation.width * 2, widget->allocation.height * 2, 90 * 64, 180 * 64); break; case GTK_CORNER_BOTTOM_LEFT: gdk_draw_arc(widget->window, white_gc, TRUE, 0, -widget->allocation.height, widget->allocation.width * 2, widget->allocation.height * 2, 180 * 64, 270 * 64); break; case GTK_CORNER_TOP_RIGHT: gdk_draw_arc(widget->window, white_gc, TRUE, -widget->allocation.width, 0, widget->allocation.width * 2, widget->allocation.height * 2, 0 * 64, 90 * 64); break; case GTK_CORNER_BOTTOM_RIGHT: gdk_draw_arc(widget->window, white_gc, TRUE, -widget->allocation.width, -widget->allocation.height, widget->allocation.width * 2, widget->allocation.height * 2, 270 * 64, 360 * 64); break; default: return FALSE; } return TRUE; }
gboolean Update(gpointer data) { int c,x,y,cx,cy; GtkWidget *dc=GetWidget("drawingarea1"); GdkGC *gc=dc->style->fg_gc[GTK_WIDGET_STATE(dc)]; GdkGCValues gcsave; gdk_gc_get_values(gc,&gcsave); cx=dc->allocation.width/2; cy=dc->allocation.height/2; { // clear the display GdkColor c={0,0xffff,0xffff,0xffff}; gdk_gc_set_rgb_fg_color(gc,&c); gdk_draw_rectangle(dc->window,gc,TRUE,0,0,dc->allocation.width,dc->allocation.height); } { // Draw the listener GdkColor c={0,0x8000,0x8000,0x8000}; gdk_gc_set_rgb_fg_color(gc,&c); gdk_draw_arc(dc->window,gc,TRUE,cx-4,cy-4,8,8,0,360*64); } for (c=0;c<chanc;c++) { // If the channel's playing then update it's position if (BASS_ChannelIsActive(chans[c].channel)==BASS_ACTIVE_PLAYING) { // Check if channel has reached the max distance if (chans[c].pos.z>=MAXDIST || chans[c].pos.z<=-MAXDIST) chans[c].vel.z=-chans[c].vel.z; if (chans[c].pos.x>=MAXDIST || chans[c].pos.x<=-MAXDIST) chans[c].vel.x=-chans[c].vel.x; // Update channel position chans[c].pos.z+=chans[c].vel.z*TIMERPERIOD/1000; chans[c].pos.x+=chans[c].vel.x*TIMERPERIOD/1000; BASS_ChannelSet3DPosition(chans[c].channel,&chans[c].pos,NULL,&chans[c].vel); } { // Draw the channel position indicator static GdkColor cols[2]={{0,0xffff,0xc000,0xc000},{0,0xffff,0,0}}; gdk_gc_set_rgb_fg_color(gc,&cols[chan==c]); x=cx+(int)((cx-10)*chans[c].pos.x/MAXDIST); y=cy-(int)((cy-10)*chans[c].pos.z/MAXDIST); gdk_draw_arc(dc->window,gc,TRUE,x-4,y-4,8,8,0,360*64); } } // Apply the 3D changes BASS_Apply3D(); gdk_gc_set_values(gc,&gcsave,GDK_GC_FOREGROUND); return TRUE; }
static void set_foreground(GdkColor *color, int status) { int i, num; GdkPoint *p; int num_app_shells = get_num_shells(); GdkGC *app_gc = get_toplevel(); num = numpoints[status]; p = polyptr[status]; if (num) { gdk_gc_set_rgb_fg_color(app_gc, color); for (i = 0; i < num_app_shells; i++) { tape_status_widget *ts = &app_shells[i].tape_status; if (ts) { gdk_draw_polygon(ts->control_pixmap, app_gc, TRUE, p, num); gtk_widget_queue_draw(ts->control); } } } else { gdk_gc_set_rgb_fg_color(app_gc, &drive_led_on_red_pixel); for (i = 0; i < num_app_shells; i++) { tape_status_widget *ts = &app_shells[i].tape_status; if (ts) { gdk_draw_arc(ts->control_pixmap, app_gc, TRUE, 3, 1, CTRL_WIDTH - 6, CTRL_HEIGHT - 2, 0, 360 * 64); gtk_widget_queue_draw(ts->control); } } } }
void drawIR_expose_event(void) { int i; int size; gint width, height; gdk_window_get_geometry(drawIR->window, NULL, NULL, &width, &height, NULL); for (i=0; i < CWIID_IR_SRC_COUNT; i++) { if (ir_data.src[i].valid) { if (ir_data.src[i].size == -1) { size = 3; } else { size = ir_data.src[i].size+1; } gdk_draw_arc(drawIR->window, drawIR->style->fg_gc[GTK_WIDGET_STATE(drawIR)], TRUE, ir_data.src[i].pos[CWIID_X] * width / CWIID_IR_X_MAX, height - ir_data.src[i].pos[CWIID_Y] * height / CWIID_IR_Y_MAX, size, size, 0, 64 * 360); } } }
void bez_spot_draw (BezSpot *s,GdkWindow *window, GdkGC *gc, double radius) { Point *p=s->point; gc_set_rgb_fg (gc, 0x000000); gdk_draw_arc(window,gc,FALSE,p->x-radius,p->y-radius,p->x+radius,p->y+radius,64,360*64); }
void SDC::DrawCircle(int x, int y, int r) { #ifdef __WXGTK__ gdk_draw_arc(m_gdkbmp, m_gc, FALSE, x - r, y - r, 2 * r, 2 * r, 0, 360 * 64); #else Select(); Ellipse(m_gc, x - r, y - r, x + r, y + r); #endif }
static void DrawCircle( GdkDrawable *drawable, GdkGC* gc, bool filled, const GdkPoint& center, int radius, const GdkColor& color ) { gdk_gc_set_rgb_fg_color( gc, &color ); gdk_draw_arc( drawable, gc, filled, center.x-radius, center.y-radius, 2*radius, 2*radius, 0, 64*360 ); }
static void Dw_bullet_draw (DwWidget *widget, DwRectangle *area, GdkEventExpose *event) { gint32 x0, y0, x, y; GdkGC *gc; DwStyleColor *bg_color; GdkWindow *window; gint32 l; int i; gboolean selected = FALSE; for (i = 0; i < DW_HIGHLIGHT_NUM_LAYERS && !selected; i++) selected = DW_BULLET(widget)->selected[i]; l = MIN (widget->allocation.width, widget->allocation.ascent); x = x0 = p_Dw_widget_x_world_to_viewport (widget, widget->allocation.x); y0 = p_Dw_widget_y_world_to_viewport (widget, widget->allocation.y); y = y0 + widget->allocation.ascent - widget->style->font->x_height; gc = selected ? widget->style->color->inverse_gc : widget->style->color->gc; window = DW_WIDGET_WINDOW (widget); if (selected) { bg_color = p_Dw_widget_get_bg_color (widget); gdk_draw_rectangle (window, bg_color->inverse_gc, TRUE, x0, y0, widget->allocation.width, DW_WIDGET_HEIGHT(widget)); } switch (widget->style->list_style_type) { case DW_STYLE_LIST_STYLE_TYPE_DISC: gdk_draw_arc (window, gc, TRUE, x, y, l, l, 0, 360 * 64); break; case DW_STYLE_LIST_STYLE_TYPE_CIRCLE: gdk_draw_arc (window, gc, FALSE, x, y, l, l, 0, 360 * 64); break; case DW_STYLE_LIST_STYLE_TYPE_SQUARE: gdk_draw_rectangle (window, gc, FALSE, x, y, l, l); break; default: break; } }
void drawTest(Ihandle *ih, int posx) { GtkWidget* widget = (GtkWidget*)IupGetAttribute(ih, "WID"); gdk_draw_arc (widget->window, widget->style->fg_gc[GTK_WIDGET_STATE (widget)], TRUE, 0, 0, widget->allocation.width, widget->allocation.height, 0, 64 * 360); }
static VALUE rg_draw_arc(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h, VALUE a1, VALUE a2) { gdk_draw_arc(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), RVAL2CBOOL(filled), NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h), NUM2INT(a1), NUM2INT(a2)); return self; }
void DrawColorFilledEllipse (GdkGC * gc, double x, double y, double sizeX, double sizeY) { x = (x + shift_X) * zoom; y = (y + shift_Y[0]) * zoom; sizeX *= zoom; sizeY *= zoom; if (sizeX < 1000000 && sizeY < 1000000 && x < 1000000 && y < 1000000 && x > -1000000 && y > -1000000) gdk_draw_arc (pixmap, gc, TRUE, x - sizeX, y - sizeY, 2 * sizeX, 2 * sizeY, 0, 360 * 64); }
// Méthodes de remplissage (ellipse, rectangle) void Fenetre::remplitEllipse(int x, int y, int large, int haut) { // ellipse pleine if (existe) { gdk_gc_set_rgb_fg_color(fenetre->style->fg_gc[GTK_STATE_NORMAL],&stylo); gdk_draw_arc(dessin, fenetre->style->fg_gc[GTK_WIDGET_STATE (fenetre)], TRUE, x,y,large,haut,0,360*64); gtk_widget_queue_draw(fenetre); // provoquer l'affichage traiteEvenements(); } }
/*! Display a circle. \param center : Circle center position. \param radius : Circle radius. \param color : Circle color. \param fill : When set to true fill the circle. \param thickness : Thickness of the circle. This parameter is only useful when \e fill is set to false. */ void vpDisplayGTK::displayCircle ( const vpImagePoint ¢er, unsigned int radius, const vpColor &color, bool fill, unsigned int thickness ) { if (displayHasBeenInitialized) { if ( thickness == 1 ) thickness = 0; if (color.id < vpColor::id_unknown) gdk_gc_set_foreground(gc, col[color.id]); else { gdkcolor.red = 256 * color.R; gdkcolor.green = 256 * color.G; gdkcolor.blue = 256 * color.B; gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE); gdk_gc_set_foreground(gc, &gdkcolor); } gdk_gc_set_line_attributes(gc, (gint)thickness, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_BEVEL) ; if (fill == false) gdk_draw_arc(background, gc, FALSE, vpMath::round( center.get_u()-radius ), vpMath::round( center.get_v()-radius ), (gint)(2*radius), (gint)(2*radius), 23040, 23040) ; /* 23040 = 360*64 */ else gdk_draw_arc(background, gc, TRUE, vpMath::round( center.get_u()-radius ), vpMath::round( center.get_v()-radius ), (gint)(2*radius), (gint)(2*radius), 23040, 23040) ; /* 23040 = 360*64 */ } else { vpERROR_TRACE("GTK not initialized " ) ; throw(vpDisplayException(vpDisplayException::notInitializedError, "GTK not initialized")) ; } }
static void make_round_corners(panel *p) { GdkBitmap *b; GdkGC* gc; GdkColor black = { 0, 0, 0, 0}; GdkColor white = { 1, 0xffff, 0xffff, 0xffff}; int w, h, r, br; ENTER; w = p->aw; h = p->ah; r = p->round_corners_radius; if (2*r > MIN(w, h)) { r = MIN(w, h) / 2; DBG("chaning radius to %d\n", r); } if (r < 4) { DBG("radius too small\n"); RET(); } b = gdk_pixmap_new(NULL, w, h, 1); gc = gdk_gc_new(GDK_DRAWABLE(b)); gdk_gc_set_foreground(gc, &black); gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, 0, 0, w, h); gdk_gc_set_foreground(gc, &white); gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, r, 0, w-2*r, h); gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, 0, r, r, h-2*r); gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, w-r, r, r, h-2*r); br = 2 * r; gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, 0, 0, br, br, 0*64, 360*64); gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, 0, h-br-1, br, br, 0*64, 360*64); gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, w-br, 0, br, br, 0*64, 360*64); gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, w-br, h-br-1, br, br, 0*64, 360*64); gtk_widget_shape_combine_mask(p->topgwin, b, 0, 0); g_object_unref(gc); g_object_unref(b); RET(); }
void iupdrvDrawArc(IdrawCanvas* dc, int x1, int y1, int x2, int y2, double a1, double a2, unsigned char r, unsigned char g, unsigned char b, int style) { GdkColor color; iupgdkColorSet(&color, r, g, b); gdk_gc_set_rgb_fg_color(dc->pixmap_gc, &color); if (style!=IUP_DRAW_FILL) iDrawSetLineStyle(dc, style); gdk_draw_arc(dc->pixmap, dc->pixmap_gc, style == IUP_DRAW_FILL, x1, y1, x2 - x1 + 1, y2 - y1 + 1, iupRound(a1 * 64), iupRound((a2 - a1) * 64)); }
static void draw_light_marker (gint xpos, gint ypos) { GdkColor color; color.red = 0x0; color.green = 0x0; color.blue = 0x0; gdk_gc_set_rgb_bg_color (gc, &color); color.red = 0x0; color.green = 0x4000; color.blue = 0xFFFF; gdk_gc_set_rgb_fg_color (gc, &color); gdk_gc_set_function (gc, GDK_COPY); if (mapvals.lightsource.type == POINT_LIGHT) { lightx = xpos; lighty = ypos; /* Save background */ /* =============== */ backbuf.x = lightx - 7; backbuf.y = lighty - 7; backbuf.w = 14; backbuf.h = 14; /* X doesn't like images that's outside a window, make sure */ /* we get the backbuffer image from within the boundaries */ /* ======================================================== */ if (backbuf.x < 0) backbuf.x = 0; else if ((backbuf.x + backbuf.w) > PREVIEW_WIDTH) backbuf.w = (PREVIEW_WIDTH - backbuf.x); if (backbuf.y < 0) backbuf.y = 0; else if ((backbuf.y + backbuf.h) > PREVIEW_HEIGHT) backbuf.h = (PREVIEW_WIDTH - backbuf.y); backbuf.image = gdk_drawable_get_image (previewarea->window, backbuf.x, backbuf.y, backbuf.w, backbuf.h); gdk_draw_arc (previewarea->window, gc, TRUE, lightx - 7, lighty - 7, 14, 14, 0, 360 * 64); } }
void Fenetre::traceArc(int x, int y, int large, int haut, int angle1, int angle2, int e) { if (existe) { gdk_gc_set_rgb_fg_color(fenetre->style->fg_gc[GTK_STATE_NORMAL],&stylo); // courbe choixEpaisseurTrace(e); // couleur et épaisseur du tracé gdk_draw_arc(dessin, fenetre->style->fg_gc[GTK_WIDGET_STATE (fenetre)], FALSE, x,y,large,haut,angle1*64,angle2*64); gtk_widget_queue_draw(fenetre); // provoquer l'affichage traiteEvenements(); } }
void draw_arc(GdkDrawable *da, GdkGC *gc, int fill, int x, int y, int r, double a1, double a2) { /* * This adjustment handles two distinct cases: * - if a1 == a2, we make sure we draw a full circle * - the end angle a2 must always be greater than the start angle a1 */ if (a2 <= a1) a2 += 360; gdk_draw_arc(da, gc, fill, x-r, y-r, 2*r, 2*r, a1*64, (a2-a1)*64); }
/* * Draws a circle _centered_ at x,y with diameter dia */ static void gerbv_gdk_draw_circle(GdkPixmap *pixmap, GdkGC *gc, gint filled, gint x, gint y, gint dia) { static const gint full_circle = 23360; gint real_x = x - dia / 2; gint real_y = y - dia / 2; gdk_draw_arc(pixmap, gc, filled, real_x, real_y, dia, dia, 0, full_circle); return; } /* gerbv_gdk_draw_circle */
void draw_place_name(int i, GdkPixmap *pixmap, GdkColor *draw_color) { int pix_x1, pix_y1; pix_x1 = map_x_to_pix(place_list->places[i].x/map->config.resolution); pix_y1 = map_y_to_pix(place_list->places[i].y/map->config.resolution); gdk_gc_set_foreground (drawing_gc, draw_color); gdk_draw_arc(pixmap, drawing_gc, 1, pix_x1-5, pix_y1-5, 10, 10, 0, 360*64); gdk_gc_set_foreground (drawing_gc, &carmen_black); gdk_draw_arc(pixmap, drawing_gc, 0, pix_x1-5, pix_y1-5, 10, 10, 0, 360*64); gdk_gc_set_foreground (drawing_gc, &carmen_black); gdk_draw_string(pixmap, place_font, drawing_gc, pix_x1, pix_y1-5, place_list->places[i].name); }
void drawStick_expose_event(GtkWidget *drawStick, GdkEventExpose *event, struct stick *stick) { gint width, height; (void)event; gdk_window_get_geometry(drawStick->window, NULL, NULL, &width, &height, NULL); gdk_draw_arc(drawStick->window, drawStick->style->fg_gc[GTK_WIDGET_STATE(drawStick)], FALSE, 0, 0, width-1, height-1, 0, 64*360); if (stick->valid) { gdk_draw_arc(drawStick->window, drawStick->style->fg_gc[GTK_WIDGET_STATE(drawStick)], TRUE, (double)stick->x/stick->max*width - 2, (1 - (double)stick->y/stick->max)*height - 2, 3, 3, 0, 64*360); } }
static void cdsector(cdCtxCanvas *ctxcanvas, int xc, int yc, int w, int h, double a1, double a2) { if (ctxcanvas->canvas->use_matrix || ctxcanvas->canvas->new_region) { cdSimSector(ctxcanvas, xc, yc, w, h, a1, a2); } else { /* "filled parameter = TRUE" produces a 'pie slice' */ gdk_draw_arc(ctxcanvas->wnd, ctxcanvas->gc, TRUE, xc-w/2, yc-h/2, w, h, cdRound(a1*64), cdRound((a2 - a1)*64)); } }
static void gtk_plot_gdk_draw_ellipse (GtkPlotPC *pc, gint filled, gdouble x, gdouble y, gdouble width, gdouble height) { if(!GTK_PLOT_GDK(pc)->gc) return; if(!GTK_PLOT_GDK(pc)->drawable) return; gdk_draw_arc (GTK_PLOT_GDK(pc)->drawable, GTK_PLOT_GDK(pc)->gc, filled, roundint(x), roundint(y), roundint(width), roundint(height), 0, 25000); }
void rcm_draw_little_circle (GdkWindow *window, GdkGC *color, gfloat hue, gfloat satur) { gint x,y; x = GRAY_CENTER + GRAY_RADIUS * satur * cos(hue); y = GRAY_CENTER - GRAY_RADIUS * satur * sin(hue); gdk_draw_arc (window, color, 0, x-LITTLE_RADIUS, y-LITTLE_RADIUS, 2*LITTLE_RADIUS, 2*LITTLE_RADIUS, 0, 360*64); }
static void cdarc(cdCtxCanvas *ctxcanvas, int xc, int yc, int w, int h, double a1, double a2) { if (ctxcanvas->canvas->use_matrix) { cdSimArc(ctxcanvas, xc, yc, w, h, a1, a2); return; } /* angles in 1/64ths of degrees counterclockwise, similar to CD */ cdgdkCheckSolidStyle(ctxcanvas, 1); gdk_draw_arc(ctxcanvas->wnd, ctxcanvas->gc, FALSE, xc-w/2, yc-h/2, w, h, cdRound(a1*64), cdRound((a2 - a1)*64)); cdgdkCheckSolidStyle(ctxcanvas, 0); }