void
configure(void)
{
ENTER;
DBG("dialog %p\n", dialog);
if (!dialog)
dialog = mk_dialog();
gtk_widget_show(dialog);
update_opt_menu(edge_opt, p->edge - 1);
update_opt_menu(allign_opt, p->allign - 1);
//gtk_adjustment_set_value(margin_adj, p->margin);
//gtk_adjustment_value_changed(margin_adj);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(margin_spinb), p->margin);
update_opt_menu(width_opt, p->widthtype - 1);
gtk_adjustment_set_value(width_adj, p->width);
update_opt_menu(height_opt, HEIGHT_PIXEL - 1);
gtk_adjustment_set_value(height_adj, p->height);
update_toggle_button(tr_checkb, p->transparent);
gtk_color_button_set_color(GTK_COLOR_BUTTON(tr_colorb), &p->gtintcolor);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON(tr_colorb), 256*p->alpha);
gtk_widget_show(dialog);
update_toggle_button(prop_dt_checkb, p->setdocktype);
update_toggle_button(prop_st_checkb, p->setstrut);
RET();
}
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;
}
}
static void widget_colorbutton_input_by_file(variable *var, char *filename)
{
FILE *infile;
GdkColor color;
list_t *values = NULL;
gchar line[512];
gint count;
guint alpha;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
if (infile = fopen(filename, "r")) {
/* Just one line */
if (fgets(line, 512, infile)) {
/* Enforce end of string in case of max chars read */
line[512 - 1] = 0;
/* Remove the trailing [CR]LFs */
for (count = strlen(line) - 1; count >= 0; count--)
if (line[count] == 13 || line[count] == 10) line[count] = 0;
values = linecutter(g_strdup(line), '|');
if (values->n_lines > 0) {
/* Parse the RGB value to create the necessary GdkColor.
* This function doesn't like trailing whitespace so it
* needs to be stripped first with g_strstrip() */
if (gdk_color_parse(g_strstrip(values->line[0]), &color)) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid colour found\n", __func__);
#endif
gtk_color_button_set_color(GTK_COLOR_BUTTON(var->Widget), &color);
}
}
if (values->n_lines > 1) {
/* Read alpha as an unsigned decimal integer */
if (sscanf(values->line[1], "%u", &alpha) == 1) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid alpha=%u found\n", __func__, alpha);
#endif
/* This requires use-alpha="true" */
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(var->Widget), alpha);
}
}
/* Free linecutter memory */
if (values) list_t_free(values);
}
/* Close the file */
fclose(infile);
} else {
fprintf(stderr, "%s(): Couldn't open '%s' for reading.\n", __func__,
filename);
}
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
int
clip_GTK_COLORBUTTONSETALPHA(ClipMachine * cm)
{
C_widget *cbtn = _fetch_cw_arg(cm);
guint16 alpha = _clip_parni(cm, 2);
CHECKCWID(cbtn,GTK_IS_COLOR_BUTTON);
CHECKARG(2, NUMERIC_t);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(cbtn->widget), alpha);
return 0;
err:
return 1;
}
GtkWidget *
mk_transparency()
{
GtkWidget *hbox, *hbox2, *label, *frame;
ENTER;
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL (label),"<span weight=\"bold\">Transparency</span>");
gtk_frame_set_label_widget(GTK_FRAME (frame), label);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 6);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), hbox, FALSE, TRUE, 0);
gtk_widget_set_size_request(hbox, 20, 1);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX (hbox2), hbox, FALSE, TRUE, 0);
tr_checkb = gtk_check_button_new_with_label("Enable Transparency");
gtk_widget_show(tr_checkb);
gtk_box_pack_start(GTK_BOX (hbox), tr_checkb, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(tr_checkb), "toggled", G_CALLBACK(transparency_toggle), NULL);
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tr_checkb), FALSE);
tr_colorl = gtk_label_new("Tint color:");
gtk_misc_set_alignment(GTK_MISC(tr_colorl), 0.0, 0.5);
gtk_widget_show(tr_colorl);
gtk_box_pack_start(GTK_BOX (hbox), tr_colorl, FALSE, FALSE, 5);
//gtk_widget_set_sensitive(tr_colorl, FALSE);
tr_colorb = gtk_color_button_new();
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(tr_colorb), TRUE);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON(tr_colorb), 65535/256*125);
gtk_box_pack_start(GTK_BOX (hbox), tr_colorb, FALSE, FALSE, 0);
//gtk_widget_set_sensitive(tr_colorb, FALSE);
RET(frame);
}
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;
}
}
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;
}
void config_changed(GtkWidget *w, gpointer data)
{
set_colour_config(gtk_combo_box_get_active_text(GTK_COMBO_BOX(w)));
force_map_redraw(true, true);
col_config = gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
current = &colour_configs[gtk_combo_box_get_active(GTK_COMBO_BOX(w))];
for (int a = 0; a < buttons.size(); a++)
{
GdkColor gdk_col;
gdk_col.red = colours[a]->r * 255;
gdk_col.green = colours[a]->g * 255;
gdk_col.blue = colours[a]->b * 255;
gtk_color_button_set_color(GTK_COLOR_BUTTON(buttons[a]), &gdk_col);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(buttons[a]), colours[a]->a * 255);
if (colours[a]->blend == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cboxes[a]), true);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cboxes[a]), false);
}
}
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;
}
GtkWidget* bimp_resize_gui_new(resize_settings settings)
{
GtkWidget *gui, *vbox_dimensions, *hbox_padding, *vbox_resolution, *hbox_values, *hbox_quality;
GtkWidget *align_manualsize, *align_values, *align_res;
GtkWidget *label_width, *label_height, *label_quality, *label_resX, *label_resY, *label_dpi;
last_percent_w_value = settings->new_w_pc;
last_percent_h_value = settings->new_h_pc;
last_pixel_w_value = settings->new_w_px;
last_pixel_h_value = settings->new_h_px;
gui = gtk_hbox_new(FALSE, 10);
// "change dimensions" side
vbox_dimensions = gtk_vbox_new(FALSE, 5);
radio_size_percent = gtk_radio_button_new_with_label (NULL, _("Set to a percentage of the original"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_size_percent), (settings->resize_mode == RESIZE_PERCENT));
radio_size_px = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_size_percent), _("Set exact size in pixel"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_size_px), (settings->resize_mode != RESIZE_PERCENT));
align_manualsize = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_manualsize), 0, 5, 20, 0);
combo_manualsize = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("For both dimensions"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("Width only"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("Height only"));
if (settings->resize_mode == RESIZE_PIXEL_WIDTH) gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 1);
else if (settings->resize_mode == RESIZE_PIXEL_HEIGHT) gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 2);
else gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 0);
gtk_container_add(GTK_CONTAINER(align_manualsize), combo_manualsize);
GtkWidget* separator1 = gtk_hseparator_new();
radio_stretch_allow = gtk_radio_button_new_with_label (NULL, _("Allow stretching"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_allow), (settings->stretch_mode == STRETCH_ALLOW));
radio_stretch_aspect = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_stretch_allow), _("Preserve aspect ratio"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_aspect), (settings->stretch_mode == STRETCH_ASPECT));
radio_stretch_padded = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_stretch_allow), _("Fill with padding"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_padded), (settings->stretch_mode == STRETCH_PADDED));
chooser_paddingcolor = gtk_color_button_new_with_color(&(settings->padding_color));
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(chooser_paddingcolor), TRUE);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(chooser_paddingcolor), settings->padding_color_alpha);
hbox_padding = gtk_hbox_new(FALSE, 5);
GtkWidget* separator2 = gtk_hseparator_new();
align_values = gtk_alignment_new(0.5, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_values), 5, 5, 0, 0);
hbox_values = gtk_hbox_new(FALSE, 5);
label_width = gtk_label_new(g_strconcat(_("Width"), ":", NULL));
spin_width = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_width, SPIN_SIZE_W, SPIN_SIZE_H);
label_height = gtk_label_new(g_strconcat(_("Height"), ":", NULL));
spin_height = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_height, SPIN_SIZE_W, SPIN_SIZE_H);
label_unit = gtk_label_new("<unit>");
gtk_widget_set_size_request (label_unit, 25, 25);
hbox_quality = gtk_hbox_new(FALSE, 5);
label_quality = gtk_label_new(_("Interpolation quality"));
combo_quality = gimp_enum_combo_box_new((GType)GIMP_TYPE_INTERPOLATION_TYPE);
gimp_int_combo_box_set_active((GimpIntComboBox*)combo_quality, settings->interpolation);
GtkWidget* separator3 = gtk_vseparator_new();
// "change resolution" side
vbox_resolution = gtk_vbox_new(FALSE, 5);
check_resolution = gtk_check_button_new_with_label(_("Change resolution"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_resolution), settings->change_res);
align_res = gtk_alignment_new(0.5, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_res), 5, 5, 0, 0);
hbox_res = gtk_hbox_new(FALSE, 5);
label_resX = gtk_label_new(g_strconcat(_("X axis"), ":", NULL));
spin_resX = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_resX, SPIN_SIZE_W, SPIN_SIZE_H);
gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resX), GTK_ADJUSTMENT(gtk_adjustment_new (settings->new_res_x, 0.005, 65536.000, 1.000, 1, 0)), 0, 3);
label_resY = gtk_label_new(g_strconcat(_("Y axis"), ":", NULL));
spin_resY = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_resY, SPIN_SIZE_W, SPIN_SIZE_H);
gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resY), GTK_ADJUSTMENT(gtk_adjustment_new (settings->new_res_y, 0.005, 65536.000, 1.000, 1, 0)), 0, 3);
label_dpi = gtk_label_new("dpi");
// pack everything
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_size_percent, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_size_px, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), align_manualsize, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), separator1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_stretch_allow, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_stretch_aspect, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_padding), radio_stretch_padded, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_padding), chooser_paddingcolor, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), hbox_padding, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), separator2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_width, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), spin_width, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_height, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), spin_height, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_unit, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_values), hbox_values);
gtk_box_pack_start(GTK_BOX(hbox_quality), label_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_quality), combo_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), align_values, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), hbox_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_resolution), check_resolution, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_resX, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), spin_resX, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_resY, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), spin_resY, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_dpi, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_res), hbox_res);
gtk_box_pack_start(GTK_BOX(vbox_resolution), align_res, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), vbox_dimensions, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), separator3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), vbox_resolution, FALSE, FALSE, 0);
previous_was_percent = FALSE;
toggle_units_group(NULL, NULL);
toggle_resolution(NULL, NULL);
g_signal_connect(G_OBJECT(radio_size_percent), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_size_px), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(combo_manualsize), "changed", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_allow), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_aspect), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_padded), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(check_resolution), "toggled", G_CALLBACK(toggle_resolution), NULL);
return gui;
}
void
on_button_config (GtkMenuItem *menuitem, gpointer user_data)
{
GtkWidget *waveform_properties;
GtkWidget *config_dialog;
GtkWidget *vbox01;
GtkWidget *color_label;
GtkWidget *color_frame;
GtkWidget *color_table;
GtkWidget *color_background_label;
GtkWidget *background_color;
GtkWidget *color_waveform_label;
GtkWidget *foreground_color;
GtkWidget *color_rms_label;
GtkWidget *foreground_rms_color;
GtkWidget *color_progressbar_label;
GtkWidget *progressbar_color;
GtkWidget *downmix_to_mono;
GtkWidget *log_scale;
GtkWidget *display_rms;
GtkWidget *display_ruler;
GtkWidget *style_label;
GtkWidget *style_frame;
GtkWidget *vbox02;
GtkWidget *render_method_spikes;
GtkWidget *render_method_bars;
GtkWidget *shade_waveform;
GtkWidget *fill_waveform;
GtkWidget *soundcloud_style;
GtkWidget *dialog_action_area13;
GtkWidget *applybutton1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
waveform_properties = gtk_dialog_new ();
gtk_window_set_transient_for (GTK_WINDOW (waveform_properties), gtk_widget_get_toplevel(menuitem));
gtk_window_set_title (GTK_WINDOW (waveform_properties), "Waveform Properties");
gtk_window_set_type_hint (GTK_WINDOW (waveform_properties), GDK_WINDOW_TYPE_HINT_DIALOG);
config_dialog = gtk_dialog_get_content_area (GTK_DIALOG (waveform_properties));
gtk_widget_show (config_dialog);
vbox01 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox01);
gtk_box_pack_start (GTK_BOX (config_dialog), vbox01, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox01), 12);
color_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (color_label),"<b>Colors</b>");
gtk_widget_show (color_label);
color_frame = gtk_frame_new ("Colors");
gtk_frame_set_label_widget ((GtkFrame *)color_frame, color_label);
gtk_frame_set_shadow_type ((GtkFrame *)color_frame, GTK_SHADOW_IN);
gtk_widget_show (color_frame);
gtk_box_pack_start (GTK_BOX (vbox01), color_frame, TRUE, FALSE, 0);
color_table = gtk_table_new (2, 4, TRUE);
gtk_widget_show (color_table);
gtk_container_add (GTK_CONTAINER (color_frame), color_table);
gtk_table_set_col_spacings ((GtkTable *) color_table, 8);
gtk_container_set_border_width (GTK_CONTAINER (color_table), 6);
color_background_label = gtk_label_new ("Background");
gtk_widget_show (color_background_label);
gtk_table_attach_defaults ((GtkTable *) color_table, color_background_label, 0,1,0,1);
color_waveform_label = gtk_label_new ("Waveform");
gtk_widget_show (color_waveform_label);
gtk_table_attach_defaults ((GtkTable *) color_table, color_waveform_label, 1,2,0,1);
color_rms_label = gtk_label_new ("RMS");
gtk_widget_show (color_rms_label);
gtk_table_attach_defaults ((GtkTable *) color_table, color_rms_label, 2,3,0,1);
color_progressbar_label = gtk_label_new ("Progressbar");
gtk_widget_show (color_progressbar_label);
gtk_table_attach_defaults ((GtkTable *) color_table, color_progressbar_label, 3,4,0,1);
background_color = gtk_color_button_new ();
gtk_color_button_set_use_alpha ((GtkColorButton *)background_color, TRUE);
gtk_widget_show (background_color);
gtk_table_attach_defaults ((GtkTable *) color_table, background_color, 0,1,1,2);
foreground_color = gtk_color_button_new ();
gtk_color_button_set_use_alpha ((GtkColorButton *)foreground_color, TRUE);
gtk_widget_show (foreground_color);
gtk_table_attach_defaults ((GtkTable *) color_table, foreground_color, 1,2,1,2);
foreground_rms_color = gtk_color_button_new ();
gtk_color_button_set_use_alpha ((GtkColorButton *)foreground_rms_color, TRUE);
gtk_widget_show (foreground_rms_color);
gtk_table_attach_defaults ((GtkTable *) color_table, foreground_rms_color, 2,3,1,2);
progressbar_color = gtk_color_button_new ();
gtk_color_button_set_use_alpha ((GtkColorButton *)progressbar_color, TRUE);
gtk_widget_show (progressbar_color);
gtk_table_attach_defaults ((GtkTable *) color_table, progressbar_color, 3,4,1,2);
style_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (style_label),"<b>Style</b>");
gtk_widget_show (style_label);
style_frame = gtk_frame_new ("Style");
gtk_frame_set_label_widget ((GtkFrame *)style_frame, style_label);
gtk_frame_set_shadow_type ((GtkFrame *)style_frame, GTK_SHADOW_IN);
gtk_widget_show (style_frame);
gtk_box_pack_start (GTK_BOX (vbox01), style_frame, FALSE, FALSE, 0);
vbox02 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox02);
gtk_container_add (GTK_CONTAINER (style_frame), vbox02);
render_method_spikes = gtk_radio_button_new_with_label (NULL, "Spikes");
gtk_widget_show (render_method_spikes);
gtk_box_pack_start (GTK_BOX (vbox02), render_method_spikes, TRUE, TRUE, 0);
render_method_bars = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton *)render_method_spikes, "Bars");
gtk_widget_show (render_method_bars);
gtk_box_pack_start (GTK_BOX (vbox02), render_method_bars, TRUE, TRUE, 0);
fill_waveform = gtk_check_button_new_with_label ("Fill waveform");
gtk_widget_show (fill_waveform);
gtk_box_pack_start (GTK_BOX (vbox02), fill_waveform, TRUE, TRUE, 0);
soundcloud_style = gtk_check_button_new_with_label ("Soundcloud style");
gtk_widget_show (soundcloud_style);
gtk_box_pack_start (GTK_BOX (vbox02), soundcloud_style, TRUE, TRUE, 0);
shade_waveform = gtk_check_button_new_with_label ("Shade waveform");
gtk_widget_show (shade_waveform);
gtk_box_pack_start (GTK_BOX (vbox02), shade_waveform, TRUE, TRUE, 0);
downmix_to_mono = gtk_check_button_new_with_label ("Downmix to mono");
gtk_widget_show (downmix_to_mono);
gtk_box_pack_start (GTK_BOX (vbox01), downmix_to_mono, FALSE, FALSE, 0);
log_scale = gtk_check_button_new_with_label ("Logarithmic scale");
gtk_widget_show (log_scale);
gtk_box_pack_start (GTK_BOX (vbox01), log_scale, FALSE, FALSE, 0);
display_rms = gtk_check_button_new_with_label ("Display RMS");
gtk_widget_show (display_rms);
gtk_box_pack_start (GTK_BOX (vbox01), display_rms, FALSE, FALSE, 0);
display_ruler = gtk_check_button_new_with_label ("Display Ruler");
gtk_widget_show (display_ruler);
gtk_box_pack_start (GTK_BOX (vbox01), display_ruler, FALSE, FALSE, 0);
dialog_action_area13 = gtk_dialog_get_action_area (GTK_DIALOG (waveform_properties));
gtk_widget_show (dialog_action_area13);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area13), GTK_BUTTONBOX_END);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (waveform_properties), applybutton1, GTK_RESPONSE_APPLY);
gtk_widget_set_can_default (applybutton1, TRUE);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (waveform_properties), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (cancelbutton1, TRUE);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (waveform_properties), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (okbutton1, TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (background_color), &CONFIG_BG_COLOR);
gtk_color_button_set_color (GTK_COLOR_BUTTON (foreground_color), &CONFIG_FG_COLOR);
gtk_color_button_set_color (GTK_COLOR_BUTTON (progressbar_color), &CONFIG_PB_COLOR);
gtk_color_button_set_color (GTK_COLOR_BUTTON (foreground_rms_color), &CONFIG_FG_RMS_COLOR);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON (background_color), CONFIG_BG_ALPHA);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON (foreground_color), CONFIG_FG_ALPHA);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON (progressbar_color), CONFIG_PB_ALPHA);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON (foreground_rms_color), CONFIG_FG_RMS_ALPHA);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (downmix_to_mono), CONFIG_MIX_TO_MONO);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (log_scale), CONFIG_LOG_ENABLED);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (display_rms), CONFIG_DISPLAY_RMS);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (display_ruler), CONFIG_DISPLAY_RULER);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shade_waveform), CONFIG_SHADE_WAVEFORM);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (soundcloud_style), CONFIG_SOUNDCLOUD_STYLE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fill_waveform), CONFIG_FILL_WAVEFORM);
gtk_widget_set_sensitive (display_rms, !CONFIG_SOUNDCLOUD_STYLE);
switch (CONFIG_RENDER_METHOD) {
case SPIKES:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (render_method_spikes), TRUE);
break;
case BARS:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (render_method_bars), TRUE);
break;
}
for (;;) {
int response = gtk_dialog_run (GTK_DIALOG (waveform_properties));
if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
gtk_color_button_get_color (GTK_COLOR_BUTTON (background_color), &CONFIG_BG_COLOR);
gtk_color_button_get_color (GTK_COLOR_BUTTON (foreground_color), &CONFIG_FG_COLOR);
gtk_color_button_get_color (GTK_COLOR_BUTTON (progressbar_color), &CONFIG_PB_COLOR);
gtk_color_button_get_color (GTK_COLOR_BUTTON (foreground_rms_color), &CONFIG_FG_RMS_COLOR);
CONFIG_BG_ALPHA = gtk_color_button_get_alpha (GTK_COLOR_BUTTON (background_color));
CONFIG_FG_ALPHA = gtk_color_button_get_alpha (GTK_COLOR_BUTTON (foreground_color));
CONFIG_PB_ALPHA = gtk_color_button_get_alpha (GTK_COLOR_BUTTON (progressbar_color));
CONFIG_FG_RMS_ALPHA = gtk_color_button_get_alpha (GTK_COLOR_BUTTON (foreground_rms_color));
CONFIG_MIX_TO_MONO = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (downmix_to_mono));
CONFIG_LOG_ENABLED = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (log_scale));
CONFIG_DISPLAY_RMS = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (display_rms));
CONFIG_DISPLAY_RULER = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (display_ruler));
CONFIG_SHADE_WAVEFORM = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (shade_waveform));
CONFIG_SOUNDCLOUD_STYLE = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (soundcloud_style));
CONFIG_FILL_WAVEFORM = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fill_waveform));
gtk_widget_set_sensitive (display_rms, !CONFIG_SOUNDCLOUD_STYLE);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (render_method_spikes)) == TRUE) {
CONFIG_RENDER_METHOD = SPIKES;
}
else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (render_method_bars)) == TRUE) {
CONFIG_RENDER_METHOD = BARS;
}
save_config ();
deadbeef->sendmessage (DB_EV_CONFIGCHANGED, 0, 0, 0);
}
if (response == GTK_RESPONSE_APPLY) {
continue;
}
break;
}
gtk_widget_destroy (waveform_properties);
#pragma GCC diagnostic pop
return;
}
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;
}
/* Initialize and display the preferences dialog. */
void terminal_preferences_dialog(GtkAction * action, LXTerminal * terminal)
{
Setting * setting = copy_setting(get_setting());
GtkBuilder * builder = gtk_builder_new();
if ( ! gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/lxterminal/lxterminal-preferences.ui", NULL))
{
g_object_unref(builder);
return;
}
GtkDialog * dialog = GTK_DIALOG(gtk_builder_get_object(builder, "lxterminal_preferences"));
gtk_window_set_title(GTK_WINDOW(dialog), _("LXTerminal"));
gtk_window_set_icon_from_file(GTK_WINDOW(dialog), PACKAGE_DATA_DIR "/icons/hicolor/128x128/apps/lxterminal.png", NULL);
GtkWidget * w = GTK_WIDGET(gtk_builder_get_object(builder, "terminal_font"));
gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), setting->font_name);
g_signal_connect(G_OBJECT(w), "font-set", G_CALLBACK(preferences_dialog_font_set_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "background_color"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->background_color);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(w), setting->background_alpha);
g_signal_connect(G_OBJECT(w), "color-set",
G_CALLBACK(preferences_dialog_background_color_set_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "foreground_color"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->foreground_color);
g_signal_connect(G_OBJECT(w), "color-set",
G_CALLBACK(preferences_dialog_foreground_color_set_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "allow_bold"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->disallow_bold);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_allow_bold_toggled_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_blink"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_blink);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->cursor_blink);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_block"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->cursor_underline);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_underline"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_underline);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->cursor_underline);
w = GTK_WIDGET(gtk_builder_get_object(builder, "audible_bell"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->audible_bell);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->audible_bell);
w = GTK_WIDGET(gtk_builder_get_object(builder, "tab_position"));
gtk_combo_box_set_active(GTK_COMBO_BOX(w), terminal_tab_get_position_id(setting->tab_position));
g_signal_connect(G_OBJECT(w), "changed",
G_CALLBACK(preferences_dialog_tab_position_changed_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "scrollback_lines"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), setting->scrollback);
g_signal_connect(G_OBJECT(w), "value-changed",
G_CALLBACK(preferences_dialog_scrollback_value_changed_event), setting);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_scroll_bar"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_scroll_bar);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_scroll_bar);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_menu_bar"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_menu_bar);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_menu_bar);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_close_button"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_close_button);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_close_button);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_pointer"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_pointer);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_pointer);
w = GTK_WIDGET(gtk_builder_get_object(builder, "select_by_word"));
gtk_entry_set_text(GTK_ENTRY(w), setting->word_selection_characters);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_generic_focus_out_event), setting->word_selection_characters);
w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_f10"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_f10);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->disable_f10);
w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_alt"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_alt);
g_signal_connect(G_OBJECT(w), "toggled",
G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->disable_alt);
/* Shortcuts */
w = GTK_WIDGET(gtk_builder_get_object(builder, NEW_WINDOW_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->new_window_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->new_window_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, NEW_TAB_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->new_tab_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->new_tab_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, CLOSE_TAB_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->close_tab_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->close_tab_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, CLOSE_WINDOW_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->close_window_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->close_window_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, COPY_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->copy_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->copy_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, PASTE_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->paste_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->paste_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, NAME_TAB_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->name_tab_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->name_tab_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, PREVIOUS_TAB_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->previous_tab_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->previous_tab_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, NEXT_TAB_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->next_tab_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->next_tab_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, MOVE_TAB_LEFT_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->move_tab_left_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->move_tab_left_accel);
w = GTK_WIDGET(gtk_builder_get_object(builder, MOVE_TAB_RIGHT_ACCEL));
gtk_entry_set_text(GTK_ENTRY(w), setting->move_tab_right_accel);
g_signal_connect(G_OBJECT(w), "focus-out-event",
G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->move_tab_right_accel);
g_object_unref(builder);
gtk_window_set_modal(GTK_WINDOW(GTK_DIALOG(dialog)), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(GTK_DIALOG(dialog)),
GTK_WINDOW(terminal->window));
int result = gtk_dialog_run(dialog);
/* Dismiss dialog. */
gtk_widget_destroy(GTK_WIDGET(dialog));
if (result == GTK_RESPONSE_OK)
{
set_setting(setting);
save_setting();
terminal_settings_apply_to_all(terminal);
}
else
{
free_setting(setting);
}
}
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);
}
/***********************************************************************
* Refresh *
***********************************************************************/
void widget_colorbutton_refresh(variable *var)
{
GdkColor color;
GList *element;
gchar *act;
gint initialised = FALSE;
guint alpha;
list_t *values = NULL;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
/* Get initialised state of widget */
if (g_object_get_data(G_OBJECT(var->Widget), "_initialised") != NULL)
initialised = (gint)g_object_get_data(G_OBJECT(var->Widget), "_initialised");
/* The <input> tag... */
act = attributeset_get_first(&element, var->Attributes, ATTR_INPUT);
while (act) {
if (input_is_shell_command(act))
widget_colorbutton_input_by_command(var, act + 8);
/* input file stock = "File:", input file = "File:/path/to/file" */
if (strncasecmp(act, "file:", 5) == 0 && strlen(act) > 5) {
if (!initialised) {
/* Check for file-monitor and create if requested */
widget_file_monitor_try_create(var, act + 5);
}
widget_colorbutton_input_by_file(var, act + 5);
}
act = attributeset_get_next(&element, var->Attributes, ATTR_INPUT);
}
/* The <item> tags... */
if (attributeset_is_avail(var->Attributes, ATTR_ITEM))
widget_colorbutton_input_by_items(var);
/* Initialise these only once at start-up */
if (!initialised) {
/* Apply directives */
if (attributeset_is_avail(var->Attributes, ATTR_LABEL))
fprintf(stderr, "%s(): <label> not implemented for this widget.\n",
__func__);
if (attributeset_is_avail(var->Attributes, ATTR_DEFAULT)) {
values = linecutter(g_strdup(attributeset_get_first(&element,
var->Attributes, ATTR_DEFAULT)), '|');
if (values->n_lines > 0) {
/* Parse the RGB value to create the necessary GdkColor.
* This function doesn't like trailing whitespace so it
* needs to be stripped first with g_strstrip() */
if (gdk_color_parse(g_strstrip(values->line[0]), &color)) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid colour found\n", __func__);
#endif
gtk_color_button_set_color(GTK_COLOR_BUTTON(var->Widget), &color);
}
}
if (values->n_lines > 1) {
/* Read alpha as an unsigned decimal integer */
if (sscanf(values->line[1], "%u", &alpha) == 1) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid alpha=%u found\n", __func__, alpha);
#endif
/* This requires use-alpha="true" */
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(var->Widget), alpha);
}
}
/* Free linecutter memory */
if (values) list_t_free(values);
}
if (attributeset_is_avail(var->Attributes, ATTR_HEIGHT))
fprintf(stderr, "%s(): <height> not implemented for this widget.\n",
__func__);
if (attributeset_is_avail(var->Attributes, ATTR_WIDTH))
fprintf(stderr, "%s(): <width> not implemented for this widget.\n",
__func__);
if ((attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "false")) ||
(attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "disabled")) || /* Deprecated */
(attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "no")) ||
(attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "0")))
gtk_widget_set_sensitive(var->Widget, FALSE);
/* Connect signals */
g_signal_connect(G_OBJECT(var->Widget), "color-set",
G_CALLBACK(on_any_widget_color_set_event), (gpointer)var->Attributes);
}
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
/* Initialize and display the preferences dialog. */
void terminal_preferences_dialog(GtkAction * action, LXTerminal * terminal)
{
Setting * setting = terminal->setting;
GtkBuilder * builder = gtk_builder_new();
if ( ! gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/lxterminal/lxterminal-preferences.ui", NULL))
{
g_object_unref(builder);
return;
}
GtkWidget * dialog = GTK_WIDGET(gtk_builder_get_object(builder, "lxterminal_preferences"));
gtk_window_set_title(GTK_WINDOW(dialog), _("LXTerminal"));
gtk_window_set_icon_from_file(GTK_WINDOW(dialog), PACKAGE_DATA_DIR "/pixmaps/lxterminal.png", NULL);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(preferences_dialog_response_event), terminal);
GtkWidget * w = GTK_WIDGET(gtk_builder_get_object(builder, "terminal_font"));
gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), setting->font_name);
g_signal_connect(G_OBJECT(w), "font-set", G_CALLBACK(preferences_dialog_font_set_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "background_color"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->background_color);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(w), setting->background_alpha);
g_signal_connect(G_OBJECT(w), "color-set", G_CALLBACK(preferences_dialog_background_color_set_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "foreground_color"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->foreground_color);
g_signal_connect(G_OBJECT(w), "color-set", G_CALLBACK(preferences_dialog_foreground_color_set_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "allow_bold"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->disallow_bold);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_allow_bold_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_blink"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_blink);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_cursor_blink_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_block"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->cursor_underline);
w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_underline"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_underline);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_cursor_underline_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "audible_bell"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->audible_bell);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_audible_bell_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "tab_position"));
gtk_combo_box_set_active(GTK_COMBO_BOX(w), terminal_tab_get_position_id(setting->tab_position));
g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(preferences_dialog_tab_position_changed_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "scrollback_lines"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), setting->scrollback);
g_signal_connect(G_OBJECT(w), "value-changed", G_CALLBACK(preferences_dialog_scrollback_value_changed_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_scroll_bar"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_scroll_bar);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_scroll_bar_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_menu_bar"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_menu_bar);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_menu_bar_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_close_button"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_close_button);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_hide_close_button_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "select_by_word"));
gtk_entry_set_text(GTK_ENTRY(w), setting->word_selection_characters);
g_signal_connect(G_OBJECT(w), "focus-out-event", G_CALLBACK(preferences_dialog_selection_focus_out_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_f10"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_f10);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_disable_f10_toggled_event), terminal);
w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_alt"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_alt);
g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(preferences_dialog_disable_alt_toggled_event), terminal);
gtk_widget_show_all(dialog);
g_object_unref(builder);
}
