static gint
configure_event (GtkWidget *widget, GdkEventConfigure *e, C2NetworkTraffic *nt)
{
if (!nt->blue)
{
GdkColor blue = { 0, 0, 0, 0xffff };
GdkColor red = { 0, 0xffff, 0, 0 };
gdk_color_alloc (gdk_colormap_get_system (), &blue);
gdk_color_alloc (gdk_colormap_get_system (), &red);
nt->blue = gdk_gc_new (GTK_WIDGET (nt)->window);
nt->red = gdk_gc_new (GTK_WIDGET (nt)->window);
gdk_gc_set_foreground (nt->blue, &blue);
gdk_gc_set_foreground (nt->red, &red);
}
if (nt->pixmap)
gdk_pixmap_unref (nt->pixmap);
nt->pixmap = gdk_pixmap_new (widget->window, widget->allocation.width,
widget->allocation.height, -1);
return TRUE;
}
static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
static void
gtk_plot_surface_init (GtkPlotSurface *dataset)
{
GtkWidget *widget;
GdkColormap *colormap;
GdkColor color;
GTK_WIDGET_SET_FLAGS(dataset, GTK_NO_WINDOW);
widget = GTK_WIDGET(dataset);
colormap = gtk_widget_get_colormap(widget);
gdk_color_parse("black", &color);
gdk_color_alloc(colormap, &color);
dataset->grid_foreground = color;
gdk_color_parse("dark green", &color);
gdk_color_alloc(colormap, &color);
dataset->grid_background = color;
gdk_color_parse("gray30", &color);
gdk_color_alloc(colormap, &color);
dataset->shadow = color;
gdk_color_parse("blue", &color);
gdk_color_alloc(colormap, &color);
dataset->color = color;
dataset->light.x = 0.;
dataset->light.y = 0.;
dataset->light.z = 1.;
dataset->nx = 0;
dataset->ny = 0;
dataset->show_grid = TRUE;
dataset->show_mesh = FALSE;
dataset->transparent = FALSE;
dataset->height_gradient = FALSE;
dataset->ambient = 0.3;
dataset->xstep = 0.05;
dataset->ystep = 0.05;
dataset->mesh_line.color = dataset->grid_foreground;
dataset->mesh_line.line_width = 1;
dataset->mesh_line.line_style = GTK_PLOT_LINE_SOLID;
dataset->dt = GTK_PLOT_DT(gtk_plot_dt_new(0));
dataset->recalc_dt = TRUE;
}
static void scope_realize(GtkWidget *widget)
{
Scope *scope;
GdkWindowAttr attributes;
gint attributes_mask;
GdkGCValues gc_values;
g_return_if_fail(widget != NULL);
g_return_if_fail(IS_SCOPE(widget));
scope = SCOPE(widget);
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual(widget);
attributes.colormap = gtk_widget_get_colormap(widget);
attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
gdk_window_set_user_data(widget->window, scope);
widget->style = gtk_style_attach(widget->style, widget->window);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
/* gc's if necessary */
if (!gdk_color_alloc(widget->style->colormap, &scope->tracecol))
g_warning("unable to allocate color: ( %d %d %d )",
scope->tracecol.red, scope->tracecol.green, scope->tracecol.blue);
gc_values.foreground = scope->tracecol;
scope->trace_gc = gtk_gc_get(widget->style->depth,
widget->style->colormap,
&gc_values, GDK_GC_FOREGROUND);
if (!gdk_color_alloc(widget->style->colormap, &scope->gridcol))
g_warning("unable to allocate color: ( %d %d %d )",
scope->gridcol.red, scope->gridcol.green, scope->gridcol.blue);
gc_values.foreground = scope->gridcol;
scope->grid_gc = gtk_gc_get(widget->style->depth,
widget->style->colormap,
&gc_values, GDK_GC_FOREGROUND);
/* create backing store */
scope->pixmap = gdk_pixmap_new(widget->window, SCOPE_WIDTH, SCOPE_HEIGHT, -1);
scope_send_configure(SCOPE(widget));
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color1, color2;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.56, .12, .12, .5, .2, .21}; /* Open */
static gdouble pz1[]={.60, .22, .27, .45, .22, .18}; /* Close */
static gdouble dy1[]={.52, .10, .12, .40, .16, .16}; /* Low */
static gdouble dz1[]={.62, .24, .30, .54, .24, .22}; /* High */
dataset[0] = GTK_PLOT_DATA(gtk_plot_candle_new());
/*
dataset[0] = GTK_PLOT_DATA(gtk_plot_data_new());
gtk_plot_autoscale(GTK_PLOT(active_plot));
*/
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, NULL, dy1, 6);
gtk_plot_data_set_z(dataset[0], pz1);
gtk_plot_data_set_dz(dataset[0], dz1);
gtk_plot_data_show_zerrbars(dataset[0]);
gdk_color_parse("black", &color1);
gdk_color_alloc(gdk_colormap_get_system(), &color1);
gdk_color_parse("red", &color2);
gdk_color_alloc(gdk_colormap_get_system(), &color2);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_FILLED,
10, 1, &color2, &color1);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color1);
/*
gtk_plot_data_set_x_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
gtk_plot_data_set_y_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
*/
gtk_plot_data_set_legend(dataset[0], "Japanese Candles");
}
void wxColourRefData::AllocColour( GdkColormap *cmap )
{
if (m_hasPixel && (m_colormap == cmap))
return;
FreeColour();
#ifdef __WXGTK20__
if ( (cmap->visual->type == GDK_VISUAL_GRAYSCALE) ||
(cmap->visual->type == GDK_VISUAL_PSEUDO_COLOR) )
#else
GdkColormapPrivate *private_colormap = (GdkColormapPrivate*) cmap;
if ((private_colormap->visual->type == GDK_VISUAL_GRAYSCALE) ||
(private_colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR))
#endif
{
m_hasPixel = gdk_colormap_alloc_color( cmap, &m_color, FALSE, TRUE );
int idx = m_color.pixel;
colMapAllocCounter[ idx ] = colMapAllocCounter[ idx ] + 1;
}
else
{
m_hasPixel = gdk_color_alloc( cmap, &m_color );
}
m_colormap = cmap;
}
void
build_example1(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={.12, .22, .27, .12, .052, .42};
static gdouble py2[]={.0, .05, .12, .22, .16, .1};
dataset[0] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, 6);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_data_set_legend(dataset[0], "Vector");
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={-0., -0.2, -0.4, -0.6, -0.8, -1.0};
static gdouble py1[]={-.2, -.4, -.5, -.35, -.30, -.40};
static gdouble px2[]={-.12, -.22, -.27, -.12, -.052, -.42};
static gdouble py2[]={-.0, -.05, -.12, -.22, -.16, -.1};
dataset[1] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[1]);
gtk_widget_show(GTK_WIDGET(dataset[1]));
gtk_plot_data_set_points(dataset[1], px1, py1, px2, py2, 6);
gtk_plot_segment_set_relative(GTK_PLOT_SEGMENT(dataset[1]), TRUE);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("blue", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[1],
GTK_PLOT_SYMBOL_NONE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[1],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_segment_set_arrow (GTK_PLOT_SEGMENT(dataset[1]), 0, 10, GTK_PLOT_SYMBOL_EMPTY);
gtk_plot_segment_set_arrow_mask (GTK_PLOT_SEGMENT(dataset[1]), GTK_PLOT_ARROW_ORIGIN|GTK_PLOT_ARROW_END);
gtk_plot_data_set_legend(dataset[1], "Segment");
}
/* INPUT
* red, green, blue : 0-255
* OUTPUT
* gc :
*/
void
get_color (GtkWidget * widget, gint red, gint green, gint blue, GdkGC * gc)
{
GdkColor color;
/* red, green, and blue are passed values, indicating the RGB triple
* of the color we want to draw. Note that the values of the RGB components
* within the GdkColor are taken from 0 to 65535, not 0 to 255.
*/
color.red = red * (65535 / 255);
color.green = green * (65535 / 255);
color.blue = blue * (65535 / 255);
/* the pixel value indicates the index in the colormap of the color.
* it is simply a combination of the RGB values we set earlier
*/
color.pixel = (gulong)(red * 65536 + green * 256 + blue);
/* However, the pixel valule is only truly valid on 24-bit (TrueColor)
* displays. Therefore, this call is required so that GDK and X can
* give us the closest color available in the colormap
*/
gdk_color_alloc (gtk_widget_get_colormap (widget), &color);
/* set the foreground to our color */
gdk_gc_set_foreground (gc, &color);
}
gboolean
ghid_port_drawing_area_configure_event_cb (GtkWidget * widget,
GdkEventConfigure * ev,
GHidPort * out)
{
static gboolean first_time_done;
HideCrosshair (TRUE);
gport->width = ev->width;
gport->height = ev->height;
if (gport->pixmap)
gdk_pixmap_unref (gport->pixmap);
gport->pixmap = gdk_pixmap_new (widget->window,
gport->width, gport->height, -1);
gport->drawable = gport->pixmap;
if (!first_time_done)
{
gport->colormap = gtk_widget_get_colormap (gport->top_window);
gport->bg_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.BackgroundColor, &gport->bg_color))
gdk_color_alloc (gport->colormap, &gport->bg_color);
else
gdk_color_white (gport->colormap, &gport->bg_color);
gdk_gc_set_foreground (gport->bg_gc, &gport->bg_color);
gport->offlimits_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.OffLimitColor, &gport->offlimits_color))
gdk_color_alloc (gport->colormap, &gport->offlimits_color);
else
gdk_color_white (gport->colormap, &gport->offlimits_color);
gdk_gc_set_foreground (gport->offlimits_gc, &gport->offlimits_color);
first_time_done = TRUE;
PCBChanged (0, NULL, 0, 0);
}
if (gport->mask)
{
gdk_pixmap_unref (gport->mask);
gport->mask = gdk_pixmap_new (0, gport->width, gport->height, 1);
}
ghid_port_ranges_scale (FALSE);
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
return 0;
}
void SetColor(gushort r, gushort g, gushort b)
{
GdkColor color;
color.red = r, color.green = g, color.blue = b;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(g_gc, &color);
}
/* Init function. Here we setup all the gtk stuff */
static GtkWidget *init_fftscope_window()
{
GtkWidget *fftscope_win;
GtkStyle *style;
GdkColor color;
guint32 colors[129];
int i;
pthread_mutex_init(&fftscope_mutex, NULL);
style = gtk_style_new();
fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope");
gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT);
gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope",
"AlsaPlayer");
gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE,
FALSE);
style =
gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win)));
color.red = SCOPE_BG_RED << 8;
color.blue = SCOPE_BG_BLUE << 8;
color.green = SCOPE_BG_GREEN << 8;
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_widget_set_style(GTK_WIDGET(fftscope_win), style);
for (i = 0; i < 32; i++) {
colors[i * 2] = colors[i * 2 + 1] =
((i * 8) << 16) + (255 << 8);
colors[i * 2 + 64] = colors[i * 2 + 65] =
(255 << 16) + (((31 - i) * 8) << 8);
}
colors[128] = 0;
color_map = gdk_rgb_cmap_new(colors, 129);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(fftscope_win), area);
gtk_widget_realize(area);
gdk_window_set_background(area->window, &color);
gtk_widget_show(area);
gtk_widget_show(fftscope_win);
/* Signals */
gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event",
GTK_SIGNAL_FUNC(close_fftscope_window),
fftscope_win);
/* Clear and show the window */
gdk_window_clear(fftscope_win->window);
gdk_flush();
ready_state = 1;
return fftscope_win;
}
/*
* AllocateColors
*
* Allocate the colors in the colormap.
*/
void AllocateColors ()
{
int i;
gdk_color_alloc (gdk_colormap_get_system (), &red);
gdk_color_alloc (gdk_colormap_get_system (), &blue);
gdk_color_alloc (gdk_colormap_get_system (), &green);
gdk_color_alloc (gdk_colormap_get_system (), &yellow);
gdk_color_alloc (gdk_colormap_get_system (), &purple);
gdk_color_alloc (gdk_colormap_get_system (), &orange);
gdk_color_alloc (gdk_colormap_get_system (), &cyan);
gdk_color_alloc (gdk_colormap_get_system (), &black);
gdk_color_alloc (gdk_colormap_get_system (), &white);
for (i = 0; i < numColors; i++) {
gdk_color_alloc (gdk_colormap_get_system (), &colorlist[i]);
}
}
void
build_example1(GtkWidget *active_plot,GtkPlotDT *data, gint num)
{
GdkColor color;
gdouble *px1= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *py1= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *px2= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble *py2= (gdouble *)g_malloc(sizeof(gdouble)*num*3);
gdouble ax,ay,bx,by,cx,cy;
GtkPlotDTtriangle *t= NULL;
GList *list = NULL;
gint i = 0;
list = data->triangles;
while(list){
t = (GtkPlotDTtriangle *)list->data;
ax= gtk_plot_dt_get_node(data,t->a)->x;
ay= gtk_plot_dt_get_node(data,t->a)->y;
bx= gtk_plot_dt_get_node(data,t->b)->x;
by= gtk_plot_dt_get_node(data,t->b)->y;
cx= gtk_plot_dt_get_node(data,t->c)->x;
cy= gtk_plot_dt_get_node(data,t->c)->y;
px1[i*3+0]= ax; py1[i*3+0]= ay;
px2[i*3+0]= bx-ax; py2[i*3+0]= by-ay;
px1[i*3+1]= bx; py1[i*3+1]= by;
px2[i*3+1]= cx-bx; py2[i*3+1]= cy-by;
px1[i*3+2]= cx; py1[i*3+2]= cy;
px2[i*3+2]= ax-cx; py2[i*3+2]= ay-cy;
i++;
list = list->next;
}
fprintf(stderr,"%d triangles, %d points\n",num,num*3);
dataset[0] = GTK_PLOT_DATA(gtk_plot_flux_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, num*3);
gtk_plot_flux_center(GTK_PLOT_FLUX(dataset[0]), FALSE);
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_flux_set_arrow(GTK_PLOT_FLUX(dataset[0]), 0, 0, 0);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_OPAQUE,
0,1, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, &color);
gtk_plot_data_set_legend(dataset[0], "Delaunay triangulization");
}
int main (int argc, char *argv[])
{
gint i;
GtkWidget *window;
GtkWidget *darea;
Data data;
GdkColormap *cmap;
//初始化
gtk_set_locale ();
gtk_init (&argc, &argv);
//建立根窗口
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "GDKString");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
//建立绘图窗口
darea = gtk_drawing_area_new ();
gtk_widget_set_usize (darea, 550, 150);
//曝光时调用函数重绘
gtk_widget_set_events (darea, GDK_EXPOSURE_MASK);
gtk_signal_connect (GTK_OBJECT (darea),
"expose_event", GTK_SIGNAL_FUNC (draw_callback),
&data);
gtk_container_add (GTK_CONTAINER (window), darea);
//取得颜色表
cmap = gdk_colormap_get_system ();
for (i = 0; i < NTEXT_COLORS; i++){
//获得GC
data.gc[i] = gdk_gc_new (window->window);
//分配颜色
if (!gdk_color_alloc(cmap, &text_colors[i].color))
g_error("couldn't allocate colour");
//设置GC的前景色
gdk_gc_set_foreground (data.gc[i],
&text_colors[i].color);
}
//设置字体集
data.font1 = gdk_fontset_load (
"7x14,-*-song-medium-r-normal--14-*-*-*-*-*-gbk-0");
data.font2 = gdk_fontset_load (
"8x16,-*-song-medium-r-normal--16-*-*-*-*-*-gbk-0");
data.font3 = gdk_fontset_load (
"12x24,-*-song-medium-r-normal--24-*-*-*-*-*-gbk-0");
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void SetBgColor( GdkGC *gc, long r, long g, long b )
{
GdkColor color;
color.red = r;
color.green = g;
color.blue = b;
gdk_color_alloc( gdk_colormap_get_system(), &color );
gdk_gc_set_background( gc, &color );
}
gboolean
ghid_port_drawing_area_configure_event_cb (GtkWidget * widget,
GdkEventConfigure * ev,
GHidPort * out)
{
static gboolean first_time_done;
gport->width = ev->width;
gport->height = ev->height;
if (gport->pixmap)
gdk_pixmap_unref (gport->pixmap);
gport->pixmap = gdk_pixmap_new (gtk_widget_get_window (widget),
gport->width, gport->height, -1);
gport->drawable = gport->pixmap;
if (!first_time_done)
{
gport->colormap = gtk_widget_get_colormap (gport->top_window);
if (gdk_color_parse (Settings.BackgroundColor, &gport->bg_color))
gdk_color_alloc (gport->colormap, &gport->bg_color);
else
gdk_color_white (gport->colormap, &gport->bg_color);
if (gdk_color_parse (Settings.OffLimitColor, &gport->offlimits_color))
gdk_color_alloc (gport->colormap, &gport->offlimits_color);
else
gdk_color_white (gport->colormap, &gport->offlimits_color);
first_time_done = TRUE;
ghid_drawing_area_configure_hook (out);
PCBChanged (0, NULL, 0, 0);
}
else
{
ghid_drawing_area_configure_hook (out);
}
ghid_port_ranges_scale ();
ghid_invalidate_all ();
return 0;
}
/* compute a gdkcolor */
void setcolor(GtkWidget *widget, GdkColor *color, gint red,gint green,gint blue)
{
/* colors in GdkColor are taken from 0 to 65535, not 0 to 255. */
color->red = red * (65535/255);
color->green = green * (65535/255);
color->blue = blue * (65535/255);
color->pixel = (gulong)(color->red*65536 + color->green*256 + color->blue);
/* find closest in colormap, if needed */
gdk_color_alloc(gtk_widget_get_colormap(widget),color);
}
gint level_meters_configure_event(GtkWidget *widget, GdkEventConfigure *event) {
int idx = get_index(gtk_widget_get_name(widget));
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
if (pixmap[idx] != NULL)
gdk_pixmap_unref(pixmap[idx]);
pixmap[idx] = gdk_pixmap_new(gtk_widget_get_window(widget),
allocation.width,
allocation.height,
-1);
penWhiteLight[idx] = get_pen(idx, 0xffff, 0xffff, 0xffff);
penGreenLight[idx] = get_pen(idx, 0, 0xffff, 0);
/* NPM: Setup penForeground[idx] color for meters */
levelmeters_init_fg(widget, (penForeground[idx] = gdk_gc_new(pixmap[idx])));
/* NPM: Setup penBackground[idx] color for meters */
levelmeters_init_bg(widget, (penBackground[idx] = gdk_gc_new(pixmap[idx])));
penOrangeLight[idx] = get_pen(idx, 0xff11, 0x9911, 0);
peak_label_color = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */
gdk_color_parse("red", peak_label_color);
gdk_color_alloc(gdk_colormap_get_system(), peak_label_color);
penRedLight[idx] = get_pen(idx, 0xffff, 0, 0);
gdk_draw_rectangle(pixmap[idx],
gtk_widget_get_style(widget)->black_gc,
TRUE,
0, 0,
allocation.width,
allocation.height);
/* NPM: ensure redraw_meters() below does a full refresh, per meter */
if (idx == 0) { /* "if stereo" -- special case for L/R output pair of digital mixer */
// g_print("level_meters_configure_event() for stereo\n");
peak_levels[IDX_LMIX] = 0;
peak_levels[IDX_RMIX] = 0;
previous_levels[IDX_LMIX] = 0;
previous_levels[IDX_RMIX] = 0;
peak_changed[IDX_LMIX] = RESET;
peak_changed[IDX_RMIX] = RESET;
}
else {
// g_print("level_meters_configure_event() for %i\n", idx);
peak_levels[idx-1] = 0;
previous_levels[idx-1] = 0;
peak_changed[idx-1] = RESET;
}
// g_print("configure: %i:%i\n", allocation.width, allocation.height);
redraw_meters(idx, allocation.width, allocation.height, 0, 0);
return TRUE;
}
/* Config helper functions for when the user changes color preferences.
| set_special colors used in the gtkhid.
*/
static void
set_special_grid_color (void)
{
if (!gport->colormap)
return;
gport->grid_color.red ^= gport->bg_color.red;
gport->grid_color.green ^= gport->bg_color.green;
gport->grid_color.blue ^= gport->bg_color.blue;
gdk_color_alloc (gport->colormap, &gport->grid_color);
if (gport->grid_gc)
gdk_gc_set_foreground (gport->grid_gc, &gport->grid_color);
}
static void
gtk_hex_entry_realize (GtkWidget *widget)
{
GtkHexEntry *hex_entry;
GtkRequisition requisition;
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
hex_entry = GTK_HEX_ENTRY (widget);
gtk_widget_get_child_requisition (widget, &requisition);
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = requisition.width;
attributes.height = requisition.height;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.cursor = hex_entry->cursor = gdk_cursor_new (GDK_XTERM);
attributes.event_mask = gtk_widget_get_events (widget)
| GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK
| GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP |
GDK_WA_CURSOR;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, hex_entry);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
gdk_color_alloc (gtk_widget_get_colormap (widget),&hex_entry->cursor_color);
hex_entry->gc = gdk_gc_new (widget->window);
gdk_gc_set_foreground (hex_entry->gc,&hex_entry->cursor_color);
}
static void
gtk_plot_gdk_set_color (GtkPlotPC *pc,
const GdkColor *color)
{
GdkColor new_color;
if(!GTK_PLOT_GDK(pc)->gc) return;
new_color = *color;
gdk_color_alloc(gdk_colormap_get_system(), &new_color);
gdk_gc_set_foreground(GTK_PLOT_GDK(pc)->gc, &new_color);
}
/* NPM: called out of level_meters_configure_event() at initialization to
pickup foreground color for level metering from --lights_color
command-line, or create default. */
static void levelmeters_init_fg(GtkWidget* widget, GdkGC *gc) {
if (meter_fg == NULL) { /* if --lights_color command-line argument not provided */
meter_fg = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */
if (!gdk_color_parse("#1e90ff", meter_fg)) { /* "dodgerblue" per http://en.wikipedia.org/wiki/X11_color_names */
free((void*) meter_fg); /* if for some impossible reason above fails, continue on valiantly */
meter_fg = &(gtk_widget_get_style(widget)->text_aa[GTK_STATE_ACTIVE]); /* should never happen, but this would pick up color from existing gtk style w/o needing any addl color allocs */
}
else
gdk_color_alloc(gdk_colormap_get_system(), meter_fg);
}
gdk_gc_set_foreground(gc, meter_fg);
}
static void board_color_init (char *color, GdkColor *gdkcolor, GdkGC **gc, GdkColormap *cmap, GtkWidget *board_area)
{
gdkcolor->red = 256 * (color ? color[0] : 215);
gdkcolor->green = 256 * (color ? color[1] : 215);
gdkcolor->blue = 256 * (color ? color[2] : 215);
gdk_color_alloc (cmap, gdkcolor);
if (*gc)
gdk_gc_unref (*gc);
*gc = gdk_gc_new(board_area->window);
gdk_gc_set_foreground (*gc, gdkcolor);
}
/* NPM: called out of level_meters_configure_event() at initialization to
pickup background color for level metering from --bg_color command-line
argument, or create default. */
static void levelmeters_init_bg(GtkWidget* widget, GdkGC *gc) {
if (meter_bg == NULL) { /* if --bg_color command-line argument not provided */
meter_bg = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */
if (!gdk_color_parse("#304050", meter_bg)) { /* a dark background color */
free((void*) meter_bg); /* if for some impossible reason above fails, continue on valiantly */
meter_bg = &(gtk_widget_get_style(widget)->text_aa[GTK_STATE_PRELIGHT]); /* should never happen, but this would pick up color from existing gtk style w/o needing any addl color allocs */
}
else
gdk_color_alloc(gdk_colormap_get_system(), meter_bg);
}
gdk_gc_set_foreground(gc, meter_bg);
}
void DrawString(GdkWindow* window, GdkFont* font, GdkGC* gc,
gint dstx, gint dsty, gchar* str)
{
GdkColor color;
color.red = 0;
color.green = 0;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(), &color);
gdk_gc_set_fill(gc, GDK_SOLID);
gdk_gc_set_foreground(gc, &color);
gdk_draw_string(window, font, gc, dstx, dsty, str);
}
static GdkGC *get_pen(int idx, int nRed, int nGreen, int nBlue) {
GdkColor *c;
GdkGC *gc;
c = (GdkColor *)g_malloc(sizeof(GdkColor));
c->red = nRed;
c->green = nGreen;
c->blue = nBlue;
gdk_color_alloc(gdk_colormap_get_system(), c);
gc = gdk_gc_new(pixmap[idx]);
gdk_gc_set_foreground(gc, c);
return gc;
}
static void init_colors(GtkWidget *widget)
{
int n;
const int *p;
GdkColor *c;
for (n = 0, p = default_colors, c = CLAVIER(widget)->colors; n < CLAVIERCOL_LAST; n++, c++) {
c->red = *p++ * 65535 / 255;
c->green = *p++ * 65535 / 255;
c->blue = *p++ * 65535 / 255;
c->pixel = (gulong)((c->red & 0xff00)*256 + (c->green & 0xff00) + (c->blue & 0xff00)/256);
gdk_color_alloc(gtk_widget_get_colormap(widget), c);
}
}
/*
* This function sets the view's current drawing color.
*/
static void
view_set_color (view_data_t *view_data, char *color)
{
GdkColormap *colormap;
GdkColor gdk_color;
fprintf (stderr, "Set color to '%s'\n", color);
colormap = gtk_widget_get_colormap (view_data->drawing_area);
gdk_color_parse (color, &gdk_color);
gdk_color_alloc (colormap, &gdk_color);
gdk_gc_set_foreground (view_data->gc, &gdk_color);
}
static void
draw_lead_user (render_priv *priv)
{
GdkWindow *window = gtk_widget_get_window (gport->drawing_area);
GtkStyle *style = gtk_widget_get_style (gport->drawing_area);
int i;
Coord radius = priv->lead_user_radius;
Coord width = MM_TO_COORD (LEAD_USER_WIDTH);
Coord separation = MM_TO_COORD (LEAD_USER_ARC_SEPARATION);
static GdkGC *lead_gc = NULL;
GdkColor lead_color;
if (!priv->lead_user)
return;
if (lead_gc == NULL)
{
lead_gc = gdk_gc_new (window);
gdk_gc_copy (lead_gc, style->white_gc);
gdk_gc_set_function (lead_gc, GDK_XOR);
gdk_gc_set_clip_origin (lead_gc, 0, 0);
lead_color.pixel = 0;
lead_color.red = (int)(65535. * LEAD_USER_COLOR_R);
lead_color.green = (int)(65535. * LEAD_USER_COLOR_G);
lead_color.blue = (int)(65535. * LEAD_USER_COLOR_B);
gdk_color_alloc (gport->colormap, &lead_color);
gdk_gc_set_foreground (lead_gc, &lead_color);
}
set_clip (priv, lead_gc);
gdk_gc_set_line_attributes (lead_gc, Vz (width),
GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
/* arcs at the approrpriate radii */
for (i = 0; i < LEAD_USER_ARC_COUNT; i++, radius -= separation)
{
if (radius < width)
radius += MM_TO_COORD (LEAD_USER_INITIAL_RADIUS);
/* Draw an arc at radius */
gdk_draw_arc (gport->drawable, lead_gc, FALSE,
Vx (priv->lead_user_x - radius),
Vy (priv->lead_user_y - radius),
Vz (2. * radius), Vz (2. * radius),
0, 360 * 64);
}
}
