static void
gtk_color_button_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GtkColorButton *color_button = GTK_COLOR_BUTTON (object);
switch (param_id)
{
case PROP_USE_ALPHA:
gtk_color_button_set_use_alpha (color_button, g_value_get_boolean (value));
break;
case PROP_TITLE:
gtk_color_button_set_title (color_button, g_value_get_string (value));
break;
case PROP_COLOR:
gtk_color_button_set_color (color_button, g_value_get_boxed (value));
break;
case PROP_ALPHA:
gtk_color_button_set_alpha (color_button, g_value_get_uint (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Color Button" );
gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
gtk_widget_set_size_request( window, 320, 240 );
GdkColor color, bgcolor;
/* parse a 6 digit hex form color value into a color structure */
gdk_color_parse( "#003366", &color );
gdk_color_parse( "#112233", &bgcolor );
/* we create a color button with a default color */
GtkWidget *colorButton = gtk_color_button_new_with_color( &color );
gtk_color_button_set_title( GTK_COLOR_BUTTON( colorButton ), "Select a Color" );
GtkWidget *label = gtk_label_new( "Look at my color" );
/* set color and state of label with a default value */
gtk_widget_modify_fg( label, GTK_STATE_NORMAL, &color );
gtk_widget_modify_bg( label, GTK_STATE_NORMAL, &bgcolor );
g_signal_connect( G_OBJECT( colorButton ), "color_set", G_CALLBACK( color_changed ), (gpointer) label );
GtkWidget *hbox = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( hbox ), colorButton, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( hbox ), label, FALSE, FALSE, 10 );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL );
gtk_container_add( GTK_CONTAINER( window ), hbox );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
void gui_update(dt_iop_module_t *self)
{
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE);
dtgtk_reset_label_set_text(g->label, _("color of film material"));
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_iop_invert_gui_data_t));
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
g->label = DTGTK_RESET_LABEL(dtgtk_reset_label_new("", self, &p->color, 3 * sizeof(float)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->label), TRUE, TRUE, 0);
g->pickerbuttons = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->pickerbuttons), TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
g->colorpicker = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), DT_PIXEL_APPLY_DPI(75), DT_PIXEL_APPLY_DPI(24));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpicker), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpicker), _("select color of film material"));
g_signal_connect(G_OBJECT(g->colorpicker), "color-set", G_CALLBACK(colorpicker_callback), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), GTK_WIDGET(g->colorpicker), TRUE, TRUE, 0);
g->picker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(g->picker), "tooltip-text", _("pick color of film material from image"), (char *)NULL);
gtk_widget_set_size_request(g->picker, DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->picker), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), g->picker, TRUE, TRUE, 5);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
}
void gui_cleanup(dt_iop_module_t *self)
{
g_free(self->gui_data);
self->gui_data = NULL;
}
int
clip_GTK_COLORBUTTONSETTITLE(ClipMachine * cm)
{
C_widget *cbtn = _fetch_cw_arg(cm);
gchar *title = _clip_parc(cm, 2);
CHECKCWID(cbtn,GTK_IS_COLOR_BUTTON);
CHECKARG(2, CHARACTER_t);
LOCALE_TO_UTF(title);
gtk_color_button_set_title(GTK_COLOR_BUTTON(cbtn->widget), title);
FREE_TEXT(title);
return 0;
err:
return 1;
}
static inline void gui_init_tab(struct dt_iop_module_t *self, const char *name, GtkWidget **ppcolor,
const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation)
{
gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(name), FALSE, FALSE, 5);
// color button
GtkWidget *color;
*ppcolor = color = gtk_color_button_new_with_rgba(c);
gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color"));
// hue slider
GtkWidget *hue;
*pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0));
dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f);
dt_bauhaus_widget_set_label(hue, NULL, _("hue"));
dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f);
g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL);
// saturation slider
GtkWidget *saturation;
*ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(saturation, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f);
g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL);
// pack the widgets
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hue), FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(saturation), FALSE, TRUE, 0);
GtkWidget *hbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(color), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
}
static void
gtk_color_button_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GtkColorButton *button = GTK_COLOR_BUTTON (object);
switch (param_id)
{
case PROP_USE_ALPHA:
gtk_color_button_set_use_alpha (button, g_value_get_boolean (value));
break;
case PROP_TITLE:
gtk_color_button_set_title (button, g_value_get_string (value));
break;
case PROP_COLOR:
{
GdkColor *color;
GdkRGBA rgba;
color = g_value_get_boxed (value);
rgba.red = color->red / 65535.0;
rgba.green = color->green / 65535.0;
rgba.blue = color->blue / 65535.0;
rgba.alpha = 1.0;
gtk_color_button_set_rgba (button, &rgba);
}
break;
case PROP_ALPHA:
gtk_color_button_set_alpha (button, g_value_get_uint (value));
break;
case PROP_RGBA:
gtk_color_button_set_rgba (button, g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
static inline int gui_init_tab(struct dt_iop_module_t *self, int line, const char *name, GtkWidget **ppcolor,
const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation)
{
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_attach(grid, dt_ui_section_label_new(name), 0, line++, 2, 1);
// color button
GtkWidget *color;
*ppcolor = color = gtk_color_button_new_with_rgba(c);
gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color"));
// hue slider
GtkWidget *hue;
*pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0));
dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f);
dt_bauhaus_widget_set_label(hue, NULL, _("hue"));
dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f);
g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL);
// saturation slider
GtkWidget *saturation;
*ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(saturation, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f);
g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL);
// pack the widgets
gtk_widget_set_hexpand(hue, TRUE); // make sure that the color picker doesn't become HUGE
gtk_grid_attach(grid, hue, 0, line, 1, 1);
gtk_grid_attach(grid, color, 1, line++, 1, 2);
gtk_grid_attach(grid, saturation, 0, line++, 1, 1);
return line;
}
static GtkWidget *
colorbutton_new(GladeXML *xml, GladeWidgetInfo *info)
{
GList *tmp;
GtkWidget *wid;
GdkColor color;
wid = gtk_color_button_new();
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "title")) {
gtk_color_button_set_title(GTK_COLOR_BUTTON(wid),attr->value);
} else if (!strcmp(attr->name, "color")) {
gdk_color_parse(attr->value,&color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(wid),&color);
}
}
return wid;
}
GtkWidget *
dialog_color_button_in_table(const gchar * color, const gchar * title, GtkWidget * table, guint left_attach,
guint right_attach, guint top_attach, guint bottom_attach)
{
GdkColor gdkcolor;
GtkWidget *button;
if (color && gdk_color_parse(color, &gdkcolor)) {
button = gtk_color_button_new_with_color(&gdkcolor);
} else {
button = gtk_color_button_new();
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(button), 0);
}
gtk_color_button_set_title(GTK_COLOR_BUTTON(button), title);
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(button), TRUE);
gtk_table_attach(GTK_TABLE(table), button, left_attach, right_attach, top_attach, bottom_attach, GTK_FILL,
GTK_SHRINK, 0, 0);
return button;
}
GtkWidget *setup_colour_editor(string col_name, rgba_t *col, string name)
{
GtkWidget *hbox = gtk_hbox_new(false, 0);
// Label
GtkWidget *label = gtk_label_new(name.c_str());
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
// Colour button
GtkWidget *c_button = gtk_color_button_new();
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(c_button), true);
gtk_color_button_set_title(GTK_COLOR_BUTTON(c_button), name.c_str());
GdkColor gdk_col;
gdk_col.red = col->r * 255;
gdk_col.green = col->g * 255;
gdk_col.blue = col->b * 255;
gtk_color_button_set_color(GTK_COLOR_BUTTON(c_button), &gdk_col);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(c_button), col->a * 255);
g_signal_connect(G_OBJECT(c_button), "color-set", G_CALLBACK(colour_changed), col);
// Additive checkbox
GtkWidget *cbox_add = gtk_check_button_new_with_label("Additive");
g_signal_connect(G_OBJECT(cbox_add), "toggled", G_CALLBACK(additive_toggled), col);
if (col->blend == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbox_add), true);
gtk_box_pack_start(GTK_BOX(hbox), label, true, true, 0);
gtk_box_pack_start(GTK_BOX(hbox), c_button, false, false, 4);
gtk_box_pack_start(GTK_BOX(hbox), cbox_add, false, false, 4);
buttons.push_back(c_button);
cboxes.push_back(cbox_add);
colours.push_back(col);
return hbox;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
/**
* terminal_profile_edit:
* @profile: a #TerminalProfile
* @transient_parent: a #GtkWindow, or %NULL
* @widget_name: a widget name in the profile editor's UI, or %NULL
*
* Shows the profile editor with @profile, anchored to @transient_parent.
* If @widget_name is non-%NULL, focuses the corresponding widget and
* switches the notebook to its containing page.
*/
void
terminal_profile_edit (TerminalProfile *profile,
GtkWindow *transient_parent,
const char *widget_name)
{
char *path;
GtkBuilder *builder;
GError *error = NULL;
GtkWidget *editor, *w;
guint i;
editor = g_object_get_data (G_OBJECT (profile), "editor-window");
if (editor)
{
terminal_profile_editor_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
GTK_WINDOW (transient_parent));
gtk_window_present (GTK_WINDOW (editor));
return;
}
path = g_build_filename (TERM_PKGDATADIR, "profile-preferences.ui", NULL);
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, path, &error))
{
g_warning ("Failed to load %s: %s\n", path, error->message);
g_error_free (error);
g_free (path);
g_object_unref (builder);
return;
}
g_free (path);
editor = (GtkWidget *) gtk_builder_get_object (builder, "profile-editor-dialog");
g_object_set_data_full (G_OBJECT (editor), "builder",
builder, (GDestroyNotify) g_object_unref);
/* Store the dialogue on the profile, so we can acccess it above to check if
* there's already a profile editor for this profile.
*/
g_object_set_data (G_OBJECT (profile), "editor-window", editor);
g_signal_connect (editor, "destroy",
G_CALLBACK (profile_editor_destroyed),
profile);
g_signal_connect (editor, "response",
G_CALLBACK (editor_response_cb),
NULL);
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
init_color_scheme_menu (w);
w = (GtkWidget *) gtk_builder_get_object (builder, "darken-background-scale");
init_background_darkness_scale (w);
w = (GtkWidget *) gtk_builder_get_object (builder, "background-image-filechooser");
setup_background_filechooser (w, profile);
/* Hook up the palette colorpickers and combo box */
for (i = 0; i < TERMINAL_PALETTE_SIZE; ++i)
{
char name[32];
char *text;
g_snprintf (name, sizeof (name), "palette-colorpicker-%u", i + 1);
w = (GtkWidget *) gtk_builder_get_object (builder, name);
g_object_set_data (G_OBJECT (w), "palette-entry-index", GUINT_TO_POINTER (i));
text = g_strdup_printf (_("Choose Palette Color %d"), i + 1);
gtk_color_button_set_title (GTK_COLOR_BUTTON (w), text);
g_free (text);
text = g_strdup_printf (_("Palette entry %d"), i + 1);
gtk_widget_set_tooltip_text (w, text);
g_free (text);
g_signal_connect (w, "notify::color",
G_CALLBACK (palette_color_notify_cb),
profile);
}
profile_palette_notify_colorpickers_cb (profile, NULL, editor);
g_signal_connect (profile, "notify::" TERMINAL_PROFILE_PALETTE,
G_CALLBACK (profile_palette_notify_colorpickers_cb),
editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "palette-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (palette_scheme_combo_changed_cb),
profile);
profile_palette_notify_scheme_combo_cb (profile, NULL, GTK_COMBO_BOX (w));
g_signal_connect (profile, "notify::" TERMINAL_PROFILE_PALETTE,
G_CALLBACK (profile_palette_notify_scheme_combo_cb),
w);
/* Hook up the color scheme pickers and combo box */
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (color_scheme_combo_changed_cb),
profile);
profile_colors_notify_scheme_combo_cb (profile, NULL, GTK_COMBO_BOX (w));
g_signal_connect (profile, "notify::" TERMINAL_PROFILE_FOREGROUND_COLOR,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
g_signal_connect (profile, "notify::" TERMINAL_PROFILE_BACKGROUND_COLOR,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
#define CONNECT_WITH_FLAGS(name, prop, flags) terminal_util_bind_object_property_to_widget (G_OBJECT (profile), prop, (GtkWidget *) gtk_builder_get_object (builder, name), flags)
#define CONNECT(name, prop) CONNECT_WITH_FLAGS (name, prop, 0)
#define SET_ENUM_VALUE(name, value) g_object_set_data (gtk_builder_get_object (builder, name), "enum-value", GINT_TO_POINTER (value))
w = GTK_WIDGET (gtk_builder_get_object (builder, "custom-command-entry"));
custom_command_entry_changed_cb (GTK_ENTRY (w));
g_signal_connect (w, "changed",
G_CALLBACK (custom_command_entry_changed_cb), NULL);
w = GTK_WIDGET (gtk_builder_get_object (builder, "profile-name-entry"));
g_signal_connect (w, "changed",
G_CALLBACK (visible_name_entry_changed_cb), editor);
g_signal_connect (gtk_builder_get_object (builder, "reset-compat-defaults-button"),
"clicked",
G_CALLBACK (reset_compat_defaults_cb),
profile);
SET_ENUM_VALUE ("image-radiobutton", TERMINAL_BACKGROUND_IMAGE);
SET_ENUM_VALUE ("solid-radiobutton", TERMINAL_BACKGROUND_SOLID);
SET_ENUM_VALUE ("transparent-radiobutton", TERMINAL_BACKGROUND_TRANSPARENT);
CONNECT ("allow-bold-checkbutton", TERMINAL_PROFILE_ALLOW_BOLD);
CONNECT ("background-colorpicker", TERMINAL_PROFILE_BACKGROUND_COLOR);
CONNECT ("background-image-filechooser", TERMINAL_PROFILE_BACKGROUND_IMAGE_FILE);
CONNECT ("backspace-binding-combobox", TERMINAL_PROFILE_BACKSPACE_BINDING);
CONNECT ("bold-color-same-as-fg-checkbox", TERMINAL_PROFILE_BOLD_COLOR_SAME_AS_FG);
CONNECT ("bold-colorpicker", TERMINAL_PROFILE_BOLD_COLOR);
CONNECT ("cursor-shape-combobox", TERMINAL_PROFILE_CURSOR_SHAPE);
CONNECT ("cursor-blink-combobox", TERMINAL_PROFILE_CURSOR_BLINK_MODE);
CONNECT ("custom-command-entry", TERMINAL_PROFILE_CUSTOM_COMMAND);
CONNECT ("darken-background-scale", TERMINAL_PROFILE_BACKGROUND_DARKNESS);
CONNECT ("default-size-columns-spinbutton", TERMINAL_PROFILE_DEFAULT_SIZE_COLUMNS);
CONNECT ("default-size-rows-spinbutton", TERMINAL_PROFILE_DEFAULT_SIZE_ROWS);
CONNECT ("delete-binding-combobox", TERMINAL_PROFILE_DELETE_BINDING);
CONNECT ("exit-action-combobox", TERMINAL_PROFILE_EXIT_ACTION);
CONNECT ("font-selector", TERMINAL_PROFILE_FONT);
CONNECT ("foreground-colorpicker", TERMINAL_PROFILE_FOREGROUND_COLOR);
CONNECT ("image-radiobutton", TERMINAL_PROFILE_BACKGROUND_TYPE);
CONNECT ("login-shell-checkbutton", TERMINAL_PROFILE_LOGIN_SHELL);
CONNECT ("profile-name-entry", TERMINAL_PROFILE_VISIBLE_NAME);
CONNECT ("scrollback-lines-spinbutton", TERMINAL_PROFILE_SCROLLBACK_LINES);
CONNECT ("scrollback-unlimited-checkbutton", TERMINAL_PROFILE_SCROLLBACK_UNLIMITED);
CONNECT ("scroll-background-checkbutton", TERMINAL_PROFILE_SCROLL_BACKGROUND);
CONNECT ("scrollbar-position-combobox", TERMINAL_PROFILE_SCROLLBAR_POSITION);
CONNECT ("scroll-on-keystroke-checkbutton", TERMINAL_PROFILE_SCROLL_ON_KEYSTROKE);
CONNECT ("scroll-on-output-checkbutton", TERMINAL_PROFILE_SCROLL_ON_OUTPUT);
CONNECT ("show-menubar-checkbutton", TERMINAL_PROFILE_DEFAULT_SHOW_MENUBAR);
CONNECT ("solid-radiobutton", TERMINAL_PROFILE_BACKGROUND_TYPE);
CONNECT ("system-font-checkbutton", TERMINAL_PROFILE_USE_SYSTEM_FONT);
CONNECT ("title-entry", TERMINAL_PROFILE_TITLE);
CONNECT ("title-mode-combobox", TERMINAL_PROFILE_TITLE_MODE);
CONNECT ("transparent-radiobutton", TERMINAL_PROFILE_BACKGROUND_TYPE);
CONNECT ("update-records-checkbutton", TERMINAL_PROFILE_UPDATE_RECORDS);
CONNECT ("use-custom-command-checkbutton", TERMINAL_PROFILE_USE_CUSTOM_COMMAND);
CONNECT ("use-custom-default-size-checkbutton", TERMINAL_PROFILE_USE_CUSTOM_DEFAULT_SIZE);
CONNECT ("use-theme-colors-checkbutton", TERMINAL_PROFILE_USE_THEME_COLORS);
CONNECT ("word-chars-entry", TERMINAL_PROFILE_WORD_CHARS);
CONNECT_WITH_FLAGS ("bell-checkbutton", TERMINAL_PROFILE_SILENT_BELL, FLAG_INVERT_BOOL);
#undef CONNECT
#undef CONNECT_WITH_FLAGS
#undef SET_ENUM_VALUE
profile_notify_sensitivity_cb (profile, NULL, editor);
g_signal_connect (profile, "notify",
G_CALLBACK (profile_notify_sensitivity_cb),
editor);
g_signal_connect (profile,
"forgotten",
G_CALLBACK (profile_forgotten_cb),
editor);
terminal_profile_editor_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
GTK_WINDOW (transient_parent));
gtk_window_present (GTK_WINDOW (editor));
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size * 100.0, 2);
dt_bauhaus_widget_set_label(g->size, NULL, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect(G_OBJECT(g->size), "value-changed", G_CALLBACK(size_callback), self);
gtk_widget_set_tooltip_text(g->size, _("size of the border in percent of the full image"));
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
gui_init_aspect(self);
g_signal_connect(G_OBJECT(g->aspect), "value-changed", G_CALLBACK(aspect_changed), self);
gtk_widget_set_tooltip_text(g->aspect, _("select the aspect ratio or right click and type your own (w:h)"));
g->aspect_orient = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation"));
dt_bauhaus_combobox_add(g->aspect_orient, _("auto"));
dt_bauhaus_combobox_add(g->aspect_orient, _("portrait"));
dt_bauhaus_combobox_add(g->aspect_orient, _("landscape"));
gtk_widget_set_tooltip_text(g->aspect_orient, _("aspect ratio orientation of the image with border"));
g_signal_connect(G_OBJECT(g->aspect_orient), "value-changed", G_CALLBACK(aspect_orient_changed), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0);
g->pos_h = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_h, 1);
dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_h), "value-changed", G_CALLBACK(position_h_changed), self);
gtk_widget_set_tooltip_text(g->pos_h, _("select the horizontal position ratio relative to top "
"or right click and type your own (y:h)"));
g->pos_v = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_v, 1);
dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_v), "value-changed", G_CALLBACK(position_v_changed), self);
gtk_widget_set_tooltip_text(g->pos_v, _("select the vertical position ratio relative to left "
"or right click and type your own (x:w)"));
gui_init_positions(self);
g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size"));
dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_size), "value-changed", G_CALLBACK(frame_size_callback), self);
gtk_widget_set_tooltip_text(g->frame_size, _("size of the frame line in percent of min border width"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0);
g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset"));
dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_offset), "value-changed", G_CALLBACK(frame_offset_callback), self);
gtk_widget_set_tooltip_text(g->frame_offset, _("offset of the frame line beginning on picture side"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select border color"));
GtkWidget *label = dtgtk_reset_label_new(_("border color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->border_picker), _("pick border color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->frame_colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->frame_colorpick), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->frame_colorpick), _("select frame line color"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
label = dtgtk_reset_label_new(_("frame line color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->frame_colorpick), "color-set", G_CALLBACK(frame_colorpick_color_set), self);
g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->frame_picker), _("pick frame line color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(borders_draw), self);
}
void reload_defaults(dt_iop_module_t *self)
{
dt_iop_borders_params_t tmp = (dt_iop_borders_params_t){ { 1.0f, 1.0f, 1.0f },
DT_IOP_BORDERS_ASPECT_CONSTANT_VALUE,
"constant border",
0,
0.1f,
0.5f,
"1/2",
0.5f,
"1/2",
0.0f,
0.5f,
{ 0.0f, 0.0f, 0.0f },
TRUE };
memcpy(self->params, &tmp, sizeof(dt_iop_borders_params_t));
memcpy(self->default_params, &tmp, sizeof(dt_iop_borders_params_t));
self->default_enabled = 0;
}
/** \brief Create and initialise widgets for the sky-at-glance tab.
*
* The widgets must be preloaded with values from config. If a config value
* is NULL, sensible default values, eg. those from defaults.h should
* be laoded.
*/
GtkWidget *sat_pref_sky_at_glance_create ()
{
GtkWidget *table;
GtkWidget *label;
GtkWidget *vbox;
GdkColor col;
guint rgb; /* 0xRRGGBB encoded colour */
guint y;
dirty = FALSE;
reset = FALSE;
table = gtk_table_new (16, 5, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Time:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* number of hours */
label = gtk_label_new (_("Find and show passes that occur within"));
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_SHRINK,
0, 0);
timesp = gtk_spin_button_new_with_range (1, 24, 1);
gtk_widget_set_tooltip_text (timesp,
_("The passes shown on the Sky at a Glance chart\n"\
"will begin within this number of hours."));
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (timesp), 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (timesp), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (timesp), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (timesp),
sat_cfg_get_int (SAT_CFG_INT_SKYATGL_TIME));
g_signal_connect (G_OBJECT (timesp), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), timesp,
1, 2, 1, 2,
GTK_SHRINK, GTK_SHRINK,
0, 0);
label = gtk_label_new (_("hours"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
2, 3, 1, 2,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 5, 2, 3,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
y = 3;
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Colours:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y, y+1,
GTK_FILL,
GTK_SHRINK,
0, 0);
/* colour 1 */
label = gtk_label_new (_("Colour for satellite 1: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+1, y+2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col1 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col1), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col1), _("Select colour 1"));
gtk_table_attach (GTK_TABLE (table), col1,
1, 2, y+1, y+2,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text ( col1,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_01);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col1), &col);
g_signal_connect (col1, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 2 */
label = gtk_label_new (_("Colour for satellite 2: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+2, y+3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col2 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col2), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col1), _("Select colour 2"));
gtk_table_attach (GTK_TABLE (table), col2,
1, 2, y+2, y+3,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text ( col2,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_02);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col2), &col);
g_signal_connect (col2, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 3 */
label = gtk_label_new (_("Colour for satellite 3: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+3, y+4,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col3 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col3), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col3), _("Select colour 3"));
gtk_table_attach (GTK_TABLE (table), col3,
1, 2, y+3, y+4,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col3,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_03);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col3), &col);
g_signal_connect (col3, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 4 */
label = gtk_label_new (_("Colour for satellite 4: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+4, y+5,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col4 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col4), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col4), _("Select colour 4"));
gtk_table_attach (GTK_TABLE (table), col4,
1, 2, y+4, y+5,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col4,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_04);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col4), &col);
g_signal_connect (col4, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 5 */
label = gtk_label_new (_("Colour for satellite 5: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, y+5, y+6,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col5 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col5), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col5), _("Select colour 5"));
gtk_table_attach (GTK_TABLE (table), col5,
1, 2, y+5, y+6,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col5,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_05);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col5), &col);
g_signal_connect (col5, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 6 */
label = gtk_label_new (_("Colour for satellite 6: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+1, y+2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col6 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col6), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col6), _("Select colour 6"));
gtk_table_attach (GTK_TABLE (table), col6,
4, 5, y+1, y+2,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col6,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_06);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col6), &col);
g_signal_connect (col6, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 7 */
label = gtk_label_new (_("Colour for satellite 7: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+2, y+3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col7 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col7), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col7), _("Select colour 7"));
gtk_table_attach (GTK_TABLE (table), col7,
4, 5, y+2, y+3,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col7,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_07);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col7), &col);
g_signal_connect (col7, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 8 */
label = gtk_label_new (_("Colour for satellite 8: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+3, y+4,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col8 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col8), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col8), _("Select colour 8"));
gtk_table_attach (GTK_TABLE (table), col8,
4, 5, y+3, y+4,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col8,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_08);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col8), &col);
g_signal_connect (col8, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 9 */
label = gtk_label_new (_("Colour for satellite 9: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+4, y+5,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col9 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col9), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col9), _("Select colour 9"));
gtk_table_attach (GTK_TABLE (table), col9,
4, 5, y+4, y+5,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col9,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_09);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col9), &col);
g_signal_connect (col9, "color-set", G_CALLBACK (colour_changed), NULL);
/* colour 10 */
label = gtk_label_new (_("Colour for satellite 10: "));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
3, 4, y+5, y+6,
GTK_SHRINK, GTK_SHRINK, 0, 0);
col10 = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (col10), FALSE);
gtk_color_button_set_title (GTK_COLOR_BUTTON (col10), _("Select colour 10"));
gtk_table_attach (GTK_TABLE (table), col10,
4, 5, y+5, y+6,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_tooltip_text (col10,
_("Click to select a colour"));
rgb = sat_cfg_get_int (SAT_CFG_INT_SKYATGL_COL_10);
rgb2gdk (rgb, &col);
gtk_color_button_set_color (GTK_COLOR_BUTTON (col10), &col);
g_signal_connect (col10, "color-set", G_CALLBACK (colour_changed), NULL);
/* create vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 20);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
/* create RESET button */
create_reset_button (GTK_BOX (vbox));
return vbox;
}
/**
* Creates the "Fonts & logo" tab. This function creates some buttons
* that are borrowed from applications like gedit.
*
* \returns A newly allocated vbox
*/
GtkWidget * onglet_display_fonts ( void )
{
GtkWidget *hbox, *vbox_pref, *label, *paddingbox, *font_button;
GtkWidget *check_button, *vbox;
GdkPixbuf * pixbuf = NULL;
GtkWidget *button;
GtkWidget *color_combobox;
GtkWidget *color_button;
vbox_pref = new_vbox_with_title_and_icon ( _("Fonts & logo"), "fonts.png" );
/* Change Grisbi Logo */
paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Grisbi logo") );
hbox = gtk_hbox_new ( FALSE, 5 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 );
check_button = gtk_check_button_new_with_label ( _("Display a logo"));
gtk_box_pack_start ( GTK_BOX ( hbox ), check_button, FALSE, FALSE, 0 );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( check_button ),
etat.utilise_logo );
hbox = gtk_hbox_new ( FALSE, 5 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 );
/* le logo est grisé ou non suivant qu'on l'utilise ou pas */
gtk_widget_set_sensitive ( hbox, etat.utilise_logo );
g_signal_connect ( G_OBJECT ( check_button ),
"toggled",
G_CALLBACK ( change_choix_utilise_logo ),
hbox );
logo_button = gtk_button_new ();
gtk_button_set_relief ( GTK_BUTTON ( logo_button ), GTK_RELIEF_NONE );
pixbuf = gsb_select_icon_get_logo_pixbuf ( );
if (!pixbuf)
{
preview = gtk_image_new_from_pixbuf ( gsb_select_icon_get_default_logo_pixbuf ( ) );
}
else
{
if ( gdk_pixbuf_get_width(pixbuf) > 64 ||
gdk_pixbuf_get_height(pixbuf) > 64 )
{
GdkPixbuf * tmp;
tmp = gdk_pixbuf_new ( GDK_COLORSPACE_RGB, TRUE, 8,
gdk_pixbuf_get_width(pixbuf)/2,
gdk_pixbuf_get_height(pixbuf)/2 );
gdk_pixbuf_scale ( pixbuf, tmp, 0, 0,
gdk_pixbuf_get_width(pixbuf)/2,
gdk_pixbuf_get_height(pixbuf)/2,
0, 0, 0.5, 0.5, GDK_INTERP_HYPER );
pixbuf = tmp;
}
preview = gtk_image_new_from_pixbuf (pixbuf);
}
gtk_container_add (GTK_CONTAINER(logo_button), preview);
g_signal_connect_swapped ( G_OBJECT ( logo_button ), "clicked",
G_CALLBACK ( modification_logo_accueil ), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), logo_button, FALSE, FALSE, 0 );
label = gtk_label_new ( _("Click on preview to change logo") );
gtk_box_pack_start ( GTK_BOX ( hbox ), label, FALSE, FALSE, 0 );
/* Change fonts */
paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Fonts") );
hbox = gtk_hbox_new ( FALSE, 10 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 );
check_button = gtk_check_button_new_with_label (
_("Use a custom font for the transactions: "));
gtk_box_pack_start ( GTK_BOX ( hbox ), check_button, FALSE, FALSE, 0 );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( check_button ),
conf.utilise_fonte_listes );
/* on crée la vbox qui contiendra la font button et le raz */
vbox = gtk_vbox_new ( FALSE, 10 );
gtk_box_pack_start ( GTK_BOX ( hbox ), vbox, FALSE, FALSE, 0 );
gtk_widget_set_sensitive ( vbox, conf.utilise_fonte_listes );
g_signal_connect ( G_OBJECT ( check_button ), "toggled",
G_CALLBACK ( change_choix_utilise_fonte_liste ), vbox );
/* Create font button */
font_button = utils_font_create_button ( &conf.font_string,
G_CALLBACK (update_fonte_listes), NULL);
gtk_box_pack_start ( GTK_BOX (vbox), font_button, FALSE, FALSE, 0 );
if ( !gsb_data_account_get_accounts_amount () )
{
gtk_widget_set_sensitive ( vbox_pref, FALSE );
}
/* change colors */
paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Colors") );
vbox = gtk_vbox_new ( FALSE, 10 );
gtk_box_pack_start ( GTK_BOX ( paddingbox ), vbox, FALSE, FALSE, 10 );
hbox = gtk_hbox_new ( FALSE, 10 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 10 );
color_combobox = gsb_color_create_color_combobox ( );
gtk_box_pack_start ( GTK_BOX (hbox),
color_combobox,
FALSE, FALSE, 0);
color_button = gtk_color_button_new ();
gtk_color_button_set_title ( GTK_COLOR_BUTTON(color_button), _("Choosing color") );
g_signal_connect ( G_OBJECT (color_button),
"color-set",
G_CALLBACK (preferences_view_color_changed),
G_OBJECT (color_combobox));
gtk_box_pack_start ( GTK_BOX (hbox),
color_button,
FALSE, FALSE, 0);
/* connect the color button to the combobox if changed */
g_signal_connect ( G_OBJECT (color_combobox),
"changed",
G_CALLBACK (preferences_view_color_combobox_changed),
G_OBJECT (color_button));
button = gtk_button_new_with_label (_("Back to default"));
g_signal_connect ( G_OBJECT (button),
"clicked",
G_CALLBACK (preferences_view_color_default),
G_OBJECT (color_combobox));
gtk_box_pack_start ( GTK_BOX (vbox),
button,
FALSE, FALSE, 0);
gtk_combo_box_set_active ( GTK_COMBO_BOX (color_combobox), 0);
return vbox_pref;
}
void sensor_config_dialog_create(SensorsApplet *sensors_applet) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkWidget *content_area;
SensorConfigDialog *config_dialog;
GtkListStore *icon_store;
IconType count;
GdkPixbuf *pixbuf;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkRGBA graph_color;
#else
GdkColor graph_color;
#endif
gchar *sensor_label;
gchar *header_text;
/* instance variables for data */
gdouble low_value, high_value, multiplier, offset;
gboolean alarm_enable;
gchar *low_alarm_command, *high_alarm_command;
gint alarm_timeout;
IconType icon_type;
gchar *graph_color_string;
config_dialog = g_new0(SensorConfigDialog, 1);
config_dialog->sensors_applet = sensors_applet;
gtk_tree_selection_get_selected(sensors_applet->selection,
&model,
&iter);
/* get current values of alarm and its enable */
gtk_tree_model_get(model, &iter,
LOW_VALUE_COLUMN, &low_value,
HIGH_VALUE_COLUMN, &high_value,
ALARM_ENABLE_COLUMN, &alarm_enable,
LOW_ALARM_COMMAND_COLUMN, &low_alarm_command,
HIGH_ALARM_COMMAND_COLUMN, &high_alarm_command,
ALARM_TIMEOUT_COLUMN, &alarm_timeout,
MULTIPLIER_COLUMN, &multiplier,
OFFSET_COLUMN, &offset,
ICON_TYPE_COLUMN, &icon_type,
GRAPH_COLOR_COLUMN, &graph_color_string,
LABEL_COLUMN, &sensor_label,
-1);
header_text = g_strdup_printf("%s - %s", _("Sensor Properties"), sensor_label);
config_dialog->dialog = gtk_dialog_new_with_buttons(header_text,
GTK_WINDOW(sensors_applet->prefs_dialog->dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_icon_name(GTK_WINDOW(config_dialog->dialog),
"sensors-applet");
g_free(header_text);
g_free(sensor_label);
g_object_set(config_dialog->dialog,
"border-width", 12,
NULL);
g_signal_connect(config_dialog->dialog,
"response",
G_CALLBACK(sensor_config_dialog_response),
config_dialog);
/* graph stuff */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Graph"));
config_dialog->graph_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_rgba_parse(&graph_color, graph_color_string);
config_dialog->graph_color_button = GTK_COLOR_BUTTON(gtk_color_button_new_with_rgba(&graph_color));
#else
gdk_color_parse(graph_color_string, &graph_color);
config_dialog->graph_color_button = GTK_COLOR_BUTTON(gtk_color_button_new_with_color(&graph_color));
#endif
config_dialog->graph_color_button_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->graph_color_button,
"xalign", 0.0,
"xscale", 0.0,
NULL);
gtk_color_button_set_title(config_dialog->graph_color_button, _("Graph Color"));
config_dialog->graph_color_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Graph _color"),
"mnemonic-widget", config_dialog->graph_color_button,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->graph_color_button, "color-set",
G_CALLBACK(sensor_config_dialog_graph_color_set),
config_dialog);
/* icon stuff */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Icon"));
config_dialog->icon_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
/* icon type */
icon_store = gtk_list_store_new(1, GDK_TYPE_PIXBUF);
/* populate list with icons */
for (count = CPU_ICON; count < NUM_ICONS; count++) {
pixbuf = sensors_applet_load_icon(count);
if (pixbuf) {
gtk_list_store_insert(icon_store, &iter, count);
gtk_list_store_set(icon_store, &iter,
0, pixbuf,
-1);
/* let list hold icons */
g_object_unref(pixbuf);
}
}
config_dialog->icon_type_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(icon_store)));
config_dialog->icon_type_combo_box_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->icon_type_combo_box,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),
GTK_CELL_RENDERER(config_dialog->icon_renderer),
FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),
GTK_CELL_RENDERER(config_dialog->icon_renderer),
"pixbuf", 0);
gtk_combo_box_set_active(config_dialog->icon_type_combo_box,
icon_type);
g_signal_connect(config_dialog->icon_type_combo_box, "changed",
G_CALLBACK(sensor_config_dialog_icon_type_changed),
config_dialog);
config_dialog->icon_type_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _icon"),
"mnemonic-widget", config_dialog->icon_type_combo_box,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Scaling Parameters"));
config_dialog->scale_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
/* do multiplier and offset widgets */
config_dialog->multiplier_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 1.0,
"lower", 0.001,
"upper", 1000.0,
"step-increment", 0.1,
"page-increment", 1.0,
"page-size", 1.0,
NULL);
config_dialog->multiplier_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->multiplier_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", multiplier,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->multiplier_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->multiplier_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->multiplier_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor value _multiplier"),
"mnemonic-widget", config_dialog->multiplier_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->multiplier_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_multiplier_changed), config_dialog);
config_dialog->offset_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -1000.000,
"upper", 1000.000,
"step-increment", 0.01,
"page-increment", 1.0,
"page-size", 1.0,
NULL);
config_dialog->offset_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->offset_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", (gdouble)offset,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->offset_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->offset_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->offset_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor value _offset"),
"mnemonic-widget", config_dialog->offset_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->offset_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_offset_changed), config_dialog);
/* now do alarm widgets */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Sensor Limits"));
config_dialog->limits_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
config_dialog->low_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -100000.0,
"upper", 100000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->low_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->low_value_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", low_value,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->low_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->low_value_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->low_value_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _low value"),
"mnemonic-widget", config_dialog->low_value_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->low_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_low_value_changed), config_dialog);
config_dialog->high_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -100000.0,
"upper", 100000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->high_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->high_value_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", high_value,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->high_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->high_value_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->high_value_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _high value"),
"mnemonic-widget", config_dialog->high_value_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->high_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_high_value_changed), config_dialog);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Alarm"));
config_dialog->alarm_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
config_dialog->alarm_timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", 0.0,
"upper", 10000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->alarm_timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->alarm_timeout_adjust,
"digits", 0,
"value", (gdouble)alarm_timeout,
"width-chars", SPINBUTTON_WIDTH_CHARS,
"sensitive", alarm_enable,
NULL);
config_dialog->alarm_timeout_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->alarm_timeout_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->alarm_timeout_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Alarm _repeat interval (secs)"),
"mnemonic-widget", config_dialog->alarm_timeout_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->alarm_timeout_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_alarm_timeout_changed), config_dialog);
config_dialog->low_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,
"text", low_alarm_command,
"width-chars", 25,
"sensitive", alarm_enable,
NULL);
g_free(low_alarm_command);
config_dialog->low_alarm_command_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Lo_w alarm command"),
"mnemonic-widget", config_dialog->low_alarm_command_entry,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->low_alarm_command_entry,
"changed",
G_CALLBACK(sensor_config_dialog_low_alarm_command_edited),
config_dialog);
config_dialog->high_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,
"text", high_alarm_command,
"width-chars", 25,
"sensitive", alarm_enable,
NULL);
g_free(high_alarm_command);
config_dialog->high_alarm_command_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Hi_gh alarm command"),
"mnemonic-widget", config_dialog->high_alarm_command_entry,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->high_alarm_command_entry,
"changed",
G_CALLBACK(sensor_config_dialog_high_alarm_command_edited),
config_dialog);
config_dialog->alarm_enable_checkbutton = g_object_new(GTK_TYPE_CHECK_BUTTON,
"use-underline", TRUE,
"label", _("_Enable alarm"),
"active", alarm_enable,
"xalign", 0.0,
NULL);
config_dialog->alarm_enable_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->alarm_enable_checkbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
g_signal_connect(config_dialog->alarm_enable_checkbutton, "toggled", G_CALLBACK(sensor_config_dialog_alarm_toggled), config_dialog);
config_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->multiplier_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->offset_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->low_value_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->high_value_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->alarm_timeout_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->icon_type_combo_box));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->graph_color_button));
g_object_unref(config_dialog->size_group);
config_dialog->table = g_object_new(GTK_TYPE_TABLE,
"column-spacing", 5,
"homogeneous", FALSE,
"n-columns", 3,
"n-rows", 15,
"row-spacing", 6,
"column-spacing", 12,
NULL);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->scale_header),
0, 2,
0, 1);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->multiplier_label),
1, 2,
1, 2);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->multiplier_spinbutton_aligner),
2, 3,
1, 2);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->offset_label),
1, 2,
2, 3);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->offset_spinbutton_aligner),
2, 3,
2, 3);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->limits_header),
0, 2,
3, 4);
/* now pack alarm widgets */
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_value_label),
1, 2,
4, 5);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_value_spinbutton_aligner),
2, 3,
4, 5);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_value_label),
1, 2,
5, 6);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_value_spinbutton_aligner),
2, 3,
5, 6);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_header),
0, 2,
6, 7);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_enable_aligner),
1, 2,
7, 8);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_timeout_label),
1, 2,
8, 9);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_timeout_spinbutton_aligner),
2, 3,
8, 9);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_alarm_command_label),
1, 2,
9, 10);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_alarm_command_entry),
2, 3,
9, 10);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_alarm_command_label),
1, 2,
10, 11);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_alarm_command_entry),
2, 3,
10, 11);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_header),
0, 2,
11, 12);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_type_label),
1, 2,
12, 13);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_type_combo_box_aligner),
2, 3,
12, 13);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_header),
0, 2,
13, 14);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_color_label),
1, 2,
14, 15);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_color_button_aligner),
2, 3,
14, 15);
content_area = gtk_dialog_get_content_area (GTK_DIALOG(config_dialog->dialog));
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(config_dialog->table), FALSE, FALSE, 0);
gtk_widget_show_all(config_dialog->dialog);
}
/**
* terminal_profile_edit:
* @profile: a #GSettings
* @transient_parent: a #GtkWindow, or %NULL
* @widget_name: a widget name in the profile editor's UI, or %NULL
*
* Shows the profile editor with @profile, anchored to @transient_parent.
* If @widget_name is non-%NULL, focuses the corresponding widget and
* switches the notebook to its containing page.
*/
void
terminal_profile_edit (GSettings *profile,
GtkWindow *transient_parent,
const char *widget_name)
{
TerminalSettingsList *profiles_list;
GtkBuilder *builder;
GError *error = NULL;
GtkWidget *editor, *w;
gs_free char *uuid = NULL;
guint i;
gfloat style_darkness;
editor = g_object_get_data (G_OBJECT (profile), "editor-window");
if (editor)
{
terminal_util_dialog_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
NULL);
gtk_window_present (GTK_WINDOW (editor));
return;
}
fixup_color_chooser_button ();
profiles_list = terminal_app_get_profiles_list (terminal_app_get ());
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/terminal/ui/profile-preferences.ui", &error);
g_assert_no_error (error);
editor = (GtkWidget *) gtk_builder_get_object (builder, "profile-editor-dialog");
g_object_set_data_full (G_OBJECT (editor), "builder",
builder, (GDestroyNotify) g_object_unref);
/* Store the dialogue on the profile, so we can acccess it above to check if
* there's already a profile editor for this profile.
*/
g_object_set_data (G_OBJECT (profile), "editor-window", editor);
g_signal_connect (editor, "destroy",
G_CALLBACK (profile_editor_destroyed),
profile);
w = (GtkWidget *) gtk_builder_get_object (builder, "close-button");
g_signal_connect (w, "clicked", G_CALLBACK (editor_close_button_clicked_cb), editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "help-button");
g_signal_connect (w, "clicked", G_CALLBACK (editor_help_button_clicked_cb), editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "profile-editor-notebook");
gtk_widget_add_events (w, GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK);
g_signal_connect (w, "scroll-event", G_CALLBACK (scroll_event_cb), NULL);
uuid = terminal_settings_list_dup_uuid_from_child (profiles_list, profile);
gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "profile-uuid")),
uuid);
g_signal_connect (gtk_builder_get_object (builder, "default-size-reset-button"),
"clicked",
G_CALLBACK (default_size_reset_cb),
profile);
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
init_color_scheme_menu (w);
/* Hook up the palette colorpickers and combo box */
for (i = 0; i < TERMINAL_PALETTE_SIZE; ++i)
{
char name[32];
char *text;
g_snprintf (name, sizeof (name), "palette-colorpicker-%u", i + 1);
w = (GtkWidget *) gtk_builder_get_object (builder, name);
g_object_set_data (G_OBJECT (w), "palette-entry-index", GUINT_TO_POINTER (i));
text = g_strdup_printf (_("Choose Palette Color %u"), i + 1);
gtk_color_button_set_title (GTK_COLOR_BUTTON (w), text);
g_free (text);
text = g_strdup_printf (_("Palette entry %u"), i + 1);
gtk_widget_set_tooltip_text (w, text);
g_free (text);
g_signal_connect (w, "notify::rgba",
G_CALLBACK (palette_color_notify_cb),
profile);
}
gtk_widget_style_get (GTK_WIDGET (
terminal_window_get_active (TERMINAL_WINDOW (transient_parent))),
"background-darkness", &style_darkness,
NULL);
gtk_widget_set_visible (gtk_builder_get_object (
builder,
"use-theme-transparency-checkbutton"), style_darkness >= 0);
profile_palette_notify_colorpickers_cb (profile, TERMINAL_PROFILE_PALETTE_KEY, editor);
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_PALETTE_KEY,
G_CALLBACK (profile_palette_notify_colorpickers_cb),
editor);
w = (GtkWidget *) gtk_builder_get_object (builder, "palette-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (palette_scheme_combo_changed_cb),
profile);
profile_palette_notify_scheme_combo_cb (profile, TERMINAL_PROFILE_PALETTE_KEY, GTK_COMBO_BOX (w));
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_PALETTE_KEY,
G_CALLBACK (profile_palette_notify_scheme_combo_cb),
w);
/* Hook up the color scheme pickers and combo box */
w = (GtkWidget *) gtk_builder_get_object (builder, "color-scheme-combobox");
g_signal_connect (w, "notify::active",
G_CALLBACK (color_scheme_combo_changed_cb),
profile);
profile_colors_notify_scheme_combo_cb (profile, NULL, GTK_COMBO_BOX (w));
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_FOREGROUND_COLOR_KEY,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
g_signal_connect (profile, "changed::" TERMINAL_PROFILE_BACKGROUND_COLOR_KEY,
G_CALLBACK (profile_colors_notify_scheme_combo_cb),
w);
w = GTK_WIDGET (gtk_builder_get_object (builder, "custom-command-entry"));
custom_command_entry_changed_cb (GTK_ENTRY (w));
g_signal_connect (w, "changed",
G_CALLBACK (custom_command_entry_changed_cb), NULL);
g_signal_connect (gtk_builder_get_object (builder, "reset-compat-defaults-button"),
"clicked",
G_CALLBACK (reset_compat_defaults_cb),
profile);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_VISIBLE_NAME_KEY,
editor,
"title",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_NO_SENSITIVITY,
(GSettingsBindGetMapping)
string_to_window_title, NULL, NULL, NULL);
g_settings_bind (profile,
TERMINAL_PROFILE_ALLOW_BOLD_KEY,
gtk_builder_get_object (builder, "allow-bold-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_BACKGROUND_COLOR_KEY,
gtk_builder_get_object (builder,
"background-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_BACKSPACE_BINDING_KEY,
gtk_builder_get_object (builder,
"backspace-binding-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_erase_binding_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_BOLD_COLOR_SAME_AS_FG_KEY,
gtk_builder_get_object (builder,
"bold-color-same-as-fg-checkbox"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_BOLD_COLOR_SAME_AS_FG_KEY,
gtk_builder_get_object (builder,
"bold-colorpicker-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_BOLD_COLOR_KEY,
gtk_builder_get_object (builder,
"bold-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_CURSOR_SHAPE_KEY,
gtk_builder_get_object (builder,
"cursor-shape-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_cursor_shape_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder, "custom-command-entry"),
"text", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_DEFAULT_SIZE_COLUMNS_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"default-size-columns-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_DEFAULT_SIZE_ROWS_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"default-size-rows-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_DELETE_BINDING_KEY,
gtk_builder_get_object (builder,
"delete-binding-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
vte_erase_binding_get_type, NULL);
g_settings_bind_with_mapping (profile, TERMINAL_PROFILE_EXIT_ACTION_KEY,
gtk_builder_get_object (builder,
"exit-action-combobox"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) string_to_enum,
(GSettingsBindSetMapping) enum_to_string,
terminal_exit_action_get_type, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_FONT_KEY,
gtk_builder_get_object (builder, "font-selector"),
"font-name", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_FOREGROUND_COLOR_KEY,
gtk_builder_get_object (builder,
"foreground-colorpicker"),
"rgba",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) s_to_rgba,
(GSettingsBindSetMapping) rgba_to_s,
NULL, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_LOGIN_SHELL_KEY,
gtk_builder_get_object (builder,
"login-shell-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_VISIBLE_NAME_KEY,
gtk_builder_get_object (builder, "profile-name-entry"),
"text", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_LINES_KEY,
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON
(gtk_builder_get_object
(builder,
"scrollback-lines-spinbutton"))),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_UNLIMITED_KEY,
gtk_builder_get_object (builder,
"scrollback-limited-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLLBACK_UNLIMITED_KEY,
gtk_builder_get_object (builder,
"scrollback-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_with_mapping (profile,
TERMINAL_PROFILE_SCROLLBAR_POLICY_KEY,
gtk_builder_get_object (builder,
"scrollbar-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET,
(GSettingsBindGetMapping) scrollbar_policy_to_bool,
(GSettingsBindSetMapping) bool_to_scrollbar_policy,
NULL, NULL);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLL_ON_KEYSTROKE_KEY,
gtk_builder_get_object (builder,
"scroll-on-keystroke-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_SCROLL_ON_OUTPUT_KEY,
gtk_builder_get_object (builder,
"scroll-on-output-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_SYSTEM_FONT_KEY,
gtk_builder_get_object (builder,
"custom-font-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_settings_bind (profile, TERMINAL_PROFILE_USE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder,
"use-custom-command-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_COLORS_KEY,
gtk_builder_get_object (builder,
"use-theme-colors-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_AUDIBLE_BELL_KEY,
gtk_builder_get_object (builder, "bell-checkbutton"),
"active",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_CUSTOM_COMMAND_KEY,
gtk_builder_get_object (builder, "custom-command-box"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_SYSTEM_FONT_KEY,
gtk_builder_get_object (builder, "font-selector"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile,
TERMINAL_PROFILE_USE_THEME_COLORS_KEY,
gtk_builder_get_object (builder, "colors-box"),
"sensitive",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind_writable (profile,
TERMINAL_PROFILE_PALETTE_KEY,
gtk_builder_get_object (builder, "palette-box"),
"sensitive",
FALSE);
g_settings_bind (profile,
TERMINAL_PROFILE_REWRAP_ON_RESIZE_KEY,
gtk_builder_get_object (builder, "rewrap-on-resize-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
/* Compatibility options */
w = (GtkWidget *) gtk_builder_get_object (builder, "encoding-combobox");
init_encodings_combo (w);
g_settings_bind (profile,
TERMINAL_PROFILE_ENCODING_KEY,
w,
"active-id", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
w = (GtkWidget *) gtk_builder_get_object (builder, "cjk-ambiguous-width-combobox");
g_settings_bind (profile, TERMINAL_PROFILE_CJK_UTF8_AMBIGUOUS_WIDTH_KEY,
w,
"active-id",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_TRANSPARENT_BACKGROUND,
gtk_builder_get_object (builder, "use-transparent-background"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_TRANSPARENT_BACKGROUND,
gtk_builder_get_object (builder, "background-transparent-scale-box"),
"sensitive", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
g_settings_bind (profile, TERMINAL_PROFILE_BACKGROUND_TRANSPARENCY_PERCENT,
gtk_builder_get_object (builder, "background-transparent-adjustment"),
"value", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_TRANSPARENCY,
gtk_builder_get_object (builder, "use-theme-transparency-checkbutton"),
"active", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET);
if (style_darkness >= 0)
g_settings_bind (profile, TERMINAL_PROFILE_USE_THEME_TRANSPARENCY,
gtk_builder_get_object (builder, "use-transparent-background-box"),
"sensitive",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_INVERT_BOOLEAN |
G_SETTINGS_BIND_NO_SENSITIVITY);
/* Finished! */
terminal_util_bind_mnemonic_label_sensitivity (editor);
terminal_util_dialog_focus_widget (editor, widget_name);
gtk_window_set_transient_for (GTK_WINDOW (editor),
NULL);
gtk_window_present (GTK_WINDOW (editor));
}
static void
xpad_preferences_init (XpadPreferences *pref)
{
GtkWidget *hbox, *font_hbox, *vbox;
const GdkColor *color;
const gchar *fontname;
GtkStyle *style;
GtkWidget *label, *appearance_frame, *alignment, *appearance_vbox;
GtkWidget *options_frame, *options_vbox, *global_vbox;
gchar *text;
GtkSizeGroup *size_group_labels = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
GtkRequisition req;
pref->priv = XPAD_PREFERENCES_GET_PRIVATE (pref);
text = g_strconcat ("<b>", _("Appearance"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
appearance_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 18,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", appearance_vbox,
NULL);
appearance_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
pref->priv->textbutton = gtk_color_button_new ();
pref->priv->backbutton = gtk_color_button_new ();
pref->priv->fontbutton = gtk_font_button_new ();
pref->priv->antifontcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use font from theme"));
pref->priv->fontcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->antifontcheck), _("Use this font:"));
pref->priv->anticolorcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use colors from theme"));
pref->priv->colorcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->anticolorcheck), _("Use these colors:"));
font_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontbutton, TRUE, TRUE, 0);
pref->priv->colorbox = gtk_vbox_new (FALSE, 6);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Background:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->backbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Foreground:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->textbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
alignment = gtk_alignment_new (1, 1, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (alignment), pref->priv->colorbox);
pref->priv->editcheck = gtk_check_button_new_with_mnemonic (_("_Edit lock"));
pref->priv->stickycheck = gtk_check_button_new_with_mnemonic (_("_Pads start on all workspaces"));
pref->priv->confirmcheck = gtk_check_button_new_with_mnemonic (_("_Confirm pad deletion"));
gtk_dialog_add_button (GTK_DIALOG (pref), "gtk-close", GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE);
g_signal_connect (pref, "response", G_CALLBACK (xpad_preferences_response), NULL);
gtk_window_set_title (GTK_WINDOW (pref), _("Xpad Preferences"));
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->textbutton), FALSE);
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->backbutton), xpad_app_get_translucent ());
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->textbutton), _("Set Foreground Color"));
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->backbutton), _("Set Background Color"));
gtk_font_button_set_title (GTK_FONT_BUTTON (pref->priv->fontbutton), _("Set Font"));
/* Set current state */
style = gtk_widget_get_default_style ();
color = xpad_settings_get_back_color (xpad_settings ());
if (color)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), color);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->colorbox, FALSE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &style->base[GTK_STATE_NORMAL]);
}
color = xpad_settings_get_text_color (xpad_settings ());
if (color)
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color);
else
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &style->text[GTK_STATE_NORMAL]);
fontname = xpad_settings_get_fontname (xpad_settings ());
if (fontname)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname);
}
else
{
gchar *str;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE);
str = pango_font_description_to_string (style->font_desc);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), str);
g_free (str);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->editcheck), xpad_settings_get_edit_lock (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->stickycheck), xpad_settings_get_sticky (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->confirmcheck), xpad_settings_get_confirm_destroy (xpad_settings ()));
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->antifontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), font_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->anticolorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->colorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
text = g_strconcat ("<b>", _("Options"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
options_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 6,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", options_vbox,
NULL);
options_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->editcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->stickycheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->confirmcheck, FALSE, FALSE, 0);
global_vbox = g_object_new (GTK_TYPE_VBOX,
"border-width", 6,
"homogeneous", FALSE,
"spacing", 18,
"child", appearance_frame,
"child", options_frame,
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref)->vbox), global_vbox, FALSE, FALSE, 0);
pref->priv->editcheck_handler = g_signal_connect (pref->priv->editcheck, "toggled", G_CALLBACK (change_edit_check), pref);
pref->priv->stickycheck_handler = g_signal_connect (pref->priv->stickycheck, "toggled", G_CALLBACK (change_sticky_check), pref);
pref->priv->confirmcheck_handler = g_signal_connect (pref->priv->confirmcheck, "toggled", G_CALLBACK (change_confirm_check), pref);
pref->priv->colorcheck_handler = g_signal_connect (pref->priv->colorcheck, "toggled", G_CALLBACK (change_color_check), pref);
pref->priv->fontcheck_handler = g_signal_connect (pref->priv->fontcheck, "toggled", G_CALLBACK (change_font_check), pref);
pref->priv->text_handler = g_signal_connect (pref->priv->textbutton, "color-set", G_CALLBACK (change_text_color), pref);
pref->priv->back_handler = g_signal_connect (pref->priv->backbutton, "color-set", G_CALLBACK (change_back_color), pref);
pref->priv->font_handler = g_signal_connect (pref->priv->fontbutton, "font-set", G_CALLBACK (change_font_face), pref);
pref->priv->notify_font_handler = g_signal_connect_swapped (xpad_settings (), "notify::fontname", G_CALLBACK (notify_fontname), pref);
pref->priv->notify_text_handler = g_signal_connect_swapped (xpad_settings (), "notify::text-color", G_CALLBACK (notify_text_color), pref);
pref->priv->notify_back_handler = g_signal_connect_swapped (xpad_settings (), "notify::back-color", G_CALLBACK (notify_back_color), pref);
pref->priv->notify_sticky_handler = g_signal_connect_swapped (xpad_settings (), "notify::sticky", G_CALLBACK (notify_sticky), pref);
pref->priv->notify_edit_handler = g_signal_connect_swapped (xpad_settings (), "notify::edit-lock", G_CALLBACK (notify_edit), pref);
pref->priv->notify_confirm_handler = g_signal_connect_swapped (xpad_settings (), "notify::confirm-destroy", G_CALLBACK (notify_confirm), pref);
g_object_unref (size_group_labels);
gtk_widget_show_all (GTK_DIALOG (pref)->vbox);
/* Make window not so squished */
gtk_widget_size_request (GTK_WIDGET (pref), &req);
g_object_set (G_OBJECT (pref), "default-width", (gint) (req.height * 0.8), NULL);
}
/* Plugin configuration function */
static GObject* plugin_configure(XfdashboardPlugin *self, gpointer inUserData)
{
GtkWidget *layout;
GtkWidget *widgetLabel;
GtkWidget *widgetValue;
XfdashboardClockViewSettings *settings;
/* Get settings of plugin */
settings=xfdashboard_clock_view_settings_new();
/* Create layout widget */
layout=gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(layout), 8);
/* Add widget to choose hour color */
widgetLabel=gtk_label_new(_("Hour color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 0, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for hour hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "hour-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose minute color */
widgetLabel=gtk_label_new(_("Minute color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 1, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for minute hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "minute-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose second color */
widgetLabel=gtk_label_new(_("Second color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 2, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for second hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "second-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose minute color */
widgetLabel=gtk_label_new(_("Background color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 3, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for background of second hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "background-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Release allocated resources */
if(settings) g_object_unref(settings);
/* Make all widgets visible */
gtk_widget_show_all(layout);
/* Return layout widget containing all other widgets */
return(G_OBJECT(layout));
}
