/**
* gimp_canvas_draw_segments:
* @canvas: a #GimpCanvas widget
* @style: one of the enumerated #GimpCanvasStyle's.
* @segments: a #GdkSegment array.
* @num_segments: the number of segments in the array.
*
* Draws a set of line segments in the specified style.
**/
void
gimp_canvas_draw_segments (GimpCanvas *canvas,
GimpCanvasStyle style,
GdkSegment *segments,
gint num_segments)
{
if (! gimp_canvas_ensure_style (canvas, style))
return;
while (num_segments >= 32000)
{
gdk_draw_segments (GTK_WIDGET (canvas)->window, canvas->gc[style],
segments, 32000);
num_segments -= 32000;
segments += 32000;
}
gdk_draw_segments (GTK_WIDGET (canvas)->window, canvas->gc[style],
segments, num_segments);
}
static void
gtk_databox_bars_real_draw (GtkDataboxGraph *graph,
GtkDataboxCanvas *canvas)
{
GtkDataboxBars *bars = GTK_DATABOX_BARS (graph);
GdkSegment *data;
guint i = 0;
gfloat *X;
gfloat *Y;
gint len;
gint size = 0;
gint16 zero = 0;
g_return_if_fail (GTK_DATABOX_IS_BARS (bars));
g_return_if_fail (canvas);
g_return_if_fail (canvas->pixmap);
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);
data = bars->priv->data;
zero = (gint16) ((0 - canvas->top_left_visible.y)
* canvas->translation_factor.y);
for (i = 0; i < len; i++, data++, X++, Y++)
{
data->x1 = data->x2 =
(gint16) ((*X - canvas->top_left_visible.x)
* canvas->translation_factor.x);
data->y1 = zero;
data->y2 =
(gint16) ((*Y - canvas->top_left_visible.y)
* canvas->translation_factor.y);
}
/* More than 2^16 bars will cause X IO error on most XServers
(Hint from Paul Barton-Davis) */
for (i = 0; i < len; i += 65536)
{
gdk_draw_segments (canvas->pixmap, graph->gc,
bars->priv->data + i,
MIN (65536, len - i));
}
return;
}
static VALUE
rg_draw_segments(VALUE self, VALUE rbgc, VALUE rbsegments)
{
GdkDrawable *drawable = _SELF(self);
GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
long n;
GdkSegment *segments = RVAL2GDKSEGMENTS(rbsegments, &n);
gdk_draw_segments(drawable, gc, segments, n);
g_free(segments);
return self;
}
static void draw(Scope *scope)
{
guint segcnt, i;
GdkPoint pt[SCOPE_WIDTH+1];
GdkSegment seg[100], *segp;
GtkWidget *widget;
GtkAllocation allocation;
GtkStyle *style;
widget = GTK_WIDGET(scope);
g_return_if_fail(gtk_widget_is_drawable(widget));
g_return_if_fail(scope->pixmap);
gtk_widget_get_allocation(widget, &allocation);
style = gtk_widget_get_style(widget);
/* calculate grid segments */
for (segp = seg, segcnt = i = 0; i < SCOPE_WIDTH; i += SCOPE_WIDTH/8) {
segp->x1 = segp->x2 = i;
segp->y1 = SCOPE_HEIGHT/2-5;
segp->y2 = SCOPE_HEIGHT/2+5;
segp++;
segcnt++;
}
segp->y1 = segp->y2 = SCOPE_HEIGHT/2;
segp->x1 = 0;
segp->x2 = SCOPE_WIDTH-1;
segp++;
segcnt++;
/* copy data points */
for (i = 0; i < SCOPE_WIDTH; i++) {
pt[i].x = i;
pt[i].y = ((32767-(int)scope->y[i])*SCOPE_HEIGHT) >> 16;
}
/* clear window */
gdk_draw_rectangle(scope->pixmap, style->base_gc[gtk_widget_get_state(widget)],
TRUE, 0, 0,
allocation.width,
allocation.height);
/* draw grid */
gdk_draw_segments(scope->pixmap, scope->grid_gc, seg, segcnt);
/* draw trace */
gdk_draw_lines(scope->pixmap, scope->trace_gc, pt, SCOPE_WIDTH);
/* draw to screen */
gdk_draw_drawable(gtk_widget_get_window(widget), style->base_gc[gtk_widget_get_state(widget)], scope->pixmap,
0, 0, 0, 0, allocation.width, allocation.height);
}
/* ****************************************************************************
* draw lines showing the route
*/
void
draw_route (void)
{
GdkSegment *route_seg;
gint destpos_x, destpos_y, curpos_x, curpos_y;
gint i, j;
gint t = 0;
gchar t_routept[5];
GtkTreeIter iter_route;
gdouble t_lon, t_lat;
if (route.items < 1)
return;
i = (route.items + 5);
route_seg = g_new0 (GdkSegment, i);
if (local_config.use_database)
{
/* poi mode */
g_snprintf (t_routept, sizeof (t_routept), "%d",
(route.pointer));
gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (route_list_tree),
&iter_route, t_routept);
calcxy (&curpos_x, &curpos_y,
coords.current_lon, coords.current_lat, current.zoom);
(route_seg)->x1 = curpos_x;
(route_seg)->y1 = curpos_y;
do
{
gtk_tree_model_get
(GTK_TREE_MODEL (route_list_tree), &iter_route,
ROUTE_LON, &t_lon, ROUTE_LAT, &t_lat, -1);
if (t != 0)
{
(route_seg + t)->x1 = (route_seg + t - 1)->x2;
(route_seg + t)->y1 = (route_seg + t - 1)->y2;
}
calcxy (&destpos_x, &destpos_y, t_lon, t_lat,
current.zoom);
(route_seg + t)->x2 = destpos_x;
(route_seg + t)->y2 = destpos_y;
t++;
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL
(route_list_tree), &iter_route));
}
else
{
/* waypoints mode */
/* start beginning with actual route.pointer */
for (j = route.pointer; j < route.items; j++)
{
/* start drawing with current_pos */
if (j == route.pointer)
{
calcxy (&curpos_x, &curpos_y,
coords.current_lon,
coords.current_lat, current.zoom);
(route_seg + t)->x1 = curpos_x;
(route_seg + t)->y1 = curpos_y;
}
else
{
(route_seg + t)->x1 = (route_seg + t - 1)->x2;
(route_seg + t)->y1 = (route_seg + t - 1)->y2;
}
calcxy (&destpos_x, &destpos_y, (routelist +
j)->lon, (routelist + j)->lat, current.zoom);
(route_seg + t)->x2 = destpos_x;
(route_seg + t)->y2 = destpos_y;
t++;
}
}
gdk_gc_set_foreground (kontext_map, &colors.route);
gdk_gc_set_background (kontext_map, &colors.white);
gdk_gc_set_line_attributes (kontext_map, 4, GDK_LINE_ON_OFF_DASH, 0, 0);
gdk_gc_set_dashes (kontext_map, 0, (gpointer) linestyles[local_config.style_route], 4);
gdk_gc_set_function (kontext_map, GDK_COPY);
gdk_draw_segments (drawable, kontext_map, (GdkSegment *) route_seg, t);
g_free (route_seg);
}
