static void iDrawSetLineStyle(IdrawCanvas* dc, int style)
{
GdkGCValues gcval;
if (style == IUP_DRAW_STROKE || style == IUP_DRAW_FILL)
gcval.line_style = GDK_LINE_SOLID;
else
{
if (style == IUP_DRAW_STROKE_DASH)
{
gint8 dashes[2] = { 9, 3 };
gdk_gc_set_dashes(dc->pixmap_gc, 0, dashes, 2);
}
else if (style == IUP_DRAW_STROKE_DOT)
{
gint8 dashes[2] = { 1, 2 };
gdk_gc_set_dashes(dc->pixmap_gc, 0, dashes, 2);
}
else if (style == IUP_DRAW_STROKE_DASH_DOT)
{
gint8 dashes[4] = { 7, 3, 1, 3 };
gdk_gc_set_dashes(dc->pixmap_gc, 0, dashes, 4);
}
else if (style == IUP_DRAW_STROKE_DASH_DOT_DOT)
{
gint8 dashes[6] = { 7, 3, 1, 3, 1, 3 };
gdk_gc_set_dashes(dc->pixmap_gc, 0, dashes, 6);
}
gcval.line_style = GDK_LINE_ON_OFF_DASH;
}
gdk_gc_set_values(dc->pixmap_gc, &gcval, GDK_GC_LINE_STYLE);
}
static int cdlinestyle(cdCtxCanvas *ctxcanvas, int style)
{
switch (style)
{
case CD_CONTINUOUS:
ctxcanvas->gcval.line_style = GDK_LINE_SOLID;
break;
case CD_DASHED:
case CD_DOTTED:
case CD_DASH_DOT:
case CD_DASH_DOT_DOT:
{
static struct {
int size;
signed char list[6];
} dashes[4] = {
{ 2, { 6, 2 } },
{ 2, { 2, 2 } },
{ 4, { 6, 2, 2, 2 } },
{ 6, { 6, 2, 2, 2, 2, 2 } }
};
if (ctxcanvas->canvas->back_opacity == CD_OPAQUE)
ctxcanvas->gcval.line_style = GDK_LINE_DOUBLE_DASH;
else
ctxcanvas->gcval.line_style = GDK_LINE_ON_OFF_DASH;
gdk_gc_set_dashes(ctxcanvas->gc, 0, dashes[style-CD_DASHED].list, dashes[style-CD_DASHED].size);
break;
}
case CD_CUSTOM:
{
int i;
signed char* dash_style = (signed char*)malloc(ctxcanvas->canvas->line_dashes_count);
for (i = 0; i < ctxcanvas->canvas->line_dashes_count; i++)
dash_style[i] = (char)ctxcanvas->canvas->line_dashes[i];
if (ctxcanvas->canvas->back_opacity == CD_OPAQUE)
ctxcanvas->gcval.line_style = GDK_LINE_DOUBLE_DASH;
else
ctxcanvas->gcval.line_style = GDK_LINE_ON_OFF_DASH;
gdk_gc_set_dashes(ctxcanvas->gc, 0, dash_style, ctxcanvas->canvas->line_dashes_count);
free(dash_style);
break;
}
}
gdk_gc_set_values(ctxcanvas->gc, &ctxcanvas->gcval, GDK_GC_LINE_STYLE);
return style;
}
/** Set the dashes for this renderer.
* offset determines where in the pattern the dashes will start.
* It is used by the grid in particular to make the grid dashes line up.
*/
void
dia_gdk_renderer_set_dashes(DiaGdkRenderer *renderer, int offset)
{
gint8 dash_list[6];
int hole_width;
int pattern_length;
switch(renderer->saved_line_style) {
case LINESTYLE_SOLID:
break;
case LINESTYLE_DASHED:
dash_list[0] = renderer->dash_length;
dash_list[1] = renderer->dash_length;
pattern_length = renderer->dash_length*2;
gdk_gc_set_dashes(renderer->gc, offset, dash_list, 2);
break;
case LINESTYLE_DASH_DOT:
hole_width = (renderer->dash_length - renderer->dot_length) / 2;
if (hole_width==0)
hole_width = 1;
dash_list[0] = renderer->dash_length;
dash_list[1] = hole_width;
dash_list[2] = renderer->dot_length;
dash_list[3] = hole_width;
pattern_length = renderer->dash_length+renderer->dot_length+2*hole_width;
gdk_gc_set_dashes(renderer->gc, offset, dash_list, 4);
break;
case LINESTYLE_DASH_DOT_DOT:
hole_width = (renderer->dash_length - 2*renderer->dot_length) / 3;
if (hole_width==0)
hole_width = 1;
dash_list[0] = renderer->dash_length;
dash_list[1] = hole_width;
dash_list[2] = renderer->dot_length;
dash_list[3] = hole_width;
dash_list[4] = renderer->dot_length;
dash_list[5] = hole_width;
pattern_length = renderer->dash_length+2*renderer->dot_length+3*hole_width;
gdk_gc_set_dashes(renderer->gc, offset, dash_list, 6);
break;
case LINESTYLE_DOTTED:
dash_list[0] = renderer->dot_length;
dash_list[1] = renderer->dot_length;
pattern_length = renderer->dot_length;
gdk_gc_set_dashes(renderer->gc, offset, dash_list, 2);
break;
}
}
static void
gdl_dock_master_xor_rect (GdlDockMaster *master)
{
gint8 dash_list [2];
GdkWindow *window;
GdkRectangle *rect;
if (!master->_priv || !master->_priv->drag_request)
return;
master->_priv->rect_drawn = ~master->_priv->rect_drawn;
if (master->_priv->rect_owner) {
gdl_dock_xor_rect (master->_priv->rect_owner,
&master->_priv->drag_request->rect);
return;
}
rect = &master->_priv->drag_request->rect;
window = gdk_get_default_root_window ();
if (!master->_priv->root_xor_gc) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
master->_priv->root_xor_gc = gdk_gc_new_with_values (
window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
};
gdk_gc_set_line_attributes (master->_priv->root_xor_gc, 1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list[0] = 1;
dash_list[1] = 1;
gdk_gc_set_dashes (master->_priv->root_xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (master->_priv->root_xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
CAMLprim value ml_gdk_gc_set_dashes(value gc, value offset, value dashes)
{
CAMLparam3(gc, offset, dashes);
CAMLlocal1(tmp);
int l = 0;
int i;
gint8 *cdashes;
for(tmp = dashes; tmp != Val_int(0); tmp = Field(tmp,1)){
l++;
}
if( l == 0 ){ ml_raise_gdk("line dashes must have at least one element"); }
cdashes = stat_alloc(sizeof (gint8) * l);
for(i=0, tmp= dashes; i<l; i++, tmp = Field(tmp,1)){
int d;
d = Int_val(Field(tmp,0));
if( d<0 || d>255 ){
stat_free (cdashes);
ml_raise_gdk("line dashes must be [0..255]");
}
cdashes[i] = d;
}
gdk_gc_set_dashes( GdkGC_val(gc), Int_val(offset), cdashes, l);
/* stat_free (cdashes); ? */
CAMLreturn(Val_unit);
}
static void
gc_set_dashes(struct graphics_gc_priv *gc, int width, int offset, unsigned char *dash_list, int n)
{
#if 0
gdk_gc_set_dashes(gc->gc, offset, (gint8 *)dash_list, n);
gdk_gc_set_line_attributes(gc->gc, width, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND);
#endif
}
static void iDrawSetLineStyle(IdrawCanvas* dc, int style)
{
GdkGCValues gcval;
if (style == IUP_DRAW_STROKE || style == IUP_DRAW_FILL)
gcval.line_style = GDK_LINE_SOLID;
else
{
gint8 dashes[2] = { 6, 2 };
gint8 dots[2] = { 2, 2 };
if (style == IUP_DRAW_STROKE_DASH)
gdk_gc_set_dashes(dc->pixmap_gc, 0, dashes, 2);
else
gdk_gc_set_dashes(dc->pixmap_gc, 0, dots, 2);
gcval.line_style = GDK_LINE_ON_OFF_DASH;
}
gdk_gc_set_values(dc->pixmap_gc, &gcval, GDK_GC_LINE_STYLE);
}
void
gdl_dock_xor_rect (GdlDock *dock,
GdkRectangle *rect)
{
GtkWidget *widget;
gint8 dash_list [2];
widget = GTK_WIDGET (dock);
if (!dock->_priv->xor_gc) {
if (GTK_WIDGET_REALIZED (widget)) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
dock->_priv->xor_gc = gdk_gc_new_with_values
(widget->window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
} else
return;
};
gdk_gc_set_line_attributes (dock->_priv->xor_gc, 1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list [0] = 1;
dash_list [1] = 1;
gdk_gc_set_dashes (dock->_priv->xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (widget->window, dock->_priv->xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (dock->_priv->xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (widget->window, dock->_priv->xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
static VALUE
rg_set_dashes(VALUE self, VALUE rbdash_offset, VALUE rbdash_list)
{
GdkGC *gc = _SELF(self);
gint dash_offset = NUM2INT(rbdash_offset);
long n;
gint8 *dash_list = RVAL2GINT8S(rbdash_list, n);
gdk_gc_set_dashes(gc, dash_offset, dash_list, n);
g_free(dash_list);
return self;
}
/* Sets the way dashed-lines are drawn. Lines will be drawn with alternating
* on and off segments of the lengths specified in dash_list. The manner in
* which the on and off segments are drawn is determined by the line_style
* value of the GC. (This can be changed with gdk_gc_set_line_attributes) */
int
clip_GDK_GCSETDASHES(ClipMachine * cm)
{
C_object *cgc = _fetch_co_arg(cm);
gint dash_offset = _clip_parni (cm, 2);
gchar *dash_list = _clip_parc (cm, 3);
gint n = _clip_parni (cm, 4);
CHECKCOBJ(cgc,GDK_IS_GC(cgc));
CHECKOPT(2,NUMERIC_t); CHECKARG(3,CHARACTER_t); CHECKOPT(4,NUMERIC_t);
if (_clip_parinfo(cm,4)==UNDEF_t) n = strlen(dash_list);
gdk_gc_set_dashes(GDK_GC(cgc->object), dash_offset,(gint8 *)dash_list,n);
return 0;
err:
return 1;
}
static
void draw_triggerline(int chan_num, int highlight) {
static gint8 dashes[2] = {2,4};
scope_disp_t *disp = &(ctrl_usr->disp);
scope_chan_t *chan = &(ctrl_usr->chan[chan_num - 1]);
scope_trig_t *trig = &(ctrl_usr->trig);
double yfoffset = chan->vert_offset;
double ypoffset = chan->position * disp->height;
double yscale = disp->height / (-10.0 * chan->scale);
double fp_level =
chan->scale * ((chan->position - trig->level) * 10) +
chan->vert_offset;
int y1 = (fp_level-yfoffset) * yscale + ypoffset;
double dx = hypot(disp->width, disp->height) * .01;
double dy = dx * 1.3;
if(dx < 5) dx = 5;
if(dy < dx + 1) dy = dx + 1;
if(chan->data_type == HAL_BIT)
y1 = ypoffset;
if(ctrl_shm->trig_edge) dy = -dy;
if(highlight) {
gdk_gc_set_foreground(disp->context, &(disp->color_selected[chan_num-1]));
} else {
gdk_gc_set_foreground(disp->context, &(disp->color_normal[chan_num-1]));
}
gdk_gc_set_dashes(disp->context, 0, dashes, 2);
gdk_gc_set_line_attributes(disp->context, 0, GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER);
line(chan_num | 0x200, 0, y1, disp->width, y1);
gdk_gc_set_line_attributes(disp->context, 0, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
if(highlight) {
gdk_gc_set_foreground(disp->context, &(disp->color_grid));
} else {
gdk_gc_set_foreground(disp->context, &(disp->color_baseline));
}
line(chan_num | 0x300, 2*dx, y1, 2*dx, y1 + 2*dy);
line(chan_num | 0x300, dx, y1+dy, 2*dx, y1 + 2*dy);
line(chan_num | 0x300, 3*dx, y1+dy, 2*dx, y1 + 2*dy);
}
/* set the line type */
static void SetLineType(NewDevDesc *dd, int newlty, double nlwd)
{
static gint8 dashlist[8];
gint i, j, newlwd;
gtkDesc *gtkd = (gtkDesc *) dd->deviceSpecific;
newlwd = nlwd;
if(newlty != gtkd->lty || newlwd != gtkd->lwd) {
gtkd->lty = newlty;
gtkd->lwd = newlwd;
if(newlty == 0) {
if(newlwd <= 1)
newlwd = 0;
gdk_gc_set_line_attributes(gtkd->wgc, newlwd,
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_ROUND);
}
else {
if(newlwd < 1)
newlwd = 1;
for(i = 0; (i < 8) && (newlty != 0); i++) {
j = newlty & 15;
if(j == 0) j = 1;
j = j * newlwd;
if(j > 255) j = 255;
dashlist[i] = j;
newlty = newlty >> 4;
}
/* set dashes */
gdk_gc_set_dashes(gtkd->wgc, 0, dashlist, i);
gdk_gc_set_line_attributes(gtkd->wgc, newlwd,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_BUTT,
GDK_JOIN_ROUND);
}
}
void load_graph_configure_expose(LoadGraph * lg)
{
/* creates the backing store pixmap */
gtk_widget_realize(lg->area);
lg->buf = gdk_pixmap_new(lg->area->window, lg->width, lg->height, -1);
/* create the graphic contexts */
lg->grid = gdk_gc_new(GDK_DRAWABLE(lg->buf));
lg->trace = gdk_gc_new(GDK_DRAWABLE(lg->buf));
lg->fill = gdk_gc_new(GDK_DRAWABLE(lg->buf));
/* the default color is green */
load_graph_set_color(lg, LG_COLOR_GREEN);
/* init graphic contexts */
gdk_gc_set_line_attributes(lg->grid,
1, GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST, GDK_JOIN_ROUND);
gdk_gc_set_dashes(lg->grid, 0, (gint8*)"\2\2", 2);
#if 0 /* old-style grid */
gdk_rgb_gc_set_foreground(lg->grid, 0x707070);
#endif
gdk_gc_set_line_attributes(lg->trace,
1, GDK_LINE_SOLID,
GDK_CAP_PROJECTING, GDK_JOIN_ROUND);
#if 0 /* old-style fill */
gdk_gc_set_line_attributes(lg->fill,
1, GDK_LINE_SOLID,
GDK_CAP_BUTT, GDK_JOIN_BEVEL);
#endif
/* configures the expose event */
g_signal_connect(G_OBJECT(lg->area), "expose-event",
(GCallback) _expose, lg);
}
static void
gtk_plot_gdk_set_dash (GtkPlotPC *pc,
gdouble offset,
gdouble *values,
gint num_values)
{
gchar list[] = {'\0','\1','\2','\3','\4','\5','\6','\7'};
gchar dash[1000] = "";
gint i;
if(!GTK_PLOT_GDK(pc)->gc) return;
if(num_values == 0){
return;
}
for(i = 0; i < num_values; i++){
gint value;
value = values[i];
dash[i] = list[value];
}
gdk_gc_set_dashes(GTK_PLOT_GDK(pc)->gc, 0, dash, num_values);
}
static GdkGC *
gimp_canvas_gc_new (GimpCanvas *canvas,
GimpCanvasStyle style)
{
GdkGC *gc;
GdkGCValues values;
GdkGCValuesMask mask = 0;
GdkColor fg = { 0, 0, 0, 0 };
GdkColor bg = { 0, 0, 0, 0 };
if (! GTK_WIDGET_REALIZED (canvas))
return NULL;
switch (style)
{
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_WHITE:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
break;
case GIMP_CANVAS_STYLE_RENDER:
mask |= GDK_GC_EXPOSURES;
values.graphics_exposures = TRUE;
break;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
mask |= GDK_GC_LINE_STYLE;
values.line_style = GDK_LINE_ON_OFF_DASH;
/* fallthrough */
case GIMP_CANVAS_STYLE_XOR:
mask |= GDK_GC_FUNCTION | GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE;
if (gimp_canvas_get_xor_color (canvas, &fg))
values.function = GDK_XOR;
else
values.function = GDK_INVERT;
values.cap_style = GDK_CAP_NOT_LAST;
values.join_style = GDK_JOIN_MITER;
break;
case GIMP_CANVAS_STYLE_SELECTION_IN:
case GIMP_CANVAS_STYLE_SELECTION_OUT:
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
mask |= GDK_GC_CAP_STYLE | GDK_GC_FILL | GDK_GC_STIPPLE;
values.cap_style = GDK_CAP_NOT_LAST;
values.fill = GDK_OPAQUE_STIPPLED;
values.stipple = canvas->stipple[0];
break;
case GIMP_CANVAS_STYLE_CUSTOM:
default:
return NULL;
}
gc = gdk_gc_new_with_values (GTK_WIDGET (canvas)->window, &values, mask);
if (style == GIMP_CANVAS_STYLE_XOR_DOTTED)
{
gint8 one = 1;
gdk_gc_set_dashes (gc, 0, &one, 1);
}
switch (style)
{
default:
return gc;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
case GIMP_CANVAS_STYLE_XOR:
break;
case GIMP_CANVAS_STYLE_WHITE:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_SELECTION_IN:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SELECTION_OUT:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
bg.red = 0x7f7f;
bg.green = 0x7f7f;
bg.blue = 0x7f7f;
break;
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0x0;
bg.green = 0x7f7f;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0x0;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
fg.red = 0x0;
fg.green = 0x7f7f;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
fg.red = 0xffff;
fg.green = 0x0;
fg.blue = 0x0;
break;
}
gdk_gc_set_rgb_fg_color (gc, &fg);
gdk_gc_set_rgb_bg_color (gc, &bg);
return gc;
}
static void setgattr(Gwidget_t * widget, Ggattr_t * ap)
{
GdkGCValues gcv;
GdkColor c;
int color, width, mode, style, pati;
double intens;
if (!(ap->flags & G_GATTRCOLOR))
ap->color = WCU->defgattr.color;
if (!(ap->flags & G_GATTRWIDTH))
ap->width = WCU->defgattr.width;
if (!(ap->flags & G_GATTRMODE))
ap->mode = WCU->defgattr.mode;
if (!(ap->flags & G_GATTRFILL))
ap->fill = WCU->defgattr.fill;
if (!(ap->flags & G_GATTRSTYLE))
ap->style = WCU->defgattr.style;
color = ap->color;
if (color >= G_MAXCOLORS || !(WCU->colors[color].inuse))
color = 1;
if (color != WCU->gattr.color) {
WCU->gattr.color = color;
/*if (ap->mode == GDK_XOR) {
gdk_gc_set_foreground (GC, widget->w->style->white_gc);
}
else {
*/
gdk_gc_set_foreground(GC, &WCU->colors[WCU->gattr.color].color);
/* } */
/* if (Gdepth == 1) {
cp = &WCU->colors[color].color;
intens = (0.3 * cp->blue + 0.59 * cp->red +
0.11 * cp->green) / 65535.0;
pati = (intens <= 0.0625) ? 16 :
-16.0 * (log (intens) / 2.7725887222);
XSetTile (Gdisplay, GC, WCU->grays[pati]);
}
*/
}
mode = ap->mode;
if (mode != WCU->gattr.mode) {
WCU->gattr.mode = mode;
/* XSetFunction (Gdisplay, GC, WCU->gattr.mode);
if (mode == GDK_XOR)
gdk_gc_set_foreground (GC, &WCU->colors[0].color);
else
*/
gdk_gc_set_foreground(GC, &WCU->colors[WCU->gattr.color].color);
}
width = ap->width;
if (width != WCU->gattr.width) {
gdk_gc_set_line_attributes(GC, width, GDK_LINE_SOLID,
GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
}
WCU->gattr.fill = ap->fill;
style = ap->style;
if (style != WCU->gattr.style) {
WCU->gattr.style = style;
if (style == G_SOLID) {
gdk_gc_set_line_attributes(GC, width, GDK_LINE_SOLID,
GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
} else {
gdk_gc_set_dashes(GC, 0, gstyles[style], 2);
gdk_gc_set_line_attributes(GC, width, GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
}
}
}
/* ****************************************************************************
* 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);
}
static void
gdl_dock_master_xor_rect (GdlDockMaster *master)
{
gint8 dash_list [2];
GdkWindow *window;
GdkRectangle *rect;
if (!master->_priv || !master->_priv->drag_request)
return;
master->_priv->rect_drawn = ~master->_priv->rect_drawn;
if (master->_priv->rect_owner) {
gdl_dock_xor_rect (master->_priv->rect_owner,
&master->_priv->drag_request->rect);
return;
}
rect = &master->_priv->drag_request->rect;
window = gdk_get_default_root_window ();
if (!master->_priv->root_xor_gc) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
master->_priv->root_xor_gc = gdk_gc_new_with_values (
window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
};
#ifdef WIN32
GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
if (is_os_vista())
{
// On Vista the dash-line is increadibly slow to draw, it takes several minutes to draw the tracking lines
// With GDK_LINE_SOLID it is parts of a second
// No performance issue on WinXP
lineStyle = GDK_LINE_SOLID;
}
#else
GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
#endif
gdk_gc_set_line_attributes (master->_priv->root_xor_gc, 1,
lineStyle,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list[0] = 1;
dash_list[1] = 1;
gdk_gc_set_dashes (master->_priv->root_xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (master->_priv->root_xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
/* Redraw the screen from the backing pixmap */
static gboolean
histo_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
{
histoDrawing_t *drawing = (histoDrawing_t*)user_data;
HistoControlFlowData *histo_control_flow_data =
(HistoControlFlowData*)g_object_get_data(
G_OBJECT(widget),
"histo_control_flow_data");
#if 0
if(unlikely(drawing->gc == NULL)) {
drawing->gc = gdk_gc_new(drawing->drawing_area->window);
gdk_gc_copy(drawing->gc, drawing->drawing_area->style->black_gc);
}
#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(histo_control_flow_data->tab);
LttTime current_time =
lttvwindow_get_current_time(histo_control_flow_data->tab);
guint cursor_x=0;
LttTime window_end = time_window.end_time;
/* update the screen from the pixmap buffer */
//added again for histogram:
gdk_draw_pixmap(widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
drawing->pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
//0
drawing->height = drawing-> drawing_area ->allocation.height;
#if 0
copy_pixmap_to_screen(histo_control_flow_data->process_list,
widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
event->area.x, event->area.y,
event->area.width, event->area.height);
#endif //0
/* //disabled for histogram
copy_pixmap_to_screen(histo_control_flow_data->process_list,
widget->window,
drawing->gc,
event->area.x, event->area.y,
event->area.width, event->area.height);*/
/* Erase the dotted lines left.. */
if(widget->allocation.height > drawing->height)
{
gdk_draw_rectangle (widget->window,
drawing->drawing_area->style->black_gc,
TRUE,
event->area.x, drawing->height,
event->area.width, // do not overlap
widget->allocation.height - drawing->height);
}
if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
ltt_time_compare(window_end, current_time) >= 0)
{
/* Draw the dotted lines */
histo_convert_time_to_pixels(
time_window,
current_time,
drawing->width,
&cursor_x);
#if 0
if(drawing->dotted_gc == NULL) {
drawing->dotted_gc = gdk_gc_new(drawing->drawing_area->window);
gdk_gc_copy(drawing->dotted_gc, widget->style->white_gc);
gint8 dash_list[] = { 1, 2 };
gdk_gc_set_line_attributes(drawing->dotted_gc,
1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
gdk_gc_set_dashes(drawing->dotted_gc,
0,
dash_list,
2);
}
#endif //0
gint height_tot = MAX(widget->allocation.height, drawing->height);
gdk_draw_line(widget->window,
drawing->dotted_gc,
cursor_x, 0,
cursor_x, height_tot);
}
return FALSE;
}
histoDrawing_t *histo_drawing_construct(HistoControlFlowData *histo_control_flow_data)
{
histoDrawing_t *drawing = g_new(histoDrawing_t, 1);
drawing->histo_control_flow_data = histo_control_flow_data;
drawing->vbox = gtk_vbox_new(FALSE, 1);
drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
drawing->ruler = gtk_drawing_area_new ();
//gtk_widget_set_size_request(drawing->ruler, -1, 27);
drawing->padding = gtk_drawing_area_new ();
//gtk_widget_set_size_request(drawing->padding, -1, 27);
gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->padding,FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
TRUE, TRUE, 0);
drawing->drawing_area = gtk_drawing_area_new ();
drawing->gc = NULL;
/*
///at this time not necessary for histogram
drawing->hbox = gtk_hbox_new(FALSE, 1);
drawing->viewport = gtk_viewport_new(NULL, histo_control_flow_data->v_adjust);
drawing->scrollbar = gtk_vscrollbar_new(histo_control_flow_data->v_adjust);
gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(drawing->viewport),
drawing->drawing_area);*/
//add vertical ruler:
drawing->vruler_drawing_hbox = gtk_hbox_new(FALSE, 1);
drawing-> vertical_ruler =gtk_drawing_area_new ();
gtk_box_pack_start(GTK_BOX(drawing->vruler_drawing_hbox), drawing->vertical_ruler,
FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(drawing->vruler_drawing_hbox), drawing->drawing_area,
TRUE, TRUE, 1);
gtk_widget_set_size_request(drawing->vertical_ruler, padding_width, -1);
gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
FALSE, FALSE, 1);
gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->vruler_drawing_hbox/*drawing_area*/,
TRUE, TRUE, 1);
drawing->pango_layout =
gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
drawing->height = 1;
drawing->width = 1;
drawing->depth = 0;
drawing->alloc_height = 1;
drawing->alloc_width = 1;
drawing->damage_begin = 0;
drawing->damage_end = 0;
drawing->horizontal_sel = -1;
//gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
g_object_set_data_full(
G_OBJECT(drawing->drawing_area),
"histo_Link_drawing_Data",
drawing,
(GDestroyNotify)histo_drawing_destroy);
g_object_set_data(
G_OBJECT(drawing->ruler),
"histo_drawing",
drawing);
g_object_set_data(
G_OBJECT(drawing->vertical_ruler),
"histo_drawing",
drawing);
//gtk_widget_modify_bg( drawing->drawing_area,
// GTK_STATE_NORMAL,
// &CF_Colors[BLACK]);
//gdk_window_get_geometry(drawing->drawing_area->window,
// NULL, NULL,
// &(drawing->width),
// &(drawing->height),
// -1);
//drawing->pixmap = gdk_pixmap_new(
// drawing->drawing_area->window,
// drawing->width,
// drawing->height,
// drawing->depth);
drawing->pixmap = NULL;
// drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
// drawing->drawing_area->allocation.width,
// drawing->drawing_area->allocation.height,
// -1);
g_signal_connect (G_OBJECT(drawing->drawing_area),
"configure_event",
G_CALLBACK (histo_configure_event),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->ruler),
"expose_event",
G_CALLBACK(histo_expose_ruler),
(gpointer)drawing);
gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
gtk_widget_add_events(drawing->vertical_ruler, GDK_POINTER_MOTION_MASK);
g_signal_connect (G_OBJECT(drawing->ruler),
"motion-notify-event",
G_CALLBACK(histo_motion_notify_ruler),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->vertical_ruler),
"expose_event",
G_CALLBACK(histo_expose_vertical_ruler),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->vertical_ruler),
"motion-notify-event",
G_CALLBACK(histo_motion_notify_vertical_ruler),
(gpointer)drawing);
/*//not necessary for historam.
g_signal_connect (G_OBJECT(drawing->drawing_area),
"size-allocate",
G_CALLBACK(scrollbar_size_allocate),
(gpointer)drawing); */
gtk_widget_set_size_request(drawing->padding, padding_width, -1);//use it for vertical ruler
g_signal_connect (G_OBJECT(drawing->drawing_area),
"expose_event",
G_CALLBACK (histo_expose_event),
(gpointer)drawing);
g_signal_connect_after (G_OBJECT(drawing->drawing_area),
"expose_event",
G_CALLBACK (histo_after_expose_event),
(gpointer)drawing);
g_signal_connect (G_OBJECT(drawing->drawing_area),
"button-press-event",
G_CALLBACK (histo_button_press_event),
(gpointer)drawing);
gtk_widget_show(drawing->ruler);
gtk_widget_show(drawing->padding);
gtk_widget_show(drawing->ruler_hbox);
gtk_widget_show(drawing->vertical_ruler);
gtk_widget_show(drawing->vruler_drawing_hbox);
gtk_widget_show(drawing->drawing_area);
/// gtk_widget_show(drawing->viewport);
/// gtk_widget_show(drawing->scrollbar);
/// gtk_widget_show(drawing->hbox);
/* Allocate the colors */
GdkColormap* colormap = gdk_colormap_get_system();
gboolean success[NUM_COLORS];
gdk_colormap_alloc_colors(colormap, histo_drawing_colors, NUM_COLORS, FALSE,
TRUE, success);
drawing->gc =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
drawing->dotted_gc =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->gc,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
gdk_gc_copy(drawing->dotted_gc,
main_window_get_widget(histo_control_flow_data->tab)->style->white_gc);
gint8 dash_list[] = { 1, 2 };
gdk_gc_set_line_attributes(drawing->dotted_gc,
1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
gdk_gc_set_dashes(drawing->dotted_gc,
0,
dash_list,
2);
drawing->ruler_gc_butt =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->ruler_gc_butt,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
drawing->ruler_gc_round =
gdk_gc_new(GDK_DRAWABLE(main_window_get_widget(histo_control_flow_data->tab)->window));
gdk_gc_copy(drawing->ruler_gc_round,
main_window_get_widget(histo_control_flow_data->tab)->style->black_gc);
gdk_gc_set_line_attributes(drawing->ruler_gc_butt,
2,
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
gdk_gc_set_line_attributes(drawing->ruler_gc_round,
2,
GDK_LINE_SOLID,
GDK_CAP_ROUND,
GDK_JOIN_ROUND);
return drawing;
}
/** Draw a TextLine object.
* @param object The renderer object to use for transform and output
* @param text_line The TextLine to render, including font and height.
* @param pos The position to render it at.
* @param color The color to render it with.
*/
static void
draw_text_line (DiaRenderer *object, TextLine *text_line,
Point *pos, Alignment alignment, Color *color)
{
DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object);
GdkColor gdkcolor;
int x,y;
Point start_pos;
PangoLayout* layout = NULL;
const gchar *text = text_line_get_string(text_line);
int height_pixels;
real font_height = text_line_get_height(text_line);
real scale = dia_transform_length(renderer->transform, 1.0);
if (text == NULL || *text == '\0') return; /* Don't render empty strings. */
point_copy(&start_pos,pos);
renderer_color_convert(renderer, color, &gdkcolor);
height_pixels = dia_transform_length(renderer->transform, font_height);
if (height_pixels < 2) { /* "Greeking" instead of making tiny font */
int width_pixels = dia_transform_length(renderer->transform,
text_line_get_width(text_line));
gdk_gc_set_foreground(renderer->gc, &gdkcolor);
gdk_gc_set_dashes(renderer->gc, 0, (gint8*)"\1\2", 2);
dia_transform_coords(renderer->transform, start_pos.x, start_pos.y, &x, &y);
gdk_draw_line(renderer->pixmap, renderer->gc, x, y, x + width_pixels, y);
return;
} else {
start_pos.y -= text_line_get_ascent(text_line);
start_pos.x -= text_line_get_alignment_adjustment (text_line, alignment);
dia_transform_coords(renderer->transform,
start_pos.x, start_pos.y, &x, &y);
layout = dia_font_build_layout(text, text_line->font,
dia_transform_length(renderer->transform, text_line->height)/20.0);
#if defined(PANGO_VERSION_ENCODE)
# if (PANGO_VERSION >= PANGO_VERSION_ENCODE(1,16,0))
/* I'd say the former Pango API was broken, i.e. leaky */
# define HAVE_pango_layout_get_line_readonly
# endif
#endif
text_line_adjust_layout_line (text_line,
#if defined(HAVE_pango_layout_get_line_readonly)
pango_layout_get_line_readonly(layout, 0),
#else
pango_layout_get_line(layout, 0),
#endif
scale/20.0);
if (renderer->highlight_color != NULL) {
draw_highlighted_string(renderer, layout, x, y, &gdkcolor);
} else {
#if defined HAVE_FREETYPE
{
FT_Bitmap ftbitmap;
int width, height;
GdkPixbuf *rgba = NULL;
width = dia_transform_length(renderer->transform,
text_line_get_width(text_line));
height = dia_transform_length(renderer->transform,
text_line_get_height(text_line));
if (width > 0) {
int stride;
guchar* pixels;
int i,j;
guint8 *graybitmap;
initialize_ft_bitmap(&ftbitmap, width, height);
pango_ft2_render_layout(&ftbitmap, layout, 0, 0);
graybitmap = ftbitmap.buffer;
rgba = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
stride = gdk_pixbuf_get_rowstride(rgba);
pixels = gdk_pixbuf_get_pixels(rgba);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
pixels[i*stride+j*4] = gdkcolor.red>>8;
pixels[i*stride+j*4+1] = gdkcolor.green>>8;
pixels[i*stride+j*4+2] = gdkcolor.blue>>8;
pixels[i*stride+j*4+3] = graybitmap[i*ftbitmap.pitch+j];
}
}
g_free(graybitmap);
gdk_draw_pixbuf(renderer->pixmap, renderer->gc, rgba, 0, 0, x, y, width, height, GDK_RGB_DITHER_NONE, 0, 0);
g_object_unref(G_OBJECT(rgba));
}
}
#else
gdk_gc_set_foreground(renderer->gc, &gdkcolor);
gdk_draw_layout(renderer->pixmap, renderer->gc, x, y, layout);
#endif
} /* !higlight_color */
g_object_unref(G_OBJECT(layout));
} /* !greeking */
static void
gc_set_dashes(struct graphics_gc_priv *gc, unsigned char *dash_list, int n)
{
gdk_gc_set_dashes(gc->gc, 0, (gint8 *)dash_list, n);
gdk_gc_set_line_attributes(gc->gc, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND);
}
