void update_onscreen_w_ranges()
{
GtkWidget *container = NULL;
static GtkWidget *table = NULL;
GtkWidget *dummy = NULL;
GtkWidget *label = NULL;
GtkWidget *button = NULL;
GtkWidget *img = NULL;
GtkAdjustment *adj = NULL;
guint i = 0;
gint y = 1;
gfloat low = 0.0;
gfloat high = 0.0;
MtxWarningRange *range = NULL;
GArray * array = NULL;
if ((!toplevel) || (!GTK_IS_WIDGET(gauge)))
return;
array = mtx_gauge_face_get_warning_ranges(MTX_GAUGE_FACE(gauge));
container = GTK_WIDGET (gtk_builder_get_object(toplevel,"warning_range_viewport"));
if (!GTK_IS_WIDGET(container))
{
printf("color range viewport invalid!!\n");
return;
}
y=1;
if (GTK_IS_WIDGET(table))
gtk_widget_destroy(table);
table = gtk_table_new(2,7,FALSE);
gtk_container_add(GTK_CONTAINER(container),table);
if (array->len > 0)
{
/* Create headers */
label = gtk_label_new("Low");
gtk_table_attach(GTK_TABLE(table),label,1,2,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("High");
gtk_table_attach(GTK_TABLE(table),label,2,3,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Inset");
gtk_table_attach(GTK_TABLE(table),label,3,4,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("LWidth");
gtk_table_attach(GTK_TABLE(table),label,4,5,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Day Color");
gtk_table_attach(GTK_TABLE(table),label,5,6,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
label = gtk_label_new("Night Color");
gtk_table_attach(GTK_TABLE(table),label,6,7,0,1,GTK_EXPAND,GTK_SHRINK,0,0);
}
/* Repopulate the table with the current ranges... */
for (i=0;i<array->len; i++)
{
range = g_array_index(array,MtxWarningRange *, i);
button = gtk_button_new();
img = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(button),img);
OBJ_SET((button),"range_index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(remove_w_range),NULL);
gtk_table_attach(GTK_TABLE(table),button,0,1,y,y+1,0,0,0,0);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &low);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &high);
dummy = gtk_spin_button_new_with_range(low,high,(high-low)/100);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->lowpoint);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_LOWPOINT));
gtk_table_attach(GTK_TABLE(table),dummy,1,2,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(low,high,(high-low)/100);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->highpoint);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_HIGHPOINT));
gtk_table_attach(GTK_TABLE(table),dummy,2,3,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(0,1,0.001);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->inset);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_INSET));
gtk_table_attach(GTK_TABLE(table),dummy,3,4,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_spin_button_new_with_range(0,1,0.001);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),range->lwidth);
g_signal_connect(G_OBJECT(dummy),"value_changed", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_LWIDTH));
gtk_table_attach(GTK_TABLE(table),dummy,4,5,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_color_button_new_with_color(&range->color[MTX_DAY]);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(dummy),"color_set", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_COLOR_DAY));
gtk_table_attach(GTK_TABLE(table),dummy,5,6,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
dummy = gtk_color_button_new_with_color(&range->color[MTX_NITE]);
OBJ_SET(dummy,"index",GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(dummy),"color_set", G_CALLBACK(alter_w_range_data),GINT_TO_POINTER(WR_COLOR_NITE));
gtk_table_attach(GTK_TABLE(table),dummy,6,7,y,y+1,GTK_SHRINK,GTK_SHRINK,0,0);
y++;
}
/* Scroll to end */
dummy = GTK_WIDGET (gtk_builder_get_object(toplevel,"crange_swin"));
adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(dummy));
gtk_adjustment_set_value(adj,gtk_adjustment_get_upper(adj));
gtk_widget_show_all(container);
}
GtkWidget* bimp_watermark_gui_new(watermark_settings settings)
{
GtkWidget *gui, *hbox_text_entry, *hbox_text_font, *hbox_text_color, *hbox_opacity, *frame_position, *table_position;
GtkWidget *align_radio_text, *align_radio_image;
GtkWidget *label_text, *label_font, *label_color, *label_opacity, *label_percent;
gui = gtk_vbox_new(FALSE, 5);
align_radio_text = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_text), 0, 5, 10, 0);
radio_text = gtk_radio_button_new_with_label(NULL, _("Text watermark"));
vbox_text = gtk_vbox_new(FALSE, 5);
hbox_text_entry = gtk_hbox_new(FALSE, 5);
label_text = gtk_label_new(g_strconcat(_("Text"), ":", NULL));
gtk_widget_set_size_request (label_text, LABEL_W, LABEL_H);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_text), settings->mode);
entry_text = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry_text), 50);
gtk_entry_set_text(GTK_ENTRY(entry_text), settings->text);
gtk_widget_set_size_request (entry_text, INPUT_W, INPUT_H);
hbox_text_font = gtk_hbox_new(FALSE, 5);
label_font = gtk_label_new(g_strconcat(_("Font"), ":", NULL));
gtk_widget_set_size_request (label_font, LABEL_W, LABEL_H);
chooser_font = gtk_font_button_new_with_font(pango_font_description_to_string(settings->font));
gtk_widget_set_size_request (chooser_font, INPUT_W, INPUT_H);
hbox_text_color = gtk_hbox_new(FALSE, 5);
label_color = gtk_label_new(g_strconcat(_("Color"), ":", NULL));
gtk_widget_set_size_request (label_color, LABEL_W, LABEL_H);
chooser_color = gtk_color_button_new_with_color(&(settings->color));
gtk_widget_set_size_request (chooser_color, INPUT_W, INPUT_H);
align_radio_image = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_image), 0, 5, 10, 0);
radio_image = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON(radio_text), _("Image watermark"));
vbox_image = gtk_vbox_new(FALSE, 5);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_image), !settings->mode);
chooser_image = gtk_file_chooser_button_new(_("Select image"), GTK_FILE_CHOOSER_ACTION_OPEN);
/* set image chooser's filters */
GtkFileFilter *filter_all, *supported[5];
filter_all = gtk_file_filter_new();
gtk_file_filter_set_name(filter_all, _("All supported types"));
supported[0] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[0], "Bitmap (*.bmp)");
gtk_file_filter_add_pattern (supported[0], "*.bmp");
gtk_file_filter_add_pattern (filter_all, "*.bmp");
supported[1] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[1], "JPEG (*.jpg, *.jpeg, *jpe)");
gtk_file_filter_add_pattern (supported[1], "*.jpg");
gtk_file_filter_add_pattern (supported[1], "*.jpeg");
gtk_file_filter_add_pattern (supported[1], "*.jpe");
gtk_file_filter_add_pattern (filter_all, "*.jpg");
gtk_file_filter_add_pattern (filter_all, "*.jpeg");
gtk_file_filter_add_pattern (filter_all, "*.jpe");
supported[2] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[2], "GIF (*.gif)");
gtk_file_filter_add_pattern (supported[2], "*.gif");
gtk_file_filter_add_pattern (filter_all, "*.gif");
supported[3] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[3], "PNG (*.png)");
gtk_file_filter_add_pattern (supported[3], "*.png");
gtk_file_filter_add_pattern (filter_all, "*.png");
supported[4] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[4], "TIFF (*tif, *.tiff)");
gtk_file_filter_add_pattern (supported[4], "*.tiff");
gtk_file_filter_add_pattern (supported[4], "*.tif");
gtk_file_filter_add_pattern (filter_all, "*.tiff");
gtk_file_filter_add_pattern (filter_all, "*.tif");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), filter_all);
int i;
for(i = 0; i < 5; i++) {
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), supported[i]);
}
if (settings->image_file != NULL) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(chooser_image), settings->image_file);
}
gtk_widget_set_size_request (chooser_image, INPUT_W, INPUT_H);
hbox_opacity = gtk_hbox_new(FALSE, 5);
label_opacity = gtk_label_new(g_strconcat(_("Opacity"), ":", NULL));
gtk_widget_set_size_request (label_opacity, LABEL_TRANSP_W, LABEL_TRANSP_H);
gtk_misc_set_alignment(GTK_MISC(label_opacity), 0.5, 0.8);
scale_opacity = gtk_hscale_new_with_range(1, 100, 1);
gtk_range_set_value(GTK_RANGE(scale_opacity), settings->opacity);
gtk_widget_set_size_request (scale_opacity, SCALE_TRANSP_W, SCALE_TRANSP_H);
label_percent = gtk_label_new("%");
gtk_widget_set_size_request (label_percent, LABEL_PERCENT_W, LABEL_PERCENT_H);
gtk_misc_set_alignment(GTK_MISC(label_percent), 0.5, 0.8);
frame_position = gtk_frame_new(g_strconcat(_("Position on the image"), ":", NULL));
gtk_widget_set_size_request (frame_position, FRAME_POSITION_W, FRAME_POSITION_H);
table_position = gtk_table_new(3, 3, TRUE);
button_tl = gtk_radio_button_new (NULL);
gtk_button_set_image(GTK_BUTTON(button_tl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tl, watermark_pos_get_string(WM_POS_TL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tl), settings->position == WM_POS_TL);
gtk_widget_set_size_request (button_tl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tl, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tc, watermark_pos_get_string(WM_POS_TC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tc), settings->position == WM_POS_TC);
gtk_widget_set_size_request (button_tc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tc, 1, 2, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tr, watermark_pos_get_string(WM_POS_TR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tr), settings->position == WM_POS_TR);
gtk_widget_set_size_request (button_tr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tr, 2, 3, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cl, watermark_pos_get_string(WM_POS_CL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cl), settings->position == WM_POS_CL);
gtk_widget_set_size_request (button_cl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cl, 0, 1, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cc, watermark_pos_get_string(WM_POS_CC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cc), settings->position == WM_POS_CC);
gtk_widget_set_size_request (button_cc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cc, 1, 2, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cr, watermark_pos_get_string(WM_POS_CR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cr), settings->position == WM_POS_CR);
gtk_widget_set_size_request (button_cr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cr, 2, 3, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bl, watermark_pos_get_string(WM_POS_BL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bl), settings->position == WM_POS_BL);
gtk_widget_set_size_request (button_bl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bl, 0, 1, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bc, watermark_pos_get_string(WM_POS_BC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bc), settings->position == WM_POS_BC);
gtk_widget_set_size_request (button_bc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bc, 1, 2, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_br = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_br), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_br, watermark_pos_get_string(WM_POS_BR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_br), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_br), settings->position == WM_POS_BR);
gtk_widget_set_size_request (button_br, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_br, 2, 3, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), label_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), entry_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), label_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), chooser_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), label_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), chooser_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_color, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_text), vbox_text);
gtk_box_pack_start(GTK_BOX(gui), align_radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_image), chooser_image, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_image), vbox_image);
gtk_box_pack_start(GTK_BOX(gui), align_radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), scale_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_percent, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), hbox_opacity, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame_position), table_position);
gtk_box_pack_start(GTK_BOX(gui), frame_position, FALSE, FALSE, 0);
toggle_group(NULL, NULL);
g_signal_connect(G_OBJECT(radio_text), "toggled", G_CALLBACK(toggle_group), NULL);
return gui;
}
void create_xosd_gui(Sven *sven,GtkWidget *vbox)
{
GtkWidget *hbox,*hbox1, *label,*unit_label,*button1;
GtkWidget *table, **position_icons, *position_table,*sep,*button;
GdkColor *colors;
gint n_colors;
Gtk_Osd_Pos curr_pos;
Gtk_Osd_Align curr_align;
GSList *group = NULL;
gtk_box_pack_start (GTK_BOX (vbox),(gpointer )create_header(_("XOSD")), FALSE, FALSE, 0);
table = gtk_table_new (7,2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 12);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
// Font selector.
label = gtk_label_new (_("Font:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
if(sven->osd->font!=NULL)
font_entry = gtk_font_button_new_with_font (sven->osd->font);
else
font_entry = gtk_font_button_new_with_font ("Sans 18");
gtk_table_attach (GTK_TABLE (table), font_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
//Colour Selector
label = gtk_label_new (_("Colour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_color_selection_palette_from_string (sven->osd->color,&colors,&n_colors);
colour_entry = gtk_color_button_new_with_color (colors);
gtk_table_attach (GTK_TABLE (table), colour_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
//Timeout
label = gtk_label_new (_("Timeout:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
timeout_obj = gtk_adjustment_new (sven->osd->timeout, -1, 60, 1, 1, 1);
timeout_spin = gtk_spin_button_new (GTK_ADJUSTMENT (timeout_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (timeout_spin),
(gfloat) sven->osd->timeout);
gtk_box_pack_start (GTK_BOX (hbox), timeout_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("seconds"));
gtk_misc_set_alignment (GTK_MISC (unit_label),0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Position
label = gtk_label_new (_("Position:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3,4,GTK_FILL, GTK_FILL, 0, 0);
position_icons = position_icons_new ();
position_table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (position_table), 6);
gtk_table_set_col_spacings (GTK_TABLE (position_table), 6);
gtk_table_attach (GTK_TABLE (table), position_table, 1, 2, 3,4,GTK_FILL, GTK_FILL, 0, 0);
curr_pos = GTK_OSD_TOP;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,curr_pos, curr_pos + 1, GTK_FILL, GTK_FILL, 0, 0);
}
curr_pos = GTK_OSD_MIDDLE;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,1, 2, GTK_FILL, GTK_FILL, 0, 0);
}
curr_pos = GTK_OSD_BOTTOM;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,2, 3, GTK_FILL, GTK_FILL, 0, 0);
}
// Vertical Offset
label = gtk_label_new (_("Vertical Offset:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4,5,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 4, 5,GTK_FILL, GTK_FILL, 0, 0);
offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1);
offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (offset_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (offset_spin), sven->osd->voffset);
gtk_box_pack_start (GTK_BOX (hbox), offset_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("pixels"));
gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Horizontal Offset
label = gtk_label_new (_("Horizontal Offset:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5,6,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 5,6,GTK_FILL, GTK_FILL, 0, 0);
h_offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1);
h_offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (h_offset_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (h_offset_spin), sven->osd->hoffset);
gtk_box_pack_start (GTK_BOX (hbox), h_offset_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("pixels"));
gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Background color
label = gtk_label_new (_("Background Color:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6,7,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 6,7,GTK_FILL, GTK_FILL, 0, 0);
bg_color_enable=gtk_check_button_new_with_mnemonic (_("Enable"));
gtk_box_pack_start (GTK_BOX (hbox), bg_color_enable, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bg_color_enable), sven->osd->bg_color_on);
gtk_color_selection_palette_from_string (sven->osd->bg_color,&colors,&n_colors);
bg_color = gtk_color_button_new_with_color (colors);
gtk_box_pack_start (GTK_BOX (hbox), bg_color, FALSE, FALSE, 0);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 10);
hbox1 = gtk_hbox_new (TRUE, 10);
gtk_widget_show (hbox1);
enable_xosd = gtk_check_button_new_with_mnemonic (_("Enable XOSD"));
gtk_widget_show (enable_xosd);
gtk_box_pack_start (GTK_BOX (hbox1), enable_xosd, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_xosd), sven->osd->osd_on);
enable_frame = gtk_check_button_new_with_mnemonic (_("Enable Frame"));
gtk_widget_show (enable_frame);
gtk_box_pack_start (GTK_BOX (hbox1), enable_frame, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_frame), sven->osd->debug_frame);
enable_shadow = gtk_check_button_new_with_mnemonic (_("Enable Shadow"));
gtk_widget_show (enable_shadow);
gtk_box_pack_start (GTK_BOX (hbox1), enable_shadow, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_shadow), sven->osd->drop_shadow);
gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 0);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE,5);
button1 = gtk_button_new_with_mnemonic (_("Test OSD"));
gtk_widget_show (button1);
gtk_box_pack_start (GTK_BOX (vbox), button1, FALSE, FALSE, 5);
g_signal_connect(button1, "clicked", G_CALLBACK(test_osd),sven);
gtk_widget_show_all (vbox);
}
GtkWidget *gui_build_dialog_gtk_table(GSList * list, gint cols, gboolean use_progress)
{
GSList *listtmp = list;
GtkWidget *adv_vbox = NULL;
GtkWidget *adv_expander = NULL;
gint ielements = g_slist_position(list, g_slist_last(list));
gint rows = ((ielements + 1) / cols) + use_progress;
GtkWidget *tab = gtk_table_new(rows, cols, FALSE);
gint actC = 0, actR = 0;
GtkWidget *to_grab_focus = NULL;
gboolean need_advanced = FALSE;
gtk_container_set_border_width(GTK_CONTAINER(tab), 15);
/* remember to free adv_expander */
adv_vbox = gtk_vbox_new(FALSE, 5);
while (listtmp)
{
GGaduKeyValue *kv = (GGaduKeyValue *) listtmp->data;
GtkWidget *entry = NULL;
gboolean need_label = TRUE;
gboolean is_advanced = FALSE;
switch (kv->type)
{
case VAR_STR:
entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(entry), g_strdup(kv->value));
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
break;
case VAR_INT:
{
entry = gtk_spin_button_new_with_range(0, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_INT_WITH_NEGATIVE:
{
entry = gtk_spin_button_new_with_range(-999999999, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_BOOL:
need_label = FALSE;
entry = gtk_check_button_new_with_mnemonic(kv->description);
if (kv->value)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entry), TRUE);
break;
case VAR_FILE_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-open");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_filename), txt_entry);
}
break;
case VAR_FONT_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-select-font");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_fontchooser), txt_entry);
}
break;
case VAR_COLOUR_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
GdkColor color;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
gdk_color_parse(gtk_entry_get_text(GTK_ENTRY(txt_entry)), &color);
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_color_button_new_with_color(&color);
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect(G_OBJECT(button_entry), "color-set", G_CALLBACK(gui_dialog_show_colorchooser), txt_entry);
}
break;
case VAR_IMG:
need_label = FALSE;
entry = gtk_image_new_from_file(kv->value);
gtk_table_set_homogeneous(GTK_TABLE(tab), FALSE);
break;
case VAR_LIST:
{
GSList *selected = g_slist_nth((GSList *) kv->value, 0);
GSList *restlist = g_slist_nth((GSList *) kv->value, 1);
gint selected_index = 0;
gint i = -1;
entry = gtk_combo_box_new_text();
g_object_set_data(G_OBJECT(entry), "options-list", restlist);
while (restlist)
{
i++;
if (!g_strcasecmp(selected->data, restlist->data))
{
selected_index = i;
print_debug("############# %d %s", selected_index, selected->data);
}
gtk_combo_box_append_text(GTK_COMBO_BOX(entry), g_strdup(restlist->data));
restlist = restlist->next;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(entry), selected_index);
}
break;
default:
break;
}
if ((kv->flag & VAR_FLAG_SENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), TRUE);
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE);
}
if ((kv->flag & VAR_FLAG_INSENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
}
if ((kv->flag & VAR_FLAG_PASSWORD) != 0)
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
if ((kv->flag & VAR_FLAG_FOCUS) != 0)
to_grab_focus = entry;
kv->user_data = (gpointer) entry;
if ((kv->flag & VAR_FLAG_ADVANCED) != 0)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
GtkWidget *align;
GtkWidget *label;
need_advanced = TRUE;
is_advanced = TRUE;
gtk_box_pack_end_defaults(GTK_BOX(hbox), entry);
if (need_label)
{
align = gtk_alignment_new(0, 0.5, 0, 0);
label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_end_defaults(GTK_BOX(hbox), align);
}
gtk_box_pack_start_defaults(GTK_BOX(adv_vbox), hbox);
}
if (need_label && !is_advanced)
{
GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0);
GtkWidget *label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_table_attach_defaults(GTK_TABLE(tab), align, 0, 1, actR, actR + 1);
if (entry)
gtk_table_attach_defaults(GTK_TABLE(tab), entry, 1, 2, actR, actR + 1);
}
else if (!is_advanced)
{
gtk_table_attach(GTK_TABLE(tab), entry, actC, actC + 2, actR, actR + 1, GTK_FILL, GTK_SHRINK, 0, 0);
}
if (!is_advanced)
{
if ((actC + 1) < cols)
actC++;
else
{
actC = 0;
actR++;
}
}
listtmp = listtmp->next;
}
if (need_advanced)
{
adv_expander = gtk_expander_new_with_mnemonic(_("_More options"));
gtk_container_add(GTK_CONTAINER(adv_expander), adv_vbox);
gtk_table_attach_defaults(GTK_TABLE(tab), adv_expander, 0, rows, actR, actR + 1);
}
else
{
gtk_widget_destroy(adv_vbox);
}
/* progress stuff */
if (use_progress)
{
GtkWidget *progress = gtk_progress_bar_new();
gtk_table_attach_defaults(GTK_TABLE(tab), progress, 0, rows, actR, actR + 1);
}
if (to_grab_focus)
gtk_widget_grab_focus(GTK_WIDGET(to_grab_focus));
return tab;
}
void termit_preferences_dialog(struct TermitTab *pTab)
{
// store font_name, foreground, background
struct TermitDlgHelper* hlp = termit_dlg_helper_new(pTab);
GtkStockItem item = {};
gtk_stock_lookup(GTK_STOCK_PREFERENCES, &item); // may be memory leak inside
GtkWidget* dialog = gtk_dialog_new_with_buttons(item.label,
GTK_WINDOW_TOPLEVEL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dialog), "key-press-event", G_CALLBACK(dlg_key_press), dialog);
GtkWidget* dlg_table = gtk_table_new(5, 2, FALSE);
#define TERMIT_PREFERENCE_ROW(pref_name, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), gtk_label_new(pref_name), 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
#define TERMIT_PREFERENCE_ROW2(pref_widget, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), pref_widget, 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
gboolean apply_to_all_tabs_flag = FALSE;
GtkWidget* entry_title = gtk_entry_new();
guint row = 0;
{ // tab title
gtk_entry_set_text(GTK_ENTRY(entry_title), hlp->tab_title);
TERMIT_PREFERENCE_ROW(_("Title"), entry_title);
}
// font selection
GtkWidget* btn_font = gtk_font_button_new_with_font(pTab->style.font_name);
g_signal_connect(btn_font, "font-set", G_CALLBACK(dlg_set_font), pTab);
TERMIT_PREFERENCE_ROW(_("Font"), btn_font);
// foreground
GtkWidget* btn_foreground = (pTab->style.foreground_color)
? gtk_color_button_new_with_color(pTab->style.foreground_color)
: gtk_color_button_new();
g_signal_connect(btn_foreground, "color-set", G_CALLBACK(dlg_set_foreground), pTab);
TERMIT_PREFERENCE_ROW(_("Foreground"), btn_foreground);
// background
GtkWidget* btn_background = (pTab->style.background_color)
? gtk_color_button_new_with_color(pTab->style.background_color)
: gtk_color_button_new();
g_signal_connect(btn_background, "color-set", G_CALLBACK(dlg_set_background), pTab);
TERMIT_PREFERENCE_ROW(_("Background"), btn_background);
// background image
GtkWidget* btn_image_file = gtk_file_chooser_button_new(pTab->style.image_file,
GTK_FILE_CHOOSER_ACTION_OPEN);
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("images"));
gtk_file_filter_add_mime_type(filter, "image/*");
if (pTab->style.image_file) {
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(btn_image_file), pTab->style.image_file);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(btn_image_file), filter);
g_signal_connect(btn_image_file, "file-set", G_CALLBACK(dlg_set_image_file), pTab);
g_signal_connect(btn_image_file, "key-press-event", G_CALLBACK(dlg_clear_image_file), pTab);
GtkWidget* btn_switch_image_file = gtk_check_button_new_with_label(_("Background image"));
if (pTab->style.image_file) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_switch_image_file), TRUE);
}
/*g_signal_connect(btn_switch_image_file, "toggled", G_CALLBACK(dlg_switch_image_file), btn_image_file);*/
/*TERMIT_PREFERENCE_ROW2(btn_switch_image_file, btn_image_file);*/
TERMIT_PREFERENCE_ROW(_("Image"), btn_image_file);
// transparency
GtkWidget* scale_transparency = gtk_spin_button_new_with_range(0, 1, 0.05);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(scale_transparency), pTab->style.transparency);
g_signal_connect(scale_transparency, "value-changed", G_CALLBACK(dlg_set_transparency), pTab);
TERMIT_PREFERENCE_ROW(_("Transparency"), scale_transparency);
// audible_bell
GtkWidget* audible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(audible_bell), pTab->audible_bell);
g_signal_connect(audible_bell, "toggled", G_CALLBACK(dlg_set_audible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Audible bell"), audible_bell);
// visible_bell
GtkWidget* visible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(visible_bell), pTab->visible_bell);
g_signal_connect(visible_bell, "toggled", G_CALLBACK(dlg_set_visible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Visible bell"), visible_bell);
// apply to al tabs
GtkWidget* btn_apply_to_all_tabs = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_apply_to_all_tabs), FALSE);
g_signal_connect(btn_apply_to_all_tabs, "toggled", G_CALLBACK(dlg_set_apply_to_all_tabs), &apply_to_all_tabs_flag);
TERMIT_PREFERENCE_ROW(_("Apply to all tabs"), btn_apply_to_all_tabs);
GtkWidget* btn_restore = gtk_button_new_from_stock(GTK_STOCK_REVERT_TO_SAVED);
g_signal_connect(G_OBJECT(btn_restore), "clicked", G_CALLBACK(dlg_restore_defaults), hlp);
gtk_table_attach(GTK_TABLE(dlg_table), btn_restore, 1, 2, row, row + 1, 0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), dlg_table);
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
dlg_set_tab_default_values(pTab, hlp);
} else {
if (apply_to_all_tabs_flag) {
gint page_num = gtk_notebook_get_n_pages(GTK_NOTEBOOK(termit.notebook));
gint i=0;
for (; i<page_num; ++i) {
TERMIT_GET_TAB_BY_INDEX(pTab, i, continue);
dlg_set_font(GTK_FONT_BUTTON(btn_font), pTab);
dlg_set_foreground(GTK_COLOR_BUTTON(btn_foreground), pTab);
dlg_set_background(GTK_COLOR_BUTTON(btn_background), pTab);
dlg_set_transparency(GTK_SPIN_BUTTON(scale_transparency), pTab);
dlg_set_image_file(GTK_FILE_CHOOSER_BUTTON(btn_image_file), pTab);
dlg_set_audible_bell(GTK_TOGGLE_BUTTON(audible_bell), pTab);
dlg_set_visible_bell(GTK_TOGGLE_BUTTON(visible_bell), pTab);
}
}
// insane title flag
if (pTab->title ||
(!pTab->title &&
strcmp(gtk_label_get_text(GTK_LABEL(pTab->tab_name)),
gtk_entry_get_text(GTK_ENTRY(entry_title))) != 0)) {
termit_tab_set_title(pTab, gtk_entry_get_text(GTK_ENTRY(entry_title)));
}
}
termit_dlg_helper_free(hlp);
gtk_widget_destroy(dialog);
}
int load_host_buttons(topview * t, Agraph_t * g, glCompSet * s)
{
GtkLayout *layout;
int btncount = 0;
int i = 0;
char *str;
char hostbtncaption[50];
char hostbtnregex[50];
char hostbtncolorR[50];
char hostbtncolorG[50];
char hostbtncolorB[50];
char hostbtncolorA[50];
int X = 10;
int Y = 25;
GdkColor color;
glCompPanel *p;
glCompButton *b;
layout =
(GtkLayout *) glade_xml_get_widget(xml, "frmHostSelectionFixed");
str = '\0';
str = agget(g, "hostbtncount");
if (str)
btncount = atoi(str);
// Graph [hostbtncaption1="AT&T",hostbtnregex1="*.ATT*",hostbtncolorR1="1",hostbtncolorG1="0",hostbtncolorB1="0",hostbtncolorA1="1"];
t->TopviewData->hostregex = N_GNEW(btncount, char *);
t->TopviewData->gtkhostbtn = N_GNEW(btncount, GtkButton *);
t->TopviewData->gtkhostcolor = N_GNEW(btncount, GtkColorButton *);
t->TopviewData->gtkhostbtncount = btncount;
if (btncount > 0) {
p = glCompPanelNew(25, 75, 165, 400);
p->data = 2; //data panel
p->color.R = (float) 0.80;
p->color.B = (float) 0.2;
glCompSetAddPanel(s, p);
} else
return 0;
for (i = 0; i < btncount; i++) {
sprintf(hostbtncaption, "hostbtncaption%i", i);
sprintf(hostbtnregex, "hostbtnregex%i", i);
sprintf(hostbtncolorR, "hostbtncolorR%i", i);
sprintf(hostbtncolorG, "hostbtncolorG%i", i);
sprintf(hostbtncolorB, "hostbtncolorB%i", i);
sprintf(hostbtncolorA, "hostbtncolorA%i", i);
agget(g, hostbtncaption),
agget(g, hostbtnregex),
agget(g, hostbtncolorR),
agget(g, hostbtncolorG),
agget(g, hostbtncolorB), agget(g, hostbtncolorA);
t->TopviewData->hostregex[i] = agget(g, hostbtnregex);
b = glCompButtonNew((GLfloat) 5,
(GLfloat) 7 + ((GLfloat) i +
(GLfloat) 1) * (GLfloat) 36,
(GLfloat) 150, (GLfloat) 35, agget(g,
hostbtncaption),
'\0', 0, 0);
b->color.R = (float) atof(agget(g, hostbtncolorR));
b->color.G = (float) atof(agget(g, hostbtncolorG));
b->color.B = (float) atof(agget(g, hostbtncolorB));
b->color.A = (float) 1;
b->panel = p;
b->groupid = -1;
b->callbackfunc = glhost_button_clicked_Slot;
b->data = i;
glCompSetAddButton(s, b);
t->TopviewData->gtkhostbtn[i] = (GtkButton *)
gtk_button_new_with_label(agget(g, hostbtncaption));
g_signal_connect((gpointer) t->TopviewData->gtkhostbtn[i],
"clicked", G_CALLBACK(host_button_clicked_Slot),
(gpointer) i);
color.blue = 65535 * atoi(agget(g, hostbtncolorB));
color.red = 65535 * atoi(agget(g, hostbtncolorR));
color.green = 65535 * atoi(agget(g, hostbtncolorG));
t->TopviewData->gtkhostcolor[i] =
(GtkColorButton *) gtk_color_button_new_with_color(&color);
gtk_color_button_set_alpha((GtkColorButton *) t->TopviewData->
gtkhostbtn[i],
65535 * atoi(agget(g, hostbtncolorA)));
gtk_layout_put(layout, (GtkWidget *) t->TopviewData->gtkhostbtn[i],
X, Y);
gtk_widget_set_size_request((GtkWidget *) t->TopviewData->
gtkhostbtn[i], 200, 35);
gtk_layout_put(layout,
(GtkWidget *) t->TopviewData->gtkhostcolor[i],
X + 225, Y);
gtk_widget_set_size_request((GtkWidget *) t->TopviewData->
gtkhostcolor[i], 40, 35);
gtk_widget_show((GtkWidget *) t->TopviewData->gtkhostbtn[i]);
gtk_widget_show((GtkWidget *) t->TopviewData->gtkhostcolor[i]);
Y = Y + 40;
t->TopviewData->hostactive[i] = 0;
}
p->height = (GLfloat) 15 + (GLfloat) (btncount + 1) * (GLfloat) 36;
for (i = 0; i < btncount; i++) {
prepare_nodes_for_groups(t, t->TopviewData, i);
}
return 1;
}
static void termomix_color_dialog (GtkWidget *widget, void *data) {
GtkWidget *color_dialog;
GtkWidget *label1, *label2;
GtkWidget *buttonfore, *buttonback;
GtkWidget *hbox_fore, *hbox_back;
gint response;
guint16 backalpha;
color_dialog=gtk_dialog_new_with_buttons(gettext("Select color"),
GTK_WINDOW(termomix.main_window), GTK_DIALOG_MODAL, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT, GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(color_dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_modal(GTK_WINDOW(color_dialog), TRUE);
/* Set style */
gchar *css = g_strdup_printf (HIG_DIALOG_CSS);
gtk_css_provider_load_from_data(termomix.provider, css, -1, NULL);
GtkStyleContext *context = gtk_widget_get_style_context (color_dialog);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER(termomix.provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_free(css);
hbox_fore=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
hbox_back=gtk_box_new(FALSE, 12);
label1=gtk_label_new(gettext("Select foreground color:"));
label2=gtk_label_new(gettext("Select background color:"));
buttonfore=gtk_color_button_new_with_color(&termomix.forecolor);
buttonback=gtk_color_button_new_with_color(&termomix.backcolor);
/* When the times comes (gtk-3.4) */
// buttonfore=gtk_color_button_new_with_rgba(&termomix.forecolor);
// buttonback=gtk_color_button_new_with_rgba(&termomix.backcolor);*/
/* This rounding sucks...*/
backalpha = roundf((termomix.opacity_level*65535)/99);
if (termomix.has_rgba) {
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(buttonback), TRUE);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(buttonback), backalpha);
}
gtk_box_pack_start(GTK_BOX(hbox_fore), label1, FALSE, FALSE, 12);
gtk_box_pack_end(GTK_BOX(hbox_fore), buttonfore, FALSE, FALSE, 12);
gtk_box_pack_start(GTK_BOX(hbox_back), label2, FALSE, FALSE, 12);
gtk_box_pack_end(GTK_BOX(hbox_back), buttonback, FALSE, FALSE, 12);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(color_dialog))), hbox_fore, FALSE, FALSE, 6);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(color_dialog))), hbox_back, FALSE, FALSE, 6);
gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(color_dialog)));
response=gtk_dialog_run(GTK_DIALOG(color_dialog));
if (response==GTK_RESPONSE_ACCEPT) {
/* TODO: Remove deprecated get_color */
//gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(color_dialog), &termomix.forecolor);
//gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(color_dialog), &termomix.backcolor);
gtk_color_button_get_color(GTK_COLOR_BUTTON(buttonfore), &termomix.forecolor);
gtk_color_button_get_color(GTK_COLOR_BUTTON(buttonback), &termomix.backcolor);
if (termomix.has_rgba) {
backalpha = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(buttonback));
}
if (termomix.has_rgba) {
vte_terminal_set_opacity(VTE_TERMINAL (termomix.term->vte), backalpha);
}
vte_terminal_set_colors(VTE_TERMINAL(termomix.term->vte), &termomix.forecolor,
&termomix.backcolor, termomix.palette, PALETTE_SIZE);
gchar *cfgtmp;
cfgtmp = g_strdup_printf("#%02x%02x%02x", termomix.forecolor.red >>8,
termomix.forecolor.green>>8, termomix.forecolor.blue>>8);
termomix_set_config_string("forecolor", cfgtmp);
g_free(cfgtmp);
cfgtmp = g_strdup_printf("#%02x%02x%02x", termomix.backcolor.red >>8,
termomix.backcolor.green>>8, termomix.backcolor.blue>>8);
termomix_set_config_string("backcolor", cfgtmp);
g_free(cfgtmp);
termomix.opacity_level= roundf((backalpha*99)/65535); /* Opacity value is between 0 and 99 */
termomix_set_config_integer("opacity_level", termomix.opacity_level);
}
void refreshConnectDialog()
{
/* Create the GtkTable */
static GtkWidget *rootTable = NULL;
if(rootTable != NULL) {
gtk_widget_destroy(rootTable);
}
rootTable = gtk_table_new(
g_robotManager->numEntries()*3,
10,
FALSE);
/* For each Mobot entry, we need to compose a set of child widgets and attach
* them to the right places on the grid */
int32_t i; // i is passed to signal handlers, so may be at most 32 bits
GtkWidget *w;
for(i = 0; i < g_robotManager->numEntries(); i++) {
/* Make a new label for the entry */
w = gtk_label_new(g_robotManager->getEntry(i));
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
0, 1, //columns
i*3, (i*3)+2, //rows
GTK_FILL, GTK_FILL,
2, 2);
/* Add connect/connecting/disconnect button */
recordMobot_t* mobot;
if(mobot = g_robotManager->getMobotIndex(i)) {
switch(mobot->connectStatus) {
case RMOBOT_NOT_CONNECTED:
w = gtk_button_new_with_label("Connect");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
2, 3,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
/* Attach the connect/disconnect button signal handler */
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_Connect_clicked), GINT_TO_POINTER(i));
/* Add an image denoting connection status for each one */
w = gtk_image_new_from_stock(GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
1, 2,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
break;
case RMOBOT_CONNECTING:
w = gtk_button_new_with_label("Connecting...");
gtk_widget_show(w);
gtk_widget_set_sensitive(w, FALSE);
gtk_table_attach( GTK_TABLE(rootTable),
w,
2, 3,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
/* Add an image denoting connection status for each one */
w = gtk_image_new_from_stock(GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
1, 2,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
break;
case RMOBOT_CONNECTED:
w = gtk_button_new_with_label("Disconnect");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
2, 3,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
/* Attach the connect/disconnect button signal handler */
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_Disconnect_clicked), GINT_TO_POINTER(i));
/* Add an image denoting connection status for each one */
w = gtk_image_new_from_stock(GTK_STOCK_YES, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
1, 2,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
break;
default:
w = gtk_button_new_with_label("Meh?");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
2, 3,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
break;
}
} else {
w = gtk_button_new_with_label("Connect");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
2, 3,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
/* Attach the connect/disconnect button signal handler */
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_Connect_clicked), GINT_TO_POINTER(i));
/* Add an image denoting connection status for each one */
w = gtk_image_new_from_stock(GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
1, 2,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
}
/* Add remove button */
w = gtk_button_new_with_label("Remove");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
3, 4,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_Remove_clicked), GINT_TO_POINTER(i));
/* Add move-up button */
w = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
4, 5,
i*3, (i*3)+1,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_MoveUp_clicked), GINT_TO_POINTER(i));
/* Add move-down button */
w = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
4, 5,
(i*3)+1, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_MoveDown_clicked), GINT_TO_POINTER(i));
/* Maybe add a color and beep buttons */
int form;
if(
(g_robotManager->getMobotIndex(i) != NULL ) &&
(g_robotManager->getMobotIndex(i)->connectStatus == RMOBOT_CONNECTED)
)
{
if(!Mobot_getFormFactor((mobot_t*)g_robotManager->getMobotIndex(i), &form)) {
if(
(form == MOBOTFORM_I) ||
(form == MOBOTFORM_L) ||
(form == MOBOTFORM_T)
)
{
int r, g, b;
int _r, _g, _b;
char buf[16];
if(g_robotManager->getMobotIndex(i)->dirty) {
if(!Mobot_getColorRGB((mobot_t*)g_robotManager->getMobotIndex(i), &r, &g, &b)) {
g_robotManager->getMobotIndex(i)->rgb[0] = r;
g_robotManager->getMobotIndex(i)->rgb[1] = g;
g_robotManager->getMobotIndex(i)->rgb[2] = b;
sprintf(buf, "#%02X%02X%02X", r, g, b);
GdkColor color;
gdk_color_parse(buf, &color);
w = gtk_color_button_new_with_color(&color);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
5, 6,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(
G_OBJECT(w),
"color-set",
G_CALLBACK(on_colorDialog_color_set),
(void*)g_robotManager->getMobotIndex(i)
);
}
} else {
sprintf(buf, "#%02X%02X%02X",
g_robotManager->getMobotIndex(i)->rgb[0],
g_robotManager->getMobotIndex(i)->rgb[1],
g_robotManager->getMobotIndex(i)->rgb[2]);
GdkColor color;
gdk_color_parse(buf, &color);
w = gtk_color_button_new_with_color(&color);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
5, 6,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(
G_OBJECT(w),
"color-set",
G_CALLBACK(on_colorDialog_color_set),
(void*)g_robotManager->getMobotIndex(i)
);
}
w = gtk_button_new_with_label("Beep!");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
6, 7,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(
G_OBJECT(w),
"pressed",
G_CALLBACK(on_beep_button_pressed),
(void*)g_robotManager->getMobotIndex(i)
);
g_signal_connect(
G_OBJECT(w),
"released",
G_CALLBACK(on_beep_button_released),
(void*)g_robotManager->getMobotIndex(i)
);
}
}
}
/* Maybe add an "Upgrade Firmware" button */
if( (g_robotManager->getMobotIndex(i) != NULL) &&
(g_robotManager->getMobotIndex(i)->connectStatus == RMOBOT_CONNECTED) &&
(g_robotManager->getMobotIndex(i)->firmwareVersion < Mobot_protocolVersion()) )
{
int form=0;
Mobot_getFormFactor((mobot_t*)g_robotManager->getMobotIndex(i), &form);
GdkColor color;
gdk_color_parse("yellow", &color);
w = gtk_button_new_with_label("Upgrade\nFirmware");
gtk_widget_modify_bg(w, GTK_STATE_NORMAL, &color);
gdk_color_parse("#FFFF22", &color);
gtk_widget_modify_bg(w, GTK_STATE_PRELIGHT, &color);
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
7, 8,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_updateFirmware_clicked), GINT_TO_POINTER(i));
}
/* Add an "Info" button */
if( (g_robotManager->getMobotIndex(i) != NULL) &&
(g_robotManager->getMobotIndex(i)->connectStatus == RMOBOT_CONNECTED)
)
{
w = gtk_button_new_with_label("Info");
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
8, 9,
i*3, (i*3)+2,
GTK_FILL, GTK_FILL,
2, 2);
g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(on_button_robotInfo_clicked), GINT_TO_POINTER(i));
}
/* Add a horizontal separator */
w = gtk_hseparator_new();
gtk_widget_show(w);
gtk_table_attach( GTK_TABLE(rootTable),
w,
0, 9,
i*3+2, (i*3)+3,
GTK_FILL, GTK_FILL,
2, 2);
}
GtkRequisition sizeRequest;
gtk_widget_size_request(rootTable, &sizeRequest);
GtkWidget *layout = GTK_WIDGET(gtk_builder_get_object(g_builder, "layout_connectDialog"));
gtk_layout_set_size(GTK_LAYOUT(layout), sizeRequest.width, sizeRequest.height);
gtk_layout_put(GTK_LAYOUT(layout), rootTable, 0, 0);
gtk_widget_show(rootTable);
/* Refresh the list stores, etc. */
static GtkListStore* liststore_available = GTK_LIST_STORE(
gtk_builder_get_object(g_builder, "liststore_availableRobots"));
static GtkListStore* liststore_connected = GTK_LIST_STORE(
gtk_builder_get_object(g_builder, "liststore_connectedRobots"));
g_dndConnect = false;
/* Clear the widgets */
gtk_list_store_clear(liststore_available);
gtk_list_store_clear(liststore_connected);
/* Populate the widgets */
GtkTreeIter iter;
GtkTreeIter connectedIter;
for(i = 0; i < g_robotManager->numEntries(); i++) {
gtk_list_store_append(liststore_available, &iter);
if(
(g_robotManager->getMobotIndex(i) != NULL) &&
(g_robotManager->getMobotIndex(i)->connectStatus == RMOBOT_CONNECTED)
) {
/* Add it to the liststore of connected bots */
gtk_list_store_append(liststore_connected, &connectedIter);
gtk_list_store_set(liststore_connected, &connectedIter,
0,
g_robotManager->getEntry(i),
-1);
/* Set the blinky light icon to green */
gtk_list_store_set(liststore_available, &iter,
0,
g_robotManager->getEntry(i),
1, GTK_STOCK_YES,
-1 );
/* Set the update progress bar data */
//printf("%d:%d\n", g_robotManager->getMobotIndex(i)->firmwareVersion, Mobot_protocolVersion());
if(g_robotManager->getMobotIndex(i)->firmwareVersion < Mobot_protocolVersion()) {
gtk_list_store_set(liststore_available, &iter,
2, TRUE, 3, 0, -1);
} else {
gtk_list_store_set(liststore_available, &iter,
2, FALSE, 3, 0, -1);
}
} else {
gtk_list_store_set(liststore_available, &iter,
0,
g_robotManager->getEntry(i),
1, GTK_STOCK_DISCONNECT,
-1 );
}
}
/* If there is only one entry, set that entry as active in the "Control
* Robot" dialog. */
/*
if(g_robotManager->numConnected() == 1) {
GtkWidget *w;
w = GTK_WIDGET(gtk_builder_get_object(g_builder, "combobox_connectedRobots"));
gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0);
}
*/
g_dndConnect = true;
}
GtkWidget * build_tgroup(MtxTickGroup *tgroup, gint index)
{
/* MUCH faster that the ui way unfortunately */
GtkWidget *notebook = NULL;
GtkWidget *table = NULL;
GtkWidget *subtable = NULL;
GtkWidget *widget = NULL;
GtkWidget *x_spin = NULL;
GtkWidget *y_spin = NULL;
GtkWidget *hbox = NULL;
GtkWidget *img = NULL;
GtkWidget *label = NULL;
GtkWidget *start = NULL;
GtkWidget *sweep = NULL;
GtkWidget *low = NULL;
GtkWidget *high = NULL;
gchar * tmpbuf = NULL;
table = gtk_table_new(2,2,FALSE);
/* Close button */
widget = gtk_button_new();
img = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(widget),img);
OBJ_SET((widget),"tgroup_index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"clicked", G_CALLBACK(remove_tgroup),NULL);
gtk_table_attach(GTK_TABLE(table),widget,0,1,0,4,0,0,0,0);
notebook = gtk_notebook_new();
gtk_table_attach(GTK_TABLE(table),notebook,1,2,0,1,GTK_EXPAND|GTK_FILL,0,0,0);
/* Text/Color Tab */
subtable = gtk_table_new(2,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Text & Color");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Text:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,2,GTK_FILL,GTK_EXPAND|GTK_FILL,0,0);
widget = gtk_entry_new();
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_TEXT));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
gtk_entry_set_width_chars(GTK_ENTRY(widget),12);
gtk_entry_set_text(GTK_ENTRY(widget),tgroup->text);
g_signal_connect(G_OBJECT(widget),"changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,2,GTK_EXPAND|GTK_FILL,GTK_EXPAND|GTK_FILL,0,0);
widget = gtk_label_new("Day");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,0,GTK_FILL,0,0);
widget = gtk_color_button_new_with_color(&tgroup->text_color[MTX_DAY]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_TEXT_COLOR_DAY));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
widget = gtk_label_new("Night");
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,0,GTK_FILL,0,0);
widget = gtk_color_button_new_with_color(&tgroup->text_color[MTX_NITE]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_TEXT_COLOR_NITE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,1,2,GTK_FILL,GTK_EXPAND,0,0);
/* Font Tab */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Font");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Font:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,GTK_EXPAND,0,0);
widget = gtk_font_button_new();
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_FONT));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
tmpbuf = g_strdup_printf("%s 12",tgroup->font);
gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget),tmpbuf);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(widget),FALSE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(widget),FALSE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(widget),FALSE);
g_free(tmpbuf);
g_signal_connect(G_OBJECT(widget),"font_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND|GTK_FILL,GTK_EXPAND,0,0);
widget = gtk_label_new("Font\nScale");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.001,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_FONT_SCALE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->font_scale, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,0,GTK_EXPAND,0,0);
widget = gtk_label_new("Text\nInset");
gtk_table_attach(GTK_TABLE(subtable),widget,4,5,0,1,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.001,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_TEXT_INSET));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->text_inset, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,5,6,0,1,0,GTK_EXPAND,0,0);
/* Major Ticks Tab */
subtable = gtk_table_new(2,6,FALSE);
/*gtk_table_set_col_spacings(GTK_TABLE(subtable),5);*/
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),"<b>Major</b> Ticks");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
/* Labels */
widget = gtk_label_new("Total Ticks");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Length");
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Width");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Inset");
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Day");
gtk_table_attach(GTK_TABLE(subtable),widget,4,5,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Night");
gtk_table_attach(GTK_TABLE(subtable),widget,5,6,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
/* Spinners */
widget = gtk_spin_button_new_with_range(0.0,100.0,1);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_NUM_MAJ_TICKS));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 1.0, "digits", 0, "numeric", TRUE, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tgroup->num_maj_ticks);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MAJ_TICK_LENGTH));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->maj_tick_length, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MAJ_TICK_WIDTH));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->maj_tick_width, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MAJ_TICK_INSET));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->maj_tick_inset, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,1,2,0,GTK_EXPAND,0,0);
widget = gtk_color_button_new_with_color(&tgroup->maj_tick_color[MTX_DAY]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MAJ_TICK_COLOR_DAY));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,4,5,1,2,GTK_FILL,GTK_EXPAND,0,0);
widget = gtk_color_button_new_with_color(&tgroup->maj_tick_color[MTX_NITE]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MAJ_TICK_COLOR_NITE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,5,6,1,2,GTK_FILL,GTK_EXPAND,0,0);
/* Minor Ticks Tab */
subtable = gtk_table_new(2,6,FALSE);
/*gtk_table_set_col_spacings(GTK_TABLE(subtable),5);*/
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),"<b>Minor</b> Ticks");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
/* Labels */
widget = gtk_label_new("Total Ticks");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Length");
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Width");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Inset");
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Day");
gtk_table_attach(GTK_TABLE(subtable),widget,4,5,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Night");
gtk_table_attach(GTK_TABLE(subtable),widget,5,6,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
/* Spinners */
widget = gtk_spin_button_new_with_range(0.0,100.0,1);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_NUM_MIN_TICKS));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 1.0, "digits", 0, "numeric", TRUE, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tgroup->num_min_ticks);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MIN_TICK_LENGTH));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->min_tick_length, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MIN_TICK_WIDTH));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->min_tick_width, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,1,2,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(0.0,1.0,0.001);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MIN_TICK_INSET));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 0.001, "digits", 3, "numeric", TRUE, "value", tgroup->min_tick_inset, NULL);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,1,2,0,GTK_EXPAND,0,0);
widget = gtk_color_button_new_with_color(&tgroup->min_tick_color[MTX_DAY]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MIN_TICK_COLOR_DAY));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,4,5,1,2,GTK_FILL,GTK_EXPAND,0,0);
widget = gtk_color_button_new_with_color(&tgroup->min_tick_color[MTX_NITE]);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_MIN_TICK_COLOR_NITE));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_signal_connect(G_OBJECT(widget),"color_set",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,5,6,1,2,GTK_FILL,GTK_EXPAND,0,0);
/* Tick Span Tab */
subtable = gtk_table_new(3,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Tick Span");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Angular Span (deg.)");
gtk_table_attach(GTK_TABLE(subtable),widget,0,2,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Span (Gauge Units)");
gtk_table_attach(GTK_TABLE(subtable),widget,2,4,0,1,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Start Angle");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,1,2,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Sweep Angle");
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,1,2,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("Low Point");
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,1,2,GTK_EXPAND,GTK_EXPAND,0,0);
widget = gtk_label_new("High Point");
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,1,2,GTK_EXPAND,GTK_EXPAND,0,0);
/* Span Spinners */
widget = gtk_spin_button_new_with_range(-360.0,360.0,0.1);
start = widget;
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_START_ANGLE));
OBJ_SET(widget,"spin_handler",GINT_TO_POINTER(ADJ_LOW_UNIT_PARTNER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,2,3,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(-360.0,360.0,0.1);
sweep = widget;
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_SWEEP_ANGLE));
OBJ_SET(widget,"spin_handler",GINT_TO_POINTER(ADJ_HIGH_UNIT_PARTNER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,2,3,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(-99999.0,99999.0,0.1);
low = widget;
OBJ_SET(widget,"handler",GINT_TO_POINTER(ADJ_START_ANGLE_PARTNER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(low),"climb-rate", 0.1, "digits", 1, "numeric", TRUE, NULL);
g_signal_connect(G_OBJECT(low),"value-changed",G_CALLBACK(tg_spin_button_handler),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,2,3,2,3,0,GTK_EXPAND,0,0);
widget = gtk_spin_button_new_with_range(-99999.0,99999.0,0.1);
high = widget;
OBJ_SET(widget,"handler",GINT_TO_POINTER(ADJ_SWEEP_ANGLE_PARTNER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(high),"climb-rate", 0.1, "digits", 1, "numeric", TRUE, NULL);
g_signal_connect(G_OBJECT(high),"value-changed",G_CALLBACK(tg_spin_button_handler),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,3,4,2,3,0,GTK_EXPAND,0,0);
/* Start/Sweep <-> Low/High interconnectedness
* This is done like shit and I don't like it..
*/
OBJ_SET(start,"lowpartner",low);
OBJ_SET(start,"highpartner",high);
OBJ_SET(start,"high_angle",sweep);
OBJ_SET(sweep,"highpartner",high);
OBJ_SET(sweep,"low_angle",start);
OBJ_SET(low,"lowpartner",start);
OBJ_SET(high,"highpartner",sweep);
OBJ_SET(high,"start_angle",start);
/* Connect the signals, then set the values to trigger the linked
* spinners to update, THEN enable change handlers, as the gauge
* ALREADY has the info, no need to set it again..
*/
g_signal_connect(G_OBJECT(start),"value-changed",G_CALLBACK(tg_spin_button_handler),NULL);
g_signal_connect(G_OBJECT(sweep),"value-changed",G_CALLBACK(tg_spin_button_handler),NULL);
g_object_set(G_OBJECT(start),"climb-rate", 0.1, "digits", 1, "numeric", TRUE, "value", tgroup->start_angle, NULL);
g_object_set(G_OBJECT(sweep),"climb-rate", 0.1, "digits", 1, "numeric", TRUE, "value", tgroup->sweep_angle, NULL);
g_signal_connect(G_OBJECT(start),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
g_signal_connect(G_OBJECT(sweep),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
/* Layer Tab: Layer */
subtable = gtk_table_new(1,4,FALSE);
gtk_table_set_col_spacings(GTK_TABLE(subtable),5);
label = gtk_label_new("Layer");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),subtable,label);
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),subtable,TRUE,TRUE,GTK_PACK_START);
widget = gtk_label_new("Layer:");
gtk_table_attach(GTK_TABLE(subtable),widget,0,1,0,1,GTK_FILL,0,0,0);
widget = gtk_spin_button_new_with_range(0.0,10.0,1.0);
OBJ_SET(widget,"handler",GINT_TO_POINTER(TG_LAYER));
OBJ_SET(widget,"index",GINT_TO_POINTER(index));
g_object_set(G_OBJECT(widget),"climb-rate", 1.0, "digits", 0, "numeric", TRUE, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(gfloat)tgroup->layer);
g_signal_connect(G_OBJECT(widget),"value-changed",G_CALLBACK(alter_tgroup_data),NULL);
gtk_table_attach(GTK_TABLE(subtable),widget,1,2,0,1,GTK_FILL,0,0,0);
widget = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table),widget,0,2,1,2,GTK_FILL,0,0,0);
return table;
}
static void
create_calendar(void)
{
static CalendarData calendar_data;
GtkWidget *window, *hpaned, *vbox, *rpane, *hbox;
GtkWidget *calendar, *toggle, *scroller, *button;
GtkWidget *frame, *label, *bbox, *align, *details;
GtkSizeGroup *size;
GtkStyle *style;
gchar *font;
gint i;
struct {
gboolean init;
char *label;
} flags[] =
{
{ TRUE, "Show _Heading" },
{ TRUE, "Show Day _Names" },
{ FALSE, "No Month _Change" },
{ TRUE, "Show _Week Numbers" },
{ FALSE, "Week Start _Monday" },
{ TRUE, "Show De_tails" },
};
calendar_data.window = NULL;
calendar_data.font_dialog = NULL;
calendar_data.details_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++)
calendar_data.settings[i] = 0;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkCalendar Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_false),
NULL);
hpaned = gtk_hpaned_new ();
/* Calendar widget */
calendar = lunar_calendar_new ();
calendar_data.calendar_widget = calendar;
frame = create_frame ("<b>Calendar</b>", calendar, 0, 0);
gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, FALSE);
calendar_data.window = calendar;
calendar_set_flags(&calendar_data);
gtk_calendar_mark_day (GTK_CALENDAR (calendar), 19);
g_signal_connect (calendar, "month_changed",
G_CALLBACK (calendar_month_changed),
&calendar_data);
g_signal_connect (calendar, "day_selected",
G_CALLBACK (calendar_day_selected),
&calendar_data);
g_signal_connect (calendar, "day_selected_double_click",
G_CALLBACK (calendar_day_selected_double_click),
&calendar_data);
g_signal_connect (calendar, "prev_month",
G_CALLBACK (calendar_prev_month),
&calendar_data);
g_signal_connect (calendar, "next_month",
G_CALLBACK (calendar_next_month),
&calendar_data);
g_signal_connect (calendar, "prev_year",
G_CALLBACK (calendar_prev_year),
&calendar_data);
g_signal_connect (calendar, "next_year",
G_CALLBACK (calendar_next_year),
&calendar_data);
rpane = gtk_vbox_new (FALSE, DEF_PAD_SMALL);
gtk_paned_pack2 (GTK_PANED (hpaned), rpane, FALSE, FALSE);
/* Build the right font-button */
vbox = gtk_vbox_new(FALSE, DEF_PAD_SMALL);
frame = create_frame ("<b>Options</b>", vbox, 1, 0);
gtk_box_pack_start (GTK_BOX (rpane), frame, FALSE, TRUE, 0);
size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_widget_ensure_style (calendar);
style = gtk_widget_get_style (calendar);
font = pango_font_description_to_string (style->font_desc);
button = gtk_font_button_new_with_font (font);
g_free (font);
g_signal_connect (button, "font-set",
G_CALLBACK(calendar_select_font),
&calendar_data);
label = gtk_label_new_with_mnemonic ("_Font:");
gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size, label);
hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
/* Color button */
GdkColor color;
gdk_color_parse("red", &color);
button = gtk_color_button_new_with_color(&color);
lunar_calendar_set_jieri_color(LUNAR_CALENDAR(calendar), &color);
g_signal_connect (button, "color-set", G_CALLBACK(calendar_select_color), &calendar_data);
label = gtk_label_new_with_mnemonic ("Holiday _Color:");
gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size, label);
hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
/* Build the width entry */
button = gtk_spin_button_new_with_range (0, 127, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (button),
gtk_calendar_get_detail_width_chars (GTK_CALENDAR (calendar)));
g_signal_connect (button, "value-changed",
G_CALLBACK (detail_width_changed),
&calendar_data);
label = gtk_label_new_with_mnemonic ("Details W_idth:");
gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size, label);
hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
/* Build the height entry */
button = gtk_spin_button_new_with_range (0, 127, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (button),
gtk_calendar_get_detail_height_rows (GTK_CALENDAR (calendar)));
g_signal_connect (button, "value-changed",
G_CALLBACK (detail_height_changed),
&calendar_data);
label = gtk_label_new_with_mnemonic ("Details H_eight:");
gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_size_group_add_widget (size, label);
hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
#if 0
/* Build the right details frame */
vbox = gtk_vbox_new(FALSE, DEF_PAD_SMALL);
frame = create_frame ("<b>Details</b>", vbox, 1, 1);
gtk_box_pack_start (GTK_BOX (rpane), frame, FALSE, TRUE, 0);
details = gtk_text_view_new();
calendar_data.details_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (details));
calendar_data.details_changed = g_signal_connect (calendar_data.details_buffer, "changed",
G_CALLBACK (calendar_details_changed),
&calendar_data);
scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scroller), details);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroller),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scroller, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL);
align = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (align), hbox);
gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("Demonstrate _Details");
g_signal_connect_swapped (button,
"clicked",
G_CALLBACK (demonstrate_details),
&calendar_data);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("_Reset Details");
g_signal_connect_swapped (button,
"clicked",
G_CALLBACK (reset_details),
&calendar_data);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
toggle = gtk_check_button_new_with_mnemonic ("_Use Details");
g_signal_connect (toggle, "toggled",
G_CALLBACK(calendar_toggle_details),
&calendar_data);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, TRUE, 0);
#endif
/* Build the Right frame with the flags in */
vbox = gtk_vbox_new(FALSE, 0);
frame = create_expander ("<b>Flags</b>", vbox, 1, 0);
gtk_box_pack_start (GTK_BOX (rpane), frame, TRUE, TRUE, 0);
for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++)
{
toggle = gtk_check_button_new_with_mnemonic(flags[i].label);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, TRUE, 0);
calendar_data.flag_checkboxes[i] = toggle;
g_signal_connect (toggle, "toggled",
G_CALLBACK (calendar_toggle_flag),
&calendar_data);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), flags[i].init);
}
/*
* Build the Signal-event part.
*/
vbox = gtk_vbox_new (TRUE, DEF_PAD_SMALL);
frame = create_frame ("<b>Signal Events</b>", vbox, 1, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.last_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.last_sig, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Previous signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.prev_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev_sig, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Second previous signal:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
calendar_data.prev2_sig = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev2_sig, FALSE, TRUE, 0);
/*
* Glue everything together
*/
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
button = gtk_button_new_with_label ("Close");
g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_add (GTK_CONTAINER (bbox), button);
vbox = gtk_vbox_new (FALSE, DEF_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
//GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_window_set_default_size (GTK_WINDOW (window), 600, 0);
gtk_widget_show_all (window);
}
/*
Create & run dialog setting
*/
void
block_notes_setting_dialog_run (block_notes_core_s *core)
{
GtkWidget *dialog;
GtkWidget *label, *h_box;
GtkWidget *button_colore_widget;
GtkWidget *button_colore_text;
GtkWidget *button_colore_border;
GtkWidget *button_font;
GtkWidget *button_spin_border;
GtkWidget *button_spin_height;
GtkWidget *button_spin_width;
GdkColor gadget;
GdkColor text;
GdkColor border;
FILE *file;
char *data;
int i;
dialog = gtk_dialog_new_with_buttons ("Setting",
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW(dialog), 200, 100);
gtk_window_set_title (GTK_WINDOW(dialog), " Setting ");
gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
/* Set gadget's color */
gadget.red = core->gadget.red;
gadget.green = core->gadget.green;
gadget.blue = core->gadget.blue;
/* Set text's color */
text.red = core->text.red;
text.green = core->text.green;
text.blue = core->text.blue;
/* Set border's color */
border.red = core->border.red;
border.green = core->border.green;
border.blue = core->border.blue;
label = libui_gtk_label_new_with_descriptor ("- Gadget -", "sans bold 8", -1, -1, NULL);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 5);
/* Gadget background */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Background:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_colore_widget = gtk_color_button_new_with_color (&gadget);
gtk_widget_show (button_colore_widget);
gtk_box_pack_start (GTK_BOX(h_box), button_colore_widget, FALSE, FALSE, 10);
gtk_widget_show (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
/* Font */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Text:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_font = gtk_font_button_new_with_font (core->font);
gtk_box_pack_start (GTK_BOX(h_box), button_font, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
/* Font color */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Text:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_colore_text = gtk_color_button_new_with_color (&text);
gtk_box_pack_start (GTK_BOX(h_box), button_colore_text, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
/* Width border */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Width:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_spin_width = gtk_spin_button_new_with_range (100, 300, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(button_spin_width), core->width);
gtk_box_pack_start (GTK_BOX(h_box), button_spin_width, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
/* Height border */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Height:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_spin_height = gtk_spin_button_new_with_range (150.0, 300.0, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(button_spin_height), core->height);
gtk_box_pack_start (GTK_BOX(h_box), button_spin_height, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
label = libui_gtk_label_new_with_descriptor ("- Border -", "sans bold 8", -1, -1, NULL);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 5);
/* Border background */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Background:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_colore_border = gtk_color_button_new_with_color (&border);
gtk_box_pack_start (GTK_BOX(h_box), button_colore_border, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
/* Border transparency */
h_box = gtk_hbox_new (FALSE, 0);
label = libui_gtk_label_new_with_descriptor ("Transparency:", "sans 8", 80, 25, NULL);
gtk_box_pack_start (GTK_BOX(h_box), label, FALSE, FALSE, 10);
button_spin_border = gtk_spin_button_new_with_range (0.0, 1.0, 0.05);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(button_spin_border), core->border_transparency);
gtk_box_pack_start (GTK_BOX(h_box), button_spin_border, FALSE, FALSE, 10);
gtk_widget_show_all (h_box);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), h_box, FALSE, FALSE, 5);
gtk_widget_show_all (GTK_DIALOG(dialog)->vbox);
/* Run it */
gint result = gtk_dialog_run (GTK_DIALOG (dialog));
switch (result)
{
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy (dialog);
break;
case GTK_RESPONSE_CANCEL:
gtk_widget_destroy (dialog);
break;
case GTK_RESPONSE_OK:
/* Read data and save all in the XML conf file */
gtk_color_button_get_color (GTK_COLOR_BUTTON(button_colore_widget), &gadget);
gtk_color_button_get_color (GTK_COLOR_BUTTON(button_colore_text), &text);
gtk_color_button_get_color (GTK_COLOR_BUTTON(button_colore_border), &border);
data = (char *) gtk_font_button_get_font_name (GTK_FONT_BUTTON(button_font));
core->font_pango = pango_font_description_from_string (data);
snprintf (core->font, 30, "%s", pango_font_description_to_string (core->font_pango));
/* Gadget's color */
core->gadget.red = gadget.red;
core->gadget.green = gadget.green;
core->gadget.blue = gadget.blue;
/* Text's color */
core->text.red = text.red;
core->text.green = text.green;
core->text.blue = text.blue;
/* Border's color */
core->border.red = border.red;
core->border.green = border.green;
core->border.blue = border.blue;
core->border_transparency = gtk_spin_button_get_value (GTK_SPIN_BUTTON(button_spin_border));
core->width = gtk_spin_button_get_value (GTK_SPIN_BUTTON(button_spin_width));
core->height = gtk_spin_button_get_value (GTK_SPIN_BUTTON(button_spin_height));
/* Recreate XML_FILE */
block_notes_xml_update_setting (XML_FILE, core);
gtk_widget_destroy (dialog);
break;
}
return;
}
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data )
{
// Perform pre conversion if necessary
VikLayerParamData vlpd = data;
if ( param->convert_to_display )
vlpd = param->convert_to_display ( data );
GtkWidget *rv = NULL;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
if ( param->type == VIK_LAYER_PARAM_COLOR )
rv = gtk_color_button_new_with_color ( &(vlpd.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
if ( param->type == VIK_LAYER_PARAM_BOOLEAN )
{
//rv = gtk_check_button_new_with_label ( //param->title );
rv = gtk_check_button_new ();
if ( vlpd.b )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE );
}
break;
case VIK_LAYER_WIDGET_COMBOBOX:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
/* Build a simple combobox */
gchar **pstr = param->widget_data;
rv = vik_combo_box_text_new ();
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
/* Set the effective default value */
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), vlpd.u );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && !param->extra_widget_data )
{
/* Build a combobox with editable text */
gchar **pstr = param->widget_data;
#if GTK_CHECK_VERSION (2, 24, 0)
rv = gtk_combo_box_text_new_with_entry ();
#else
rv = gtk_combo_box_entry_new_text ();
#endif
if ( vlpd.s )
vik_combo_box_text_append ( rv, vlpd.s );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && param->extra_widget_data)
{
/* Build a combobox with fixed selections without editable text */
gchar **pstr = param->widget_data;
rv = GTK_WIDGET ( vik_combo_box_text_new () );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
{
/* Set the effective default value */
/* In case of value does not exist, set the first value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( strcmp(((const char **)param->extra_widget_data)[i], vlpd.s) == 0 )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP:
/* widget_data and extra_widget_data are GList */
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new ( param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
int nb_elem = g_list_length(param->widget_data);
for ( i = 0; i < nb_elem; i++ )
if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new_static ( (const gchar **) param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits );
}
break;
case VIK_LAYER_WIDGET_ENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_PASSWORD:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE );
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
gtk_widget_set_tooltip_text ( GTK_WIDGET(rv),
_("Take care that this password will be stored clearly in a plain file.") );
}
break;
case VIK_LAYER_WIDGET_FILEENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, GPOINTER_TO_INT(param->widget_data), NULL, NULL);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FOLDERENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, VF_FILTER_NONE, NULL, NULL);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FILELIST:
if ( param->type == VIK_LAYER_PARAM_STRING_LIST )
{
rv = vik_file_list_new ( _(param->title), NULL );
vik_file_list_set_files ( VIK_FILE_LIST(rv), vlpd.sl );
}
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step );
gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits );
gtk_range_set_value ( GTK_RANGE(rv), init_val );
}
case VIK_LAYER_WIDGET_BUTTON:
if ( param->type == VIK_LAYER_PARAM_PTR && param->widget_data ) {
rv = gtk_button_new_with_label ( param->widget_data );
g_signal_connect ( G_OBJECT(rv), "clicked", G_CALLBACK (vlpd.ptr), param->extra_widget_data );
}
break;
default: break;
}
if ( rv && !gtk_widget_get_tooltip_text ( rv ) ) {
if ( param->tooltip )
gtk_widget_set_tooltip_text ( rv, _(param->tooltip) );
}
return rv;
}
void anypaper_window_create (AnypaperWindow *self)
{
AnypaperWindowPrivate *priv = self->priv;
GtkWidget *window;
GtkWidget *label;
GtkWidget *image, *background;
GtkWidget *rmenu;
GtkWidget *button;
GtkWidget *note, *vbox1, *vbox2, *hbox1, *table, *halign;
gchar *filename, *buffer;
GdkPixbuf *tempbuf;
GdkColor color;
self->priv->window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "anyPaper " VERSION);
gtk_window_set_default_size(GTK_WINDOW(window), 500, 100);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ANYPAPER_DATA "anypaper.png", NULL);
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox2);
note = gtk_notebook_new ();
vbox1 = gtk_vbox_new (FALSE, 10);
label = gtk_label_new ("Wallpaper");
gtk_notebook_append_page (GTK_NOTEBOOK(note), vbox1, label);
gtk_widget_show (label);
table = gtk_table_new (3, 4, FALSE);
label = gtk_label_new ("File: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->file_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->file_entry), self->parameters->file);
g_signal_connect (G_OBJECT (priv->file_entry), "activate", G_CALLBACK (set_image_file_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->file_entry, 1, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->file_entry);
button = gtk_button_new_from_stock (GTK_STOCK_OPEN);
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (open_image_file_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Style: ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->combo = gtk_combo_box_new_text ();
gtk_container_add(GTK_CONTAINER(halign), priv->combo);
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Fullscreen");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Normal");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Tiled");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Adjusted");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Scaled");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Custom Scale");
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), self->parameters->style);
g_signal_connect (G_OBJECT (priv->combo), "changed", G_CALLBACK (set_image_style_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->combo);
gtk_widget_show (halign);
priv->custom_table = gtk_table_new (2, 3, FALSE);
label = gtk_label_new ("Scale x: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (priv->custom_table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin5 = gtk_spin_button_new_with_range (0, 100, .1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (priv->spin5), 4);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin5), self->parameters->scalex);
g_signal_connect (G_OBJECT (priv->spin5), "value-changed", G_CALLBACK (change_other_scale_cb), self);
g_signal_connect_after (G_OBJECT (priv->spin5), "value-changed", G_CALLBACK (set_image_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), priv->spin5, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin5);
button = gtk_toggle_button_new_with_mnemonic("linked");
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(button), priv->custom_scale_connect_state);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (connect_custom_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), button, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Scale y: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (priv->custom_table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin6 = gtk_spin_button_new_with_range (0, 100, .1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (priv->spin6), 4);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin6), self->parameters->scaley);
g_signal_connect (G_OBJECT (priv->spin6), "value-changed", G_CALLBACK (change_other_scale_cb), self);
g_signal_connect_after (G_OBJECT (priv->spin6), "value-changed", G_CALLBACK (set_image_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), priv->spin6, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin6);
gtk_table_attach (GTK_TABLE (table), priv->custom_table, 2, 4, 1, 3, GTK_FILL, GTK_FILL, 0, 0);
if (self->parameters->style == 5) gtk_widget_show (priv->custom_table);
else gtk_widget_hide (priv->custom_table);
label = gtk_label_new ("Background: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
gdk_color_parse (self->parameters->background, &color);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->cbutton = gtk_color_button_new_with_color (&color);
gtk_container_add(GTK_CONTAINER(halign), priv->cbutton);
g_signal_connect (G_OBJECT (priv->cbutton), "color-set", G_CALLBACK (set_image_background_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->cbutton);
gtk_widget_show (halign);
gtk_box_pack_start (GTK_BOX(vbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
hbox1 = gtk_hbox_new (FALSE, 0);
priv->preview = gtk_image_new_from_pixbuf(self->image->preview);
gtk_box_pack_start (GTK_BOX(hbox1), priv->preview, TRUE, FALSE, 2);
gtk_widget_show (priv->preview);
table = gtk_table_new (5, 2, FALSE);
priv->label1 = gtk_label_new ("Position x: ");
gtk_misc_set_alignment (GTK_MISC(priv->label1), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (priv->label1), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), priv->label1, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->label1);
priv->spin1 = gtk_spin_button_new_with_range (-65535, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin1), self->parameters->positionx);
g_signal_connect (G_OBJECT (priv->spin1), "value-changed", G_CALLBACK (set_image_position_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin1, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin1);
priv->label2 = gtk_label_new ("Position y: ");
gtk_misc_set_alignment (GTK_MISC(priv->label2), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (priv->label2), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), priv->label2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->label2);
priv->spin2 = gtk_spin_button_new_with_range (-65535, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin2), self->parameters->positiony);
g_signal_connect (G_OBJECT (priv->spin2), "value-changed", G_CALLBACK (set_image_position_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin2, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin2);
label = gtk_label_new ("Width: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin3 = gtk_spin_button_new_with_range (0, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin3), self->parameters->width);
g_signal_connect (G_OBJECT (priv->spin3), "value-changed", G_CALLBACK (set_image_size_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin3, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin3);
label = gtk_label_new ("Height: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin4 = gtk_spin_button_new_with_range (0, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin4), self->parameters->height);
g_signal_connect (G_OBJECT (priv->spin4), "value-changed", G_CALLBACK (set_image_size_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin4, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin4);
button = gtk_button_new_with_mnemonic ("_Center");
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(center_image_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 0, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(hbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
button = gtk_button_new_with_mnemonic ("Show _Preview");
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(show_window_preview_cb), self);
gtk_box_pack_start (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_with_mnemonic ("Load lastwallpaper file");
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (load_lastwallpaperfile_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
gtk_widget_show (vbox1);
vbox1 = gtk_vbox_new (FALSE, 2);
label = gtk_label_new ("Configuration");
gtk_notebook_append_page (GTK_NOTEBOOK(note), vbox1, label);
gtk_widget_show (label);
table = gtk_table_new (3, 3, FALSE);
label = gtk_label_new ("Default output file: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->def_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->def_entry), self->parameters->defaultfile);
gtk_table_attach_defaults (GTK_TABLE (table), priv->def_entry, 1, 2, 0, 1);
gtk_widget_show (priv->def_entry);
button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
image = gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (save_default_file_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Command (Wallpapersetter): ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
button = gtk_button_new_with_mnemonic ("Detect");
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (detect_popup_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
priv->com_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->com_entry), self->parameters->command);
gtk_table_attach_defaults (GTK_TABLE (table), priv->com_entry, 1, 2, 1, 2);
gtk_widget_show (priv->com_entry);
label = gtk_label_new ("Interpolation: ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->combo_interpolation = gtk_combo_box_new_text ();
gtk_container_add(GTK_CONTAINER(halign), priv->combo_interpolation);
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_NEAREST");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_TILES");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_BILINEAR");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_HYPER");
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo_interpolation), interpolation_int (self->parameters->interpolation));
g_signal_connect (G_OBJECT (priv->combo_interpolation), "changed", G_CALLBACK (set_image_interpolation_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->combo_interpolation);
gtk_widget_show (halign);
gtk_box_pack_start (GTK_BOX(vbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
hbox1 = gtk_hbox_new (FALSE, 0);
button = gtk_button_new_with_mnemonic ("Load anypaperrc file");
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (load_rcfile_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX(vbox2), note, FALSE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
if (no_set == FALSE)
{
button = gtk_button_new_from_stock (GTK_STOCK_OK);
image = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
}
else
{
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON);
}
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
if (no_set == FALSE)
{
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(ok_cb), self);
}
else g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), NULL);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
if (no_set == FALSE)
{
button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(apply_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), NULL);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
}
button = gtk_button_new_from_stock (GTK_STOCK_SAVE_AS);
image = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (save_file_as_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_ABOUT);
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(about_window_cb), G_OBJECT (window));
gtk_box_pack_start (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(vbox2), hbox1, FALSE, TRUE, 0);
gtk_widget_show (hbox1);
gtk_widget_show (vbox2);
gtk_widget_show (note);
gtk_widget_show (window);
}
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data )
{
GtkWidget *rv = NULL;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
if ( param->type == VIK_LAYER_PARAM_COLOR )
rv = gtk_color_button_new_with_color ( &(data.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
if ( param->type == VIK_LAYER_PARAM_BOOLEAN )
{
//rv = gtk_check_button_new_with_label ( //param->title );
rv = gtk_check_button_new ();
if ( data.b )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE );
}
break;
case VIK_LAYER_WIDGET_COMBOBOX:
#ifndef GTK_2_2
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
gchar **pstr = param->widget_data;
rv = gtk_combo_box_new_text ();
while ( *pstr )
gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), *(pstr++) );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == data.u )
{
gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), data.u );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data )
{
gchar **pstr = param->widget_data;
rv = GTK_WIDGET ( gtk_combo_box_entry_new_text () );
if ( data.s )
gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), data.s );
while ( *pstr )
gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), *(pstr++) );
if ( data.s )
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
break;
#endif
case VIK_LAYER_WIDGET_RADIOGROUP:
/* widget_data and extra_widget_data are GList */
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new ( param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
int nb_elem = g_list_length(param->widget_data);
for ( i = 0; i < nb_elem; i++ )
if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == data.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( data.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), data.u );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new_static ( (const gchar **) param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == data.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( data.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), data.u );
}
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? data.d : (param->type == VIK_LAYER_PARAM_UINT ? data.u : data.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits );
}
break;
case VIK_LAYER_WIDGET_ENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
if (data.s)
gtk_entry_set_text ( GTK_ENTRY(rv), data.s );
}
break;
case VIK_LAYER_WIDGET_PASSWORD:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE );
if (data.s)
gtk_entry_set_text ( GTK_ENTRY(rv), data.s );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text ( GTK_WIDGET(rv),
_("Take care that this password will be stored clearly in a plain file.") );
#endif
}
break;
case VIK_LAYER_WIDGET_FILEENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN);
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), data.s );
}
break;
case VIK_LAYER_WIDGET_FOLDERENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), data.s );
}
break;
case VIK_LAYER_WIDGET_FILELIST:
if ( param->type == VIK_LAYER_PARAM_STRING_LIST )
{
rv = vik_file_list_new ( _(param->title) );
vik_file_list_set_files ( VIK_FILE_LIST(rv), data.sl );
}
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? data.d : (param->type == VIK_LAYER_PARAM_UINT ? data.u : data.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step );
gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits );
gtk_range_set_value ( GTK_RANGE(rv), init_val );
}
}
return rv;
}
/**
* \fn void color_options(GtkWidget *widget, BrailleMusicEditor *editor)
* \brief Color options callback
* \param editor The GUI structure .
*
* This function shows a dialog which allows user to customize the colors
* used in the lexical highlighting.
*/
void color_options(GtkWidget *widget, BrailleMusicEditor *editor) {
GtkWidget* dialog;
// Creation of a dialog window
dialog = gtk_dialog_new_with_buttons("Lexical Highlighting",
GTK_WINDOW(editor->window),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 220, -1);
init_colors();
GtkWidget *buttons[NB_TYPES];
GtkWidget *labels[NB_TYPES];
GtkTextBuffer *buffer;
int i;
GtkWidget *box = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
for(i = 0; i < NB_TYPES; i++) {
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous(GTK_BOX(hbox), TRUE);
labels[i] = gtk_label_new(type_table[i]);
//buttons[i] = gtk_button_new_with_label(type_table[i]);
buttons[i] = gtk_color_button_new_with_color(&color_table[i]);
gtk_box_pack_start(GTK_BOX(hbox), labels[i], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), buttons[i], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 0);
gtk_widget_modify_fg(labels[i], GTK_STATE_NORMAL, &color_table[i]);
}
gtk_widget_show_all(box);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
// run the dialog window
switch (gtk_dialog_run(GTK_DIALOG(dialog)))
{
case GTK_RESPONSE_OK:
for(i = 0; i < NB_TYPES; i++) {
gtk_color_button_get_color(GTK_COLOR_BUTTON(buttons[i]),
&color_table[i]);
}
//updating the coloration
set_tags(buffer);
coloration_update(widget, editor);
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_NONE:
default:
break;
}
// Destruction of the dialog window
gtk_widget_destroy((GtkWidget *) dialog);
}
