/* Draw the marker that indicates where the black point is */ static void drawBlackMarker(GdkDrawable *drawable, GtkWidget *greyramp) { GreyrampProperties *properties = greyrampGetProperties(greyramp); DotterContext *dc = properties->dwc->dotterCtx; GdkRectangle markerRect; getBlackMarkerRect(properties, &markerRect); /* Draw a triangle. Line color is the 'selected' color if dragging */ GdkColor *fillColor = getGdkColor(DOTCOLOR_MARKER_FILL, dc->defaultColors, FALSE, properties->dwc->usePrintColors); GdkColor *lineColor = getGdkColor(DOTCOLOR_MARKER_LINE, dc->defaultColors, properties->draggingBlack, properties->dwc->usePrintColors); int numPoints = 3; GdkPoint points[numPoints]; points[0].x = markerRect.x + (markerRect.width / 2); points[0].y = markerRect.y; points[1].x = markerRect.x; points[1].y = markerRect.y + markerRect.height; points[2].x = markerRect.x + markerRect.width; points[2].y = markerRect.y + markerRect.height; /* Draw fill in white and line in black (or green if dragging) */ GdkGC *gc = gdk_gc_new(drawable); gdk_gc_set_foreground(gc, fillColor); gdk_draw_polygon(drawable, gc, TRUE, points, numPoints); gdk_gc_set_foreground(gc, lineColor); gdk_draw_polygon(drawable, gc, FALSE, points, numPoints); g_object_unref(gc); }
static void draw_polygon (DiaRenderer *object, Point *points, int num_points, Color *fill, Color *stroke) { DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object); GdkGC *gc = renderer->gc; GdkColor color; GdkPoint *gdk_points; int i,x,y; gdk_points = g_new(GdkPoint, num_points); for (i=0;i<num_points;i++) { dia_transform_coords(renderer->transform, points[i].x, points[i].y, &x, &y); gdk_points[i].x = x; gdk_points[i].y = y; } if (fill && fill->alpha > 0.0) { renderer_color_convert(renderer, fill, &color); gdk_gc_set_foreground(gc, &color); gdk_draw_polygon(renderer->pixmap, gc, TRUE, gdk_points, num_points); } if (stroke && stroke->alpha > 0.0) { renderer_color_convert(renderer, stroke, &color); gdk_gc_set_foreground(gc, &color); gdk_draw_polygon(renderer->pixmap, gc, FALSE, gdk_points, num_points); } g_free(gdk_points); }
static void draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count) { if (gr->mode == draw_mode_begin || gr->mode == draw_mode_end) gdk_draw_polygon(gr->drawable, gc->gc, TRUE, (GdkPoint *)p, count); if (gr->mode == draw_mode_end || gr->mode == draw_mode_cursor) gdk_draw_polygon(gr->widget->window, gc->gc, TRUE, (GdkPoint *)p, count); }
static void gwy_hmarker_box_draw_marker(GwyMarkerBox *mbox, gint i) { GtkWidget *widget; GtkStateType state, gcstate; gboolean ghost, selected; GdkPoint points[3]; gint height, width; gdouble pos; gint iw, ipos; widget = GTK_WIDGET(mbox); state = GTK_WIDGET_STATE(widget); width = widget->allocation.width; height = widget->allocation.height; selected = (i == mbox->selected); ghost = selected && mbox->ghost; selected = selected && mbox->highlight; pos = g_array_index(mbox->markers, gdouble, i); if (ghost) gcstate = GTK_STATE_INSENSITIVE; else if (state == GTK_STATE_INSENSITIVE) gcstate = state; else gcstate = GTK_STATE_NORMAL; ipos = GWY_ROUND(pos*(width - 1)); iw = MAX(GWY_ROUND(height/GWY_SQRT3 - 1), 1); points[0].x = ipos - iw; points[1].x = ipos + iw; points[2].x = ipos; if (mbox->flipped) { points[0].y = 0; points[1].y = 0; points[2].y = height-1; } else { points[0].y = height-1; points[1].y = height-1; points[2].y = 0; } if (selected && !ghost) gdk_draw_polygon(widget->window, widget->style->bg_gc[GTK_STATE_SELECTED], TRUE, points, G_N_ELEMENTS(points)); else gdk_draw_polygon(widget->window, widget->style->text_gc[gcstate], TRUE, points, G_N_ELEMENTS(points)); gdk_draw_polygon(widget->window, widget->style->fg_gc[gcstate], FALSE, points, G_N_ELEMENTS(points)); }
static void cdpoly(cdCtxCanvas *ctxcanvas, int mode, cdPoint* poly, int n) { int i; if (mode != CD_BEZIER && mode != CD_PATH) { for (i = 0; i < n; i++) { if (ctxcanvas->canvas->use_matrix) cdMatrixTransformPoint(ctxcanvas->xmatrix, poly[i].x, poly[i].y, &(poly[i].x), &(poly[i].y)); } } switch( mode ) { case CD_FILL: if (ctxcanvas->canvas->new_region) { GdkRegion* rgn = gdk_region_polygon((GdkPoint*)poly, n, ctxcanvas->canvas->fill_mode == CD_EVENODD ? GDK_EVEN_ODD_RULE : GDK_WINDING_RULE); sCombineRegion(ctxcanvas, rgn); } else gdk_draw_polygon(ctxcanvas->wnd, ctxcanvas->gc, TRUE, (GdkPoint*)poly, n); break; case CD_CLOSED_LINES: cdgdkCheckSolidStyle(ctxcanvas, 1); gdk_draw_polygon(ctxcanvas->wnd, ctxcanvas->gc, FALSE, (GdkPoint*)poly, n); cdgdkCheckSolidStyle(ctxcanvas, 0); break; case CD_OPEN_LINES: cdgdkCheckSolidStyle(ctxcanvas, 1); gdk_draw_lines(ctxcanvas->wnd, ctxcanvas->gc, (GdkPoint*)poly, n); cdgdkCheckSolidStyle(ctxcanvas, 0); break; case CD_CLIP: ctxcanvas->clip_rgn = gdk_region_polygon((GdkPoint*)poly, n, ctxcanvas->canvas->fill_mode == CD_EVENODD ? GDK_EVEN_ODD_RULE : GDK_WINDING_RULE); if (ctxcanvas->canvas->clip_mode == CD_CLIPPOLYGON) cdclip(ctxcanvas, CD_CLIPPOLYGON); break; case CD_BEZIER: cdSimPolyBezier(ctxcanvas->canvas, poly, n); break; case CD_PATH: cdSimPolyPath(ctxcanvas->canvas, poly, n); break; } }
/*----------------------------------------------------------------------------*/ void viewPaint3DBlock(GtkWidget* widget, char block, GdkRectangle* rect) { //g_message("block = %d", block); GdkPoint pts[6]; int ind = rect->width / 8; pts[0].x = rect->x; pts[0].y = rect->y + rect->height; pts[1].x = rect->x; pts[1].y = rect->y; pts[2].x = rect->x + rect->width; pts[2].y = rect->y; pts[3].x = rect->x + rect->width - ind; pts[3].y = rect->y + ind; pts[4].x = rect->x + ind; pts[4].y = rect->y + ind; pts[5].x = rect->x + ind; pts[5].y = rect->y + rect->height - ind; gdk_draw_polygon(pixmap, gc[(block-1)%13][0], TRUE, pts, 6); gdk_draw_rectangle(pixmap, gc[(block-1)%13][1], TRUE, rect->x+ind, rect->y+ind, rect->width-ind-ind, rect->height-ind-ind); pts[1].x = rect->x + rect->width; pts[1].y = rect->y + rect->height; pts[4].x = rect->x + rect->width - ind; pts[4].y = rect->y + rect->height - ind; //g_message("block2 = %d", block); gdk_draw_polygon(pixmap, gc[(block-1)%13][2], TRUE, pts, 6); }
/*----------------------------------------------------------------------------*/ void viewPaintPyrimidBlock(GtkWidget* widget, char block, GdkRectangle* rect) { GdkPoint pts[4]; pts[0].x = rect->x; pts[0].y = rect->y; pts[1].x = rect->x; pts[1].y = rect->y+rect->height; pts[2].x = rect->x + rect->width; pts[2].y = rect->y; pts[3].x = rect->x + rect->width; pts[3].y = rect->y + rect->height; gdk_draw_polygon(pixmap, gc[(block-1)%13][1], TRUE, pts, 4); int mid = rect->width / 2; pts[1].x = rect->x + mid; pts[1].y = rect->y + mid; pts[2].x = rect->x + rect->width-1; gdk_draw_polygon(pixmap, gc[(block-1)%13][0], TRUE, pts, 3); pts[0].x = rect->x+1; pts[0].y = rect->y + rect->height; pts[1].x = rect->x + rect->width; pts[1].y = rect->y + rect->height; pts[2].x = rect->x + rect->width - mid; pts[2].y = rect->y + rect->height - mid; gdk_draw_polygon(pixmap, gc[(block-1)%13][2], TRUE, pts, 3); }
void _HYPlatformGraphicPane::_FillPolygon (Ptr rgn) { if (rgn) { _HYGDK_Polygon * thePoly = (_HYGDK_Polygon *)rgn; gdk_draw_polygon (thePane, theContext, true, thePoly->thePoints, thePoly->pointCount); } }
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 _HYPlatformGraphicPane::_DrawPolygon (Ptr rgn, long width) { if (rgn) { gdk_gc_set_line_attributes (theContext, width, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER); _HYGDK_Polygon * thePoly = (_HYGDK_Polygon *)rgn; gdk_draw_polygon (thePane, theContext, false, thePoly->thePoints, thePoly->pointCount); } }
/* This function is based on a portion of EnGradient's draw_box */ void draw_default_triangle(GtkStyle * style, GdkWindow * window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle * area, GtkWidget * widget, const gchar * detail, gint x, gint y, gint width, gint height) { GdkPoint points1[3]; /* dark */ GdkPoint points2[3]; /* light */ points1[0].x = x+2; points1[0].y = y+2; points1[1].x = x+10; points1[1].y = y+2; points1[2].x = x+2; points1[2].y = y+10; points2[0].x = x+3; points2[0].y = y+3; points2[1].x = x+10; points2[1].y = y+3; points2[2].x = x+3; points2[2].y = y+10; if (area) { gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area); gdk_gc_set_clip_rectangle(style->light_gc[state_type], area); gdk_gc_set_clip_rectangle(style->dark_gc[state_type], area); } /* Paint a triangle here instead of in "buttondefault" which is drawn _behind_ the current button */ if (GTK_WIDGET_HAS_DEFAULT (widget)) { gdk_draw_polygon(window, style->dark_gc[state_type], FALSE, points1, 3); gdk_draw_polygon(window, style->light_gc[state_type], FALSE, points2, 3); gdk_draw_polygon(window, style->bg_gc[GTK_STATE_SELECTED], TRUE, points2, 3); } if (area) { gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL); gdk_gc_set_clip_rectangle(style->light_gc[state_type], NULL); gdk_gc_set_clip_rectangle(style->dark_gc[state_type], NULL); } }
static void draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count) { #if 0 if (gr->mode == draw_mode_begin || gr->mode == draw_mode_end) gdk_draw_polygon(gr->drawable, gc->gc, TRUE, (GdkPoint *)p, count); if (gr->mode == draw_mode_end || gr->mode == draw_mode_cursor) gdk_draw_polygon(gr->widget->window, gc->gc, TRUE, (GdkPoint *)p, count); #endif int i; glColor4f( gc->fr, gc->fg, gc->fb, gc->fa); glBegin( GL_POLYGON ); for (i = 0 ; i < count ; i++) { glVertex2i(p[i].x, p[i].y); } glVertex2i(p[0].x, p[0].y); glEnd(); }
/* * Aperture macro primitive 4 (outline) * - Start point is not included in number of points. * - Outline is 1 pixel. */ static void gerbv_gdk_draw_prim4(GdkPixmap *pixmap, GdkGC *gc, double *p, double scale, gint x, gint y) { const int exposure_idx = 0; const int nuf_points_idx = 1; const int first_x_idx = 2; const int first_y_idx = 3; const int rotext_idx = 4; GdkGC *local_gc = gdk_gc_new(pixmap); int nuf_points, point; double rotation; GdkPoint *points; GdkColor color; /* Include start point */ nuf_points = (int)p[nuf_points_idx] + 1; points = (GdkPoint *)g_malloc(sizeof(GdkPoint) * nuf_points); if (!points) { g_free(points); return; } rotation = p[(nuf_points - 1) * 2 + rotext_idx]; for (point = 0; point < nuf_points; point++) { points[point].x = (int)round(scale * p[point * 2 + first_x_idx]); points[point].y = -(int)round(scale * p[point * 2 + first_y_idx]); if (rotation != 0.0) points[point] = rotate_point(points[point], rotation); points[point].x += x; points[point].y += y; } gdk_gc_copy(local_gc, gc); /* Exposure */ if (p[exposure_idx] == 0.0) { color.pixel = 0; gdk_gc_set_foreground(local_gc, &color); } gdk_gc_set_line_attributes(local_gc, 1, /* outline always 1 pixels */ GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER); gdk_draw_polygon(pixmap, local_gc, 1, points, nuf_points); g_free(points); gdk_gc_unref(local_gc); return; } /* gerbv_gdk_draw_prim4 */
void iupdrvDrawPolygon(IdrawCanvas* dc, int* points, int count, 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_polygon(dc->pixmap, dc->pixmap_gc, style==IUP_DRAW_FILL, (GdkPoint*)points, count); }
static void gerbv_gdk_draw_prim21(GdkPixmap *pixmap, GdkGC *gc, double *p, double scale, gint x, gint y) { const int exposure_idx = 0; const int width_idx = 1; const int height_idx = 2; const int exp_x_idx = 3; const int exp_y_idx = 4; const int rotation_idx = 5; const int nuf_points = 4; GdkPoint points[nuf_points]; GdkColor color; GdkGC *local_gc = gdk_gc_new(pixmap); int half_width, half_height; int i; half_width = (int)round(p[width_idx] * scale / 2.0); half_height =(int)round(p[height_idx] * scale / 2.0); points[0].x = half_width; points[0].y = half_height; points[1].x = half_width; points[1].y = -half_height; points[2].x = -half_width; points[2].y = -half_height; points[3].x = -half_width; points[3].y = half_height; for (i = 0; i < nuf_points; i++) { points[i] = rotate_point(points[i], p[rotation_idx]); points[i].x += (x + (int)(p[exp_x_idx] * scale)); points[i].y += (y - (int)(p[exp_y_idx] * scale)); } gdk_gc_copy(local_gc, gc); /* Exposure */ if (p[exposure_idx] == 0.0) { color.pixel = 0; gdk_gc_set_foreground(local_gc, &color); } gdk_draw_polygon(pixmap, local_gc, 1, points, nuf_points); gdk_gc_unref(local_gc); return; } /* gerbv_gdk_draw_prim21 */
/* * Doesn't handle explicit x,y yet */ static void gerbv_gdk_draw_prim22(GdkPixmap *pixmap, GdkGC *gc, double *p, double scale, gint x, gint y) { const int exposure_idx = 0; const int width_idx = 1; const int height_idx = 2; const int x_lower_left_idx = 3; const int y_lower_left_idx = 4; const int rotation_idx = 5; const int nuf_points = 4; GdkPoint points[nuf_points]; GdkGC *local_gc = gdk_gc_new(pixmap); GdkColor color; int i; points[0].x = (int)round(p[x_lower_left_idx] * scale); points[0].y = (int)round(p[y_lower_left_idx] * scale); points[1].x = (int)round((p[x_lower_left_idx] + p[width_idx]) * scale); points[1].y = (int)round(p[y_lower_left_idx] * scale); points[2].x = (int)round((p[x_lower_left_idx] + p[width_idx]) * scale); points[2].y = (int)round((p[y_lower_left_idx] + p[height_idx]) * scale); points[3].x = (int)round(p[x_lower_left_idx] * scale); points[3].y = (int)round((p[y_lower_left_idx] + p[height_idx]) * scale); for (i = 0; i < nuf_points; i++) { points[i] = rotate_point(points[i], p[rotation_idx]); points[i].x = x + points[i].x; points[i].y = y - points[i].y; } gdk_gc_copy(local_gc, gc); /* Exposure */ if (p[exposure_idx] == 0.0) { color.pixel = 0; gdk_gc_set_foreground(local_gc, &color); } gdk_draw_polygon(pixmap, local_gc, 1, points, nuf_points); gdk_gc_unref(local_gc); return; } /* gerbv_gdk_draw_prim22 */
/** * gimp_canvas_draw_polygon: * @canvas: a #GimpCanvas widget * @style: one of the enumerated #GimpCanvasStyle's. * @filled: if %TRUE, fill the polygon. * @points: a #GdkPoint array. * @num_points: the number of points in the array. * * Draws a polygon connecting the specified points, in the specified * style. **/ void gimp_canvas_draw_polygon (GimpCanvas *canvas, GimpCanvasStyle style, gboolean filled, GdkPoint *points, gint num_points) { if (! gimp_canvas_ensure_style (canvas, style)) return; gdk_draw_polygon (GTK_WIDGET (canvas)->window, canvas->gc[style], filled, points, num_points); }
int GCpolygon(Gwidget_t * widget, int gpn, Gpoint_t * gpp, Ggattr_t * ap) { Grect_t gr; int n, i; if (gpn == 0) return 0; gr.o = gpp[0], gr.c = gpp[0]; for (i = 1; i < gpn; i++) { gr.o.x = min(gr.o.x, gpp[i].x); gr.o.y = min(gr.o.y, gpp[i].y); gr.c.x = min(gr.c.x, gpp[i].x); gr.c.y = min(gr.c.y, gpp[i].y); } /* if(!ISVISIBLE(gr)) return 1; */ if (gpn + 1 > Gppn) { n = (((gpn + 1) + PPINCR - 1) / PPINCR) * PPINCR; Gppp = Marraygrow(Gppp, (long) n * PPSIZE); Gppn = n; } for (i = 0; i < gpn; i++) Gppp[i] = pdrawtopix(widget, gpp[i]); setgattr(widget, ap); if (WCU->gattr.fill) { if (Gppp[gpn - 1].x != Gppp[0].x || Gppp[gpn - 1].y != Gppp[0].y) Gppp[gpn] = Gppp[0], gpn++; gdk_draw_polygon(widget->w, GC, TRUE, Gppp, gpn); } else gdk_draw_polygon(widget->w, GC, FALSE, Gppp, gpn); return 0; }
/* * Aperture macro primitive 5 (polygon) */ static void gerbv_gdk_draw_prim5(GdkPixmap *pixmap, GdkGC *gc, double *p, double scale, gint x, gint y) { const int exposure_idx = 0; const int nuf_vertices_idx = 1; const int center_x_idx = 2; const int center_y_idx = 3; const int diameter_idx = 4; const int rotation_idx = 5; int nuf_vertices, i; double vertex, tick, rotation, radius; GdkPoint *points; GdkGC *local_gc = gdk_gc_new(pixmap); GdkColor color; nuf_vertices = (int)p[nuf_vertices_idx]; points = (GdkPoint *)g_malloc(sizeof(GdkPoint) * nuf_vertices); if (!points) { g_free(points); return; } gdk_gc_copy(local_gc, gc); /* Exposure */ if (p[exposure_idx] == 0.0) { color.pixel = 0; gdk_gc_set_foreground(local_gc, &color); } tick = 2 * M_PI / (double)nuf_vertices; rotation = -p[rotation_idx] * M_PI / 180.0; radius = p[diameter_idx] / 2.0; for (i = 0; i < nuf_vertices; i++) { vertex = tick * (double)i + rotation; points[i].x = (int)round(scale * radius * cos(vertex)) + x + p[center_x_idx]; points[i].y = (int)round(scale * radius * sin(vertex)) + y + p[center_y_idx]; } gdk_draw_polygon(pixmap, local_gc, 1, points, nuf_vertices); gdk_gc_unref(local_gc); g_free(points); return; } /* gerbv_gdk_draw_prim5 */
static VALUE rg_draw_polygon(VALUE self, VALUE rbgc, VALUE rbfilled, VALUE rbpoints) { GdkDrawable *drawable = _SELF(self); GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc)); gboolean filled = RVAL2CBOOL(rbfilled); long n; GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n); gdk_draw_polygon(drawable, gc, filled, points, n); g_free(points); return self; }
static void gdk_trace_line(HosPainterGdk *self, struct hos_point* points, const gint n_point, gint lvl, gboolean closed) { HosPainter *painter = HOS_PAINTER(self); /* * The next assertion would be nice, but would require * either breaking into the painter's structure (grokking out * the adjustment) or creating a selector for the painter's * n_lvl; does not seem worth it to be able to do this * assertion. */ /* assert(lvl < painter->n_lvl); */ /* set color */ { GdkColor *color = contour_get_color(painter->contour, lvl); /* FIXME adjustable linewidth, etc. */ gdk_gc_set_rgb_fg_color(self->gc, color); gdk_gc_set_line_attributes(self->gc, painter->contour->line_width, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER); } { GdkPoint gdk_points[n_point]; guint i; /* * Points must be copied from a glib-style array to a * C-style array for use in gdk_draw_lines. */ for (i = 0; i < n_point; ++i) { gdk_points[i].x = points[i].x; gdk_points[i].y = points[i].y; } if (closed) gdk_draw_polygon(self->drawable, self->gc, FALSE, gdk_points, n_point); else gdk_draw_lines(self->drawable, self->gc, gdk_points, n_point); } }
void iupdrvDrawPolygon(IdrawCanvas* dc, int* points, int count, long color, int style, int line_width) { GdkColor c; iupgdkColorSet(&c, color); gdk_gc_set_rgb_fg_color(dc->pixmap_gc, &c); if (style != IUP_DRAW_FILL) { iDrawSetLineWidth(dc, line_width); iDrawSetLineStyle(dc, style); } if (style == IUP_DRAW_FILL) gdk_draw_polygon(dc->pixmap, dc->pixmap_gc, TRUE, (GdkPoint*)points, count); else gdk_draw_lines(dc->pixmap, dc->pixmap_gc, (GdkPoint*)points, count); }
void iupDrawPolygon(IdrawCanvas* dc, int* points, int count, 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) { GdkGCValues gcval; if (style==IUP_DRAW_STROKE_DASH) gcval.line_style = GDK_LINE_ON_OFF_DASH; else gcval.line_style = GDK_LINE_SOLID; gdk_gc_set_values(dc->pixmap_gc, &gcval, GDK_GC_LINE_STYLE); } gdk_draw_polygon(dc->pixmap, dc->pixmap_gc, style==IUP_DRAW_FILL, (GdkPoint*)points, count); }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics_fillPolygon (JNIEnv *env, jobject obj, jintArray xpoints, jintArray ypoints, jint npoints) { struct graphics *g; GdkPoint *points; g = (struct graphics *) NSA_GET_PTR (env, obj); points = translate_points (env, xpoints, ypoints, npoints, g->x_offset, g->y_offset); gdk_threads_enter (); gdk_draw_polygon (g->drawable, g->gc, TRUE, points, npoints); gdk_flush (); gdk_threads_leave (); g_free (points); }
/* affiche flfigpetite dans le pixmap */ void tandrawfloat (GdkPixmap *pixmap, gboolean isoutline){ tanflfig *flfig=&flfigpetite; double dx,dy; GdkPoint pnts[PIECENBR*(PNTNBRMAX+1)]; int flpntnbr; int flpiecenbr; int i,j; tanfpnt *figfpnts; double zoom; tanpolytype polytype; if (isoutline){ zoom = widgetgrande->allocation.width*figgrande.zoom; dx=dxout; dy=dyout; } else{ zoom = widgetpetite->allocation.width*figpetite.zoom; dx=dxpetite; dy=dypetite; } flpiecenbr = flfig->flpiecenbr; for (i = 0; i<flpiecenbr; i++){ figfpnts = flfig->flpieces[i].flpnts; flpntnbr = flfig->flpieces[i].flpntnbr; polytype = flfig->flpieces[i].polytype; for (j = 0; j<flpntnbr; j++){ pnts[j].x = (gint16)(zoom*(figfpnts[j].posx-dx)+ARON); pnts[j].y = (gint16)(zoom*(figfpnts[j].posy-dy)+ARON); } if (isoutline){ pnts[flpntnbr] = pnts[0]; gdk_draw_lines(pixmap, tabgc[GCPIECEHLP], pnts, flpntnbr+1); } else { gdk_draw_polygon(pixmap, (polytype==TAN_POLYON) ? ( figpetite.reussi ? tabgc[GCPETITECHK] : tabgc[GCPETITEBG] ) : tabgc[GCPETITEFG], TRUE, pnts, flpntnbr); } } }
void ghid_fill_polygon (hidGC gc, int n_coords, int *x, int *y) { static GdkPoint *points = 0; static int npoints = 0; int i; USE_GC (gc); if (npoints < n_coords) { npoints = n_coords + 1; points = (GdkPoint *)realloc (points, npoints * sizeof (GdkPoint)); } for (i = 0; i < n_coords; i++) { points[i].x = Vx (x[i]); points[i].y = Vy (y[i]); } gdk_draw_polygon (gport->drawable, gport->u_gc, 1, points, n_coords); }
static void fill_polygon (DiaRenderer *object, Point *points, int num_points, Color *line_color) { DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object); GdkGC *gc = renderer->gc; GdkColor color; GdkPoint *gdk_points; int i,x,y; gdk_points = g_new(GdkPoint, num_points); for (i=0;i<num_points;i++) { dia_transform_coords(renderer->transform, points[i].x, points[i].y, &x, &y); gdk_points[i].x = x; gdk_points[i].y = y; } renderer_color_convert(renderer, line_color, &color); gdk_gc_set_foreground(gc, &color); gdk_draw_polygon(renderer->pixmap, gc, TRUE, gdk_points, num_points); g_free(gdk_points); }
static void gtk_plot_gdk_draw_polygon (GtkPlotPC *pc, gint filled, GtkPlotPoint *points, gint numpoints) { GdkPoint *p = NULL; gint i; if(!GTK_PLOT_GDK(pc)->gc) return; if(!GTK_PLOT_GDK(pc)->drawable) return; p = (GdkPoint *)g_malloc(numpoints * sizeof(GdkPoint)); for(i = 0; i < numpoints; i++){ p[i].x = roundint(points[i].x); p[i].y = roundint(points[i].y); } gdk_draw_polygon(GTK_PLOT_GDK(pc)->drawable, GTK_PLOT_GDK(pc)->gc, filled, p, numpoints); g_free(p); }
static void gtk_databox_marker_real_draw (GtkDataboxGraph *graph, GtkDataboxCanvas *canvas) { GtkDataboxMarker *marker = GTK_DATABOX_MARKER (graph); GdkPoint points [3]; gfloat *X; gfloat *Y; gint len; gint16 x; gint16 y; GtkDataboxCoord coord; gint size; gint i; g_return_if_fail (GTK_DATABOX_IS_MARKER (marker)); g_return_if_fail (canvas); g_return_if_fail (canvas->pixmap); g_return_if_fail (canvas->context); if (!graph->gc) gtk_databox_graph_create_gc (graph, canvas); len = gtk_databox_xyc_graph_get_length (GTK_DATABOX_XYC_GRAPH (graph)); X = gtk_databox_xyc_graph_get_X (GTK_DATABOX_XYC_GRAPH (graph)); Y = gtk_databox_xyc_graph_get_Y (GTK_DATABOX_XYC_GRAPH (graph)); size = gtk_databox_graph_get_size (graph); for (i = 0; i < len; ++i) { x = (gint16) ((X[i] - canvas->top_left_visible.x) * canvas->translation_factor.x); y = (gint16) ((Y[i] - canvas->top_left_visible.y) * canvas->translation_factor.y); switch (marker->priv->type) { case GTK_DATABOX_MARKER_TRIANGLE: switch (marker->priv->marker_info[i].position) { case GTK_DATABOX_MARKER_C: coord.x = x; coord.y = y; y = y - size / 2; points[0].x = x; points[0].y = y; points[1].x = x - size / 2; points[1].y = y + size; points[2].x = x + size / 2; points[2].y = y + size; break; case GTK_DATABOX_MARKER_N: coord.x = x; coord.y = y - 2 - size / 2; y = y - 2; points[0].x = x; points[0].y = y; points[1].x = x - size / 2; points[1].y = y - size; points[2].x = x + size / 2; points[2].y = y - size; break; case GTK_DATABOX_MARKER_E: coord.x = x + 2 + size / 2; coord.y = y; x = x + 2; points[0].x = x; points[0].y = y; points[1].x = x + size; points[1].y = y + size / 2; points[2].x = x + size; points[2].y = y - size / 2; break; case GTK_DATABOX_MARKER_S: coord.x = x; coord.y = y + 2 + size / 2; y = y + 2; points[0].x = x; points[0].y = y; points[1].x = x - size / 2; points[1].y = y + size; points[2].x = x + size / 2; points[2].y = y + size; break; case GTK_DATABOX_MARKER_W: coord.x = x - 2 - size / 2; coord.y = y; x = x - 2; points[0].x = x; points[0].y = y; points[1].x = x - size; points[1].y = y + size / 2; points[2].x = x - size; points[2].y = y - size / 2; break; } gdk_draw_polygon (canvas->pixmap, graph->gc, TRUE, points, 3); break; /* End of GTK_DATABOX_MARKER_TRIANGLE */ case GTK_DATABOX_MARKER_SOLID_LINE: case GTK_DATABOX_MARKER_DASHED_LINE: switch (marker->priv->marker_info[i].position) { case GTK_DATABOX_MARKER_C: coord.x = x; coord.y = y; points[0].x = x; points[0].y = 0; points[1].x = x; points[1].y = canvas->height; break; case GTK_DATABOX_MARKER_N: coord.x = x; points[0].x = x; points[0].y = 0; points[1].x = x; points[1].y = canvas->height; break; case GTK_DATABOX_MARKER_E: coord.y = y; points[0].x = 0; points[0].y = y; points[1].x = canvas->width; points[1].y = y; break; case GTK_DATABOX_MARKER_S: coord.x = x; points[0].x = x; points[0].y = 0; points[1].x = x; points[1].y = canvas->height; break; case GTK_DATABOX_MARKER_W: coord.y = y; points[0].x = 0; points[0].y = y; points[1].x = canvas->width; points[1].y = y; break; } gdk_draw_line (canvas->pixmap, graph->gc, points[0].x, points[0].y, points[1].x, points[1].y); break; /* End of GTK_DATABOX_MARKER_LINE */ case GTK_DATABOX_MARKER_NONE: default: coord.x = x; coord.y = y; break; } if (marker->priv->marker_info[i].text) { if (!marker->priv->marker_info[i].label) { marker->priv->marker_info[i].label = pango_layout_new (canvas->context); pango_layout_set_text (marker->priv->marker_info[i].label, marker->priv->marker_info[i].text, -1); } if (marker->priv->type == GTK_DATABOX_MARKER_SOLID_LINE || marker->priv->type == GTK_DATABOX_MARKER_DASHED_LINE) { gint width; gint height; pango_layout_get_pixel_size (marker->priv->marker_info[i].label, &width, &height); width = (width + 1) / 2 + 2; height = (height + 1) / 2 + 2; size = 0; switch (marker->priv->marker_info[i].position) { case GTK_DATABOX_MARKER_C: break; case GTK_DATABOX_MARKER_N: coord.y = height; break; case GTK_DATABOX_MARKER_E: coord.x = canvas->width - width; break; case GTK_DATABOX_MARKER_S: coord.y = canvas->height - height; break; case GTK_DATABOX_MARKER_W: coord.x = width; break; } } gtk_databox_label_write_at (canvas->pixmap, marker->priv->marker_info[i].label, marker->priv->label_gc, coord, marker->priv->marker_info[i].label_position, (size + 1) / 2 + 2, marker->priv->marker_info[i].boxed); } } return; }
GdkRectangle tandrawpiece (GtkWidget *widget,GdkPixmap *pixmap, tanpiecepos *piecepos, double zoom, tanremplis remplis){ GdkPoint pnt[PNTNBRMAX+1]; int i,pntnbr,ix,iy,ixmax=-20000,ixmin=20000,iymax=-20000,iymin=20000; GdkRectangle update_rect; GdkGC *gc; double gris,rx,ry; pntnbr=tanplacepiece(piecepos,pnt,zoom); for(i=0; i<pntnbr; i++){ ix=pnt[i].x; iy=pnt[i].y; if (ix<ixmin) ixmin=ix; if (ix>ixmax) ixmax=ix; if (iy<iymin) iymin=iy; if (iy>iymax) iymax=iy; } update_rect.x=ixmin; update_rect.y=iymin; update_rect.width=ixmax-ixmin+1; update_rect.height=iymax-iymin+1; switch (remplis){ case TAN_PETITEHLP: gc=tabgc[GCPETITEHLP]; break; case TAN_PIECENOR: gc=tabgc[GCPIECENOR]; gdk_gc_set_ts_origin (gc,pnt[pntnbr].x,pnt[pntnbr].y); break; case TAN_PIECEHI: gc=tabgc[GCPIECEHI]; gdk_gc_set_ts_origin (gc,pnt[pntnbr].x,pnt[pntnbr].y); break; default: gc=widget->style->white_gc; break; } gdk_draw_polygon (pixmap, gc, TRUE, pnt, pntnbr); if ( remplis==TAN_PIECENOR || remplis==TAN_PIECEHI ){ pnt[pntnbr]=pnt[0]; /* ecrase le point du centre */ for (i=0; i<pntnbr; i++){ rx=pnt[i+1].x-pnt[i].x; ry=pnt[i].y-pnt[i+1].y; gris=(ry+rx)*0.35355339/sqrt(rx*rx+ry*ry); if (piecepos->flipped) gris=-gris; gris=gris+0.5; gdk_draw_line (pixmap, tabgc[(int)(gris*(GRISNBR))], pnt[i].x,pnt[i].y,pnt[i+1].x,pnt[i+1].y); } } return(update_rect); }