void settings(){
GtkWidget *window_settings;
GtkWidget *box_buttons;
GtkWidget *box_cbuttons1;
GtkWidget *box_cbuttons2;
GtkWidget * label_bg;
GtkWidget * label_fg;
GtkWidget* button_save;
GtkWidget* button_close;
window_settings = gtk_window_new(GTK_WINDOW_TOPLEVEL);
box_main = gtk_vbox_new(FALSE, 0);
box_buttons = gtk_hbox_new(FALSE, 0);
box_cbuttons1 = gtk_hbox_new(FALSE, 0);
box_cbuttons2 = gtk_hbox_new(FALSE, 0);
label_bg = gtk_label_new("Background : ");
gtk_box_pack_start (GTK_BOX(box_cbuttons1), label_bg, TRUE, FALSE, 5);
button_bcolor = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX(box_cbuttons1), button_bcolor, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(box_main), box_cbuttons1, TRUE, FALSE, 5);
label_fg = gtk_label_new("Foreground : ");
gtk_box_pack_start (GTK_BOX(box_cbuttons2), label_fg, TRUE, FALSE, 5);
button_fcolor = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX(box_cbuttons2), button_fcolor, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(box_main), box_cbuttons2, TRUE, FALSE, 5);
button_save = gtk_button_new_with_label("Save");
button_close = gtk_button_new_with_label("Close");
gtk_signal_connect (GTK_OBJECT (button_save), "clicked",
GTK_SIGNAL_FUNC (save), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_save, TRUE, FALSE, 5);
gtk_signal_connect (GTK_OBJECT (button_close), "clicked",
GTK_SIGNAL_FUNC (remove_vte), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_close, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_main), box_buttons, TRUE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (window_settings), box_main);
gtk_widget_show (label_fg);
gtk_widget_show (label_bg);
gtk_widget_show (box_cbuttons1);
gtk_widget_show (box_cbuttons2);
gtk_widget_show (button_bcolor);
gtk_widget_show (button_fcolor);
gtk_widget_show (button_save);
gtk_widget_show (button_close);
gtk_widget_show (box_buttons);
gtk_widget_show (box_main);
gtk_widget_show (window_settings);
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_bcolor), &bcolor);
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_fcolor), &fcolor);
}
static void
AddWidgets(GtkWidget * window)
{
GtkWidget *table, *label, *scale;
table = gtk_table_new(5, 4, TRUE);
gtk_container_add(GTK_CONTAINER(window), table);
label = gtk_label_new(_("Ambient colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
pcpAmbient = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpAmbient), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpAmbient, 1, 2, 0, 1);
label = gtk_label_new(_("Diffuse colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
pcpDiffuse = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpDiffuse), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpDiffuse, 1, 2, 1, 2);
label = gtk_label_new(_("Specular colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
pcpSpecular = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpSpecular), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpSpecular, 3, 4, 0, 1);
label = gtk_label_new(_("Shine:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 1, 2);
padjShine = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 128.0, 1.0, 10.0, 0.0));
g_signal_connect(G_OBJECT(padjShine), "value-changed", G_CALLBACK(UpdateColourPreview), NULL);
scale = gtk_hscale_new(padjShine);
gtk_scale_set_digits(GTK_SCALE(scale), 0);
gtk_table_attach_defaults(GTK_TABLE(table), scale, 3, 4, 1, 2);
pOpacitylabel = gtk_label_new(_("Opacity:"));
gtk_table_attach_defaults(GTK_TABLE(table), pOpacitylabel, 0, 1, 2, 3);
padjOpacity = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 1.0, 100.0, 1.0, 10.0, 0.0));
g_signal_connect(G_OBJECT(padjOpacity), "value-changed", G_CALLBACK(UpdateColourPreview), NULL);
psOpacity = gtk_hscale_new(padjOpacity);
gtk_scale_set_digits(GTK_SCALE(psOpacity), 0);
gtk_table_attach_defaults(GTK_TABLE(table), psOpacity, 1, 2, 2, 3);
pTexturelabel = gtk_label_new(_("Texture:"));
gtk_table_attach_defaults(GTK_TABLE(table), pTexturelabel, 2, 3, 2, 3);
textureComboBox = GTK_WIDGET(gtk_combo_box_text_new());
texture_set_active();
gtk_widget_set_sensitive(textureComboBox, FALSE);
g_signal_connect(textureComboBox, "changed", G_CALLBACK(TextureChange), NULL);
gtk_table_attach_defaults(GTK_TABLE(table), textureComboBox, 2, 4, 3, 4);
label = gtk_label_new(_("Preview:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
pwPreview = CreateGLPreviewWidget(&col3d);
gtk_table_attach_defaults(GTK_TABLE(table), pwPreview, 0, 2, 4, 5);
}
int main(void)
{
GtkWidget *mainwin;
GtkWidget *grid;
gtk_init(NULL, NULL);
mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(mainwin), "Foreground Colors with CSS");
gtk_container_set_border_width(GTK_CONTAINER(mainwin), 12);
g_signal_connect(mainwin, "delete-event", G_CALLBACK(quit), NULL);
grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
gtk_container_add(GTK_CONTAINER(mainwin), grid);
button = gtk_button_new_with_label("Color Me!");
gtk_widget_set_hexpand(button, TRUE);
gtk_widget_set_halign(button, GTK_ALIGN_FILL);
gtk_widget_set_vexpand(button, TRUE);
gtk_widget_set_halign(button, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
button, NULL,
GTK_POS_BOTTOM, 1, 1);
foreground = gtk_color_button_new();
g_signal_connect(foreground, "color-set", G_CALLBACK(changeColor), NULL);
gtk_widget_set_hexpand(foreground, TRUE);
gtk_widget_set_halign(foreground, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
foreground, button,
GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid),
gtk_label_new("Foreground"), foreground,
GTK_POS_LEFT, 1, 1);
background = gtk_color_button_new();
g_signal_connect(background, "color-set", G_CALLBACK(changeColor), NULL);
gtk_widget_set_hexpand(background, TRUE);
gtk_widget_set_halign(background, GTK_ALIGN_FILL);
gtk_grid_attach_next_to(GTK_GRID(grid),
background, foreground,
GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid),
gtk_label_new("Background"), background,
GTK_POS_LEFT, 1, 1);
gtk_widget_show_all(mainwin);
gtk_main();
return 0;
}
GtkWidget *colorbutton_new(GjayApp *gjay)
{
GtkWidget *widget;
widget = gtk_color_button_new();
return widget;
}
GtkWidget *
setup_toolarea (TboToolText *self)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *font_color_label = gtk_label_new (_("Text color:"));
GtkWidget *font_label = gtk_label_new (_("Font:"));
GtkWidget *scroll;
GtkWidget *view;
gtk_misc_set_alignment (GTK_MISC (font_label), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_color_label), 0, 0);
self->font = gtk_font_button_new ();
g_signal_connect (self->font, "font-set", G_CALLBACK (on_font_change), self);
self->font_color = gtk_color_button_new ();
g_signal_connect (self->font_color, "color-set", G_CALLBACK (on_color_change), self);
vbox = gtk_vbox_new (FALSE, 5);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), font_label, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox), self->font, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), font_color_label, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox), self->font_color, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
view = gtk_text_view_new ();
gtk_widget_add_events (view, GDK_FOCUS_CHANGE_MASK);
g_signal_connect (view, "focus-in-event", G_CALLBACK (on_tview_focus_in), self);
g_signal_connect (view, "focus-out-event", G_CALLBACK (on_tview_focus_out), self);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
self->text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (self->text_buffer, "", -1);
g_signal_connect (self->text_buffer, "changed", G_CALLBACK (on_text_change), self);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), view);
gtk_box_pack_start (GTK_BOX (vbox), scroll, FALSE, FALSE, 5);
return vbox;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *colorbutton = gtk_color_button_new();
g_signal_connect(colorbutton, "color-set", G_CALLBACK(color_set), (gpointer) colorbutton);
gtk_container_add(GTK_CONTAINER(window), colorbutton);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
/***********************************************************************
* Create *
***********************************************************************/
GtkWidget *widget_colorbutton_create(
AttributeSet *Attr, tag_attr *attr, gint Type)
{
GtkWidget *widget;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
widget = gtk_color_button_new();
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
return widget;
}
static VALUE
colorbutton_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE color;
GtkWidget* widget;
rb_scan_args(argc, argv, "01", &color);
if (NIL_P(color)){
widget = gtk_color_button_new();
} else {
widget = gtk_color_button_new_with_color(RVAL2GDKCOLOR(color));
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
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 GtkWidget*
web_view_create_plugin_widget_cb (GtkWidget* web_view,
const gchar* mime_type,
const gchar* uri,
GHashTable* param,
gpointer userdata)
{
if (g_str_equal (mime_type, "application/x-gtk-color-button"))
{
GtkWidget* button = gtk_color_button_new ();
GdkColor color;
gdk_color_parse ("#EF8E3A", &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (button), &color);
g_signal_connect (button, "color-set",
G_CALLBACK (color_button_color_set_cb), web_view);
return button;
}
return NULL;
}
GtkWidget *
do_paint (GtkWidget *toplevel)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *draw_area, *headerbar, *colorbutton;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
draw_area = drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), draw_area);
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Paint");
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (headerbar), TRUE);
colorbutton = gtk_color_button_new ();
g_signal_connect (colorbutton, "color-set",
G_CALLBACK (color_button_color_set), draw_area);
g_signal_connect (draw_area, "color-set",
G_CALLBACK (drawing_area_color_set), colorbutton);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (colorbutton),
&(GdkRGBA) { 0, 0, 0, 1 });
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton);
gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
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;
}
int
clip_GTK_COLORBUTTONNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
wid = gtk_color_button_new();
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
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 add_color_alpha_value(gchar * caption, gchar * basekey, gchar * sect, gboolean active)
{
GtkWidget * w;
gchar * colorkey;
gchar * alphakey;
colorkey = g_strdup_printf(active?"active_%s":"inactive_%s",basekey);
alphakey = g_strdup_printf(active?"active_%s_alpha":"inactive_%s_alpha",
basekey);
w = gtk_label_new(caption);
table_append(w,FALSE);
w = gtk_color_button_new();
table_append(w,FALSE);
register_setting(w,ST_COLOR,sect,colorkey);
w = scaler_new(0.0,1.0,0.01);
table_append(w,TRUE);
register_setting(w,ST_FLOAT,sect,alphakey);
//we don't g_free because they are registered with register_setting
}
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;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE color;
GtkWidget* widget;
rb_scan_args(argc, argv, "01", &color);
if (NIL_P(color)){
widget = gtk_color_button_new();
} else {
GType gtype = RVAL2GTYPE(color);
if (gtype == GDK_TYPE_COLOR) {
widget = gtk_color_button_new_with_color(RVAL2GDKCOLOR(color));
} else {
widget = gtk_color_button_new_with_rgba(RVAL2GDKRGBA(color));
}
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
static void
warlock_color_button_init (WarlockColorButton *button)
{
button->check_button = gtk_check_button_new ();
button->color_button = gtk_color_button_new ();
button->active = FALSE;
button->color = g_new (GdkRGBA, 1);
gtk_box_pack_start (GTK_BOX (button), button->check_button, FALSE,
TRUE, 0);
gtk_box_pack_start (GTK_BOX (button), button->color_button, FALSE,
TRUE, 0);
g_signal_connect (G_OBJECT (button->check_button), "toggled",
G_CALLBACK (warlock_color_button_toggled), button);
g_signal_connect (G_OBJECT (button->color_button), "color-set",
G_CALLBACK (warlock_color_button_color_changed),
button);
warlock_color_button_set_active (button, FALSE);
gtk_widget_show (button->color_button);
gtk_widget_show (button->check_button);
}
/**
* rstto_preferences_dialog_init:
* @dialog: The PreferencesDialog, used for configuring ristretto
* properties.
*
*
* This function initializes the preferences-dialog.
*
*
* get_properties ()
*
* configure_display_tab
*
* background_color_frame
*
* quality_frame
*
* configure_fullscreen_tab
*
* clock_frame
*
* thumbnails_frame
*
* configure_slideshow_tab
*
* slideshow_timeout_frame
*
* configure_control_tab
*
* scrollwheel_frame
*
* configure_behaviour_tab
*
* startup_frame
*
* desktop_frame
*/
static void
rstto_preferences_dialog_init ( RsttoPreferencesDialog *dialog )
{
/* Variable Section */
gboolean bool_invert_zoom_direction;
gboolean bool_bgcolor_override;
guint uint_slideshow_timeout;
gboolean bool_hide_thumbnails_fullscreen;
gboolean bool_wrap_images;
gboolean bool_maximize_on_startup;
gboolean bool_show_clock;
gboolean bool_limit_quality;
gchar *str_desktop_type = NULL;
GdkColor *bgcolor;
GtkWidget *timeout_lbl, *timeout_hscale;
GtkWidget *display_main_vbox;
GtkWidget *display_main_lbl;
GtkWidget *fullscreen_main_vbox;
GtkWidget *fullscreen_main_lbl;
GtkWidget *slideshow_main_vbox;
GtkWidget *slideshow_main_lbl;
GtkWidget *control_main_vbox;
GtkWidget *control_main_lbl;
GtkWidget *behaviour_main_vbox;
GtkWidget *behaviour_main_lbl;
GtkWidget *behaviour_desktop_lbl;
GtkWidget *notebook = gtk_notebook_new ();
/* Code Section */
dialog->priv = g_new0 (RsttoPreferencesDialogPriv, 1);
dialog->priv->settings = rstto_settings_new ();
/*
* Get all properties from the ristretto settings container
*/
g_object_get (
G_OBJECT (dialog->priv->settings),
"invert-zoom-direction", &bool_invert_zoom_direction,
"bgcolor-override", &bool_bgcolor_override,
"bgcolor", &bgcolor,
"slideshow-timeout", &uint_slideshow_timeout,
"hide-thumbnails-fullscreen", &bool_hide_thumbnails_fullscreen,
"maximize-on-startup", &bool_maximize_on_startup,
"wrap-images", &bool_wrap_images,
"desktop-type", &str_desktop_type,
"show-clock", &bool_show_clock,
"limit-quality", &bool_limit_quality,
NULL);
/*
* Configure the display tab
*/
display_main_vbox = gtk_vbox_new(FALSE, 0);
display_main_lbl = gtk_label_new(_("Display"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), display_main_vbox, display_main_lbl);
/**
* Bg-color frame
*/
dialog->priv->display_tab.bgcolor_vbox = gtk_vbox_new (FALSE, 0);
dialog->priv->display_tab.bgcolor_frame = xfce_gtk_frame_box_new_with_content(_("Background color"),
dialog->priv->display_tab.bgcolor_vbox);
gtk_box_pack_start (GTK_BOX (display_main_vbox), dialog->priv->display_tab.bgcolor_frame, FALSE, FALSE, 0);
dialog->priv->display_tab.bgcolor_override_check_button = gtk_check_button_new_with_label (_("Override background color:"));
dialog->priv->display_tab.bgcolor_hbox = gtk_hbox_new (FALSE, 4);
dialog->priv->display_tab.bgcolor_color_button = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_hbox),
dialog->priv->display_tab.bgcolor_override_check_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_hbox),
dialog->priv->display_tab.bgcolor_color_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_vbox),
dialog->priv->display_tab.bgcolor_hbox, FALSE, FALSE, 0);
/* set current value */
gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->priv->display_tab.bgcolor_color_button),
bgcolor);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->display_tab.bgcolor_override_check_button),
bool_bgcolor_override);
gtk_widget_set_sensitive (GTK_WIDGET (dialog->priv->display_tab.bgcolor_color_button),
bool_bgcolor_override);
/* connect signals */
g_signal_connect (G_OBJECT (dialog->priv->display_tab.bgcolor_override_check_button),
"toggled", (GCallback)cb_bgcolor_override_toggled, dialog);
g_signal_connect (G_OBJECT (dialog->priv->display_tab.bgcolor_color_button),
"color-set", G_CALLBACK (cb_bgcolor_color_set), dialog);
dialog->priv->display_tab.quality_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->display_tab.quality_frame = xfce_gtk_frame_box_new_with_content(_("Quality"), dialog->priv->display_tab.quality_vbox);
gtk_box_pack_start (GTK_BOX (display_main_vbox), dialog->priv->display_tab.quality_frame, FALSE, FALSE, 0);
dialog->priv->display_tab.quality_label = gtk_label_new (
_("With this option enabled, the maximum image-quality will be limited to the screen-size."));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->display_tab.quality_label), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->display_tab.quality_label), 0, 0.5);
dialog->priv->display_tab.quality_button = gtk_check_button_new_with_label (_("Limit rendering quality"));
gtk_container_add (GTK_CONTAINER (dialog->priv->display_tab.quality_vbox), dialog->priv->display_tab.quality_label);
gtk_container_add (GTK_CONTAINER (dialog->priv->display_tab.quality_vbox), dialog->priv->display_tab.quality_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->display_tab.quality_button), bool_limit_quality);
g_signal_connect (G_OBJECT (dialog->priv->display_tab.quality_button),
"toggled", (GCallback)cb_limit_quality_check_button_toggled, dialog);
/*
* Fullscreen tab
*/
fullscreen_main_vbox = gtk_vbox_new(FALSE, 0);
fullscreen_main_lbl = gtk_label_new(_("Fullscreen"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), fullscreen_main_vbox, fullscreen_main_lbl);
dialog->priv->fullscreen_tab.thumbnail_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->fullscreen_tab.thumbnail_frame = xfce_gtk_frame_box_new_with_content(_("Thumbnails"), dialog->priv->fullscreen_tab.thumbnail_vbox);
gtk_box_pack_start (GTK_BOX (fullscreen_main_vbox), dialog->priv->fullscreen_tab.thumbnail_frame, FALSE, FALSE, 0);
dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl = gtk_label_new(_("The thumbnail bar can be automatically hidden when the window is fullscreen."));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl), 0, 0.5);
dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button = gtk_check_button_new_with_label (_("Hide thumbnail bar when fullscreen"));
gtk_box_pack_start (GTK_BOX (dialog->priv->fullscreen_tab.thumbnail_vbox), dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->fullscreen_tab.thumbnail_vbox), dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button),
bool_hide_thumbnails_fullscreen);
dialog->priv->fullscreen_tab.clock_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->fullscreen_tab.clock_frame = xfce_gtk_frame_box_new_with_content(_("Clock"), dialog->priv->fullscreen_tab.clock_vbox);
gtk_box_pack_start (GTK_BOX (fullscreen_main_vbox), dialog->priv->fullscreen_tab.clock_frame, FALSE, FALSE, 0);
dialog->priv->fullscreen_tab.clock_label = gtk_label_new ( _("Show an analog clock that displays the current time when the window is fullscreen"));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->fullscreen_tab.clock_label), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->fullscreen_tab.clock_label), 0, 0.5);
dialog->priv->fullscreen_tab.clock_button = gtk_check_button_new_with_label (_("Show Fullscreen Clock"));
gtk_container_add (GTK_CONTAINER (dialog->priv->fullscreen_tab.clock_vbox), dialog->priv->fullscreen_tab.clock_label);
gtk_container_add (GTK_CONTAINER (dialog->priv->fullscreen_tab.clock_vbox), dialog->priv->fullscreen_tab.clock_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->fullscreen_tab.clock_button), bool_show_clock);
g_signal_connect (G_OBJECT (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button),
"toggled", (GCallback)cb_hide_thumbnails_fullscreen_check_button_toggled, dialog);
g_signal_connect (G_OBJECT (dialog->priv->fullscreen_tab.clock_button),
"toggled", (GCallback)cb_show_clock_check_button_toggled, dialog);
/*
* Slideshow tab
*/
slideshow_main_vbox = gtk_vbox_new(FALSE, 0);
slideshow_main_lbl = gtk_label_new(_("Slideshow"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), slideshow_main_vbox, slideshow_main_lbl);
dialog->priv->slideshow_tab.timeout_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->slideshow_tab.timeout_frame = xfce_gtk_frame_box_new_with_content(_("Timeout"), dialog->priv->slideshow_tab.timeout_vbox);
gtk_box_pack_start (GTK_BOX (slideshow_main_vbox), dialog->priv->slideshow_tab.timeout_frame, FALSE, FALSE, 0);
timeout_lbl = gtk_label_new(_("The time period an individual image is displayed during a slideshow\n(in seconds)"));
timeout_hscale = gtk_hscale_new_with_range(1, 60, 1);
gtk_misc_set_alignment(GTK_MISC(timeout_lbl), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(timeout_lbl), 2, 2);
gtk_box_pack_start(GTK_BOX(dialog->priv->slideshow_tab.timeout_vbox), timeout_lbl, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(dialog->priv->slideshow_tab.timeout_vbox), timeout_hscale, FALSE, TRUE, 0);
gtk_range_set_value (GTK_RANGE (timeout_hscale), (gdouble)uint_slideshow_timeout);
g_signal_connect (
G_OBJECT (timeout_hscale),
"value-changed",
(GCallback)cb_slideshow_timeout_value_changed,
dialog);
control_main_vbox = gtk_vbox_new(FALSE, 0);
control_main_lbl = gtk_label_new(_("Control"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), control_main_vbox, control_main_lbl);
dialog->priv->control_tab.scroll_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->control_tab.scroll_frame = xfce_gtk_frame_box_new_with_content(_("Scroll wheel"), dialog->priv->control_tab.scroll_vbox);
gtk_box_pack_start (GTK_BOX (control_main_vbox), dialog->priv->control_tab.scroll_frame, FALSE, FALSE, 0);
dialog->priv->control_tab.zoom_invert_check_button = gtk_check_button_new_with_label (_("Invert zoom direction"));
gtk_container_add (GTK_CONTAINER (dialog->priv->control_tab.scroll_vbox), dialog->priv->control_tab.zoom_invert_check_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->control_tab.zoom_invert_check_button), bool_invert_zoom_direction);
g_signal_connect (
G_OBJECT (dialog->priv->control_tab.zoom_invert_check_button),
"toggled",
(GCallback)cb_invert_zoom_direction_check_button_toggled,
dialog);
/*
* Behaviour tab
*/
behaviour_main_vbox = gtk_vbox_new(FALSE, 0);
behaviour_main_lbl = gtk_label_new(_("Behaviour"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), behaviour_main_vbox, behaviour_main_lbl);
/********************************************/
dialog->priv->behaviour_tab.startup_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->behaviour_tab.startup_frame = xfce_gtk_frame_box_new_with_content(_("Startup"), dialog->priv->behaviour_tab.startup_vbox);
gtk_box_pack_start (GTK_BOX (behaviour_main_vbox), dialog->priv->behaviour_tab.startup_frame, FALSE, FALSE, 0);
dialog->priv->behaviour_tab.maximize_window_on_startup_check_button = gtk_check_button_new_with_label (_("Maximize window on startup when opening an image"));
gtk_container_add (GTK_CONTAINER (dialog->priv->behaviour_tab.startup_vbox), dialog->priv->behaviour_tab.maximize_window_on_startup_check_button);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (dialog->priv->behaviour_tab.maximize_window_on_startup_check_button),
bool_maximize_on_startup);
dialog->priv->behaviour_tab.wrap_images_check_button = gtk_check_button_new_with_label (_("Wrap around images"));
gtk_container_add (GTK_CONTAINER (dialog->priv->behaviour_tab.startup_vbox), dialog->priv->behaviour_tab.wrap_images_check_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->behaviour_tab.wrap_images_check_button),
bool_wrap_images);
g_signal_connect (
G_OBJECT (dialog->priv->behaviour_tab.wrap_images_check_button),
"toggled",
(GCallback)cb_wrap_images_check_button_toggled,
dialog);
g_signal_connect (
G_OBJECT (dialog->priv->behaviour_tab.maximize_window_on_startup_check_button),
"toggled",
(GCallback)cb_maximize_on_startup_check_button_toggled,
dialog);
/********************************************/
dialog->priv->behaviour_tab.desktop_vbox = gtk_vbox_new(FALSE, 4);
dialog->priv->behaviour_tab.desktop_frame = xfce_gtk_frame_box_new_with_content(
_("Desktop"),
dialog->priv->behaviour_tab.desktop_vbox);
gtk_box_pack_start (
GTK_BOX (behaviour_main_vbox),
dialog->priv->behaviour_tab.desktop_frame,
FALSE,
FALSE,
0);
behaviour_desktop_lbl = gtk_label_new(NULL);
gtk_label_set_markup (
GTK_LABEL (behaviour_desktop_lbl),
_("Configure which system is currently managing your desktop.\n"
"This setting determines the method <i>Ristretto</i> will use\n"
"to configure the desktop wallpaper."));
gtk_misc_set_alignment(
GTK_MISC(behaviour_desktop_lbl),
0,
0.5);
gtk_box_pack_start (
GTK_BOX (dialog->priv->behaviour_tab.desktop_vbox),
behaviour_desktop_lbl,
FALSE,
FALSE,
0);
dialog->priv->behaviour_tab.choose_desktop_combo_box =
gtk_combo_box_new_text();
gtk_box_pack_start (
GTK_BOX (dialog->priv->behaviour_tab.desktop_vbox),
dialog->priv->behaviour_tab.choose_desktop_combo_box,
FALSE,
FALSE,
0);
gtk_combo_box_insert_text(
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_NONE,
_("None"));
gtk_combo_box_insert_text (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE,
_("Xfce"));
gtk_combo_box_insert_text (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_GNOME,
_("GNOME"));
if (str_desktop_type != NULL)
{
if (0 == g_ascii_strcasecmp (str_desktop_type, "xfce"))
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE);
}
else
{
if (0 == g_ascii_strcasecmp (str_desktop_type, "gnome"))
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_GNOME);
}
else
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_NONE);
}
}
}
else
{
/* Default, set it to xfce */
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE);
}
g_signal_connect (
G_OBJECT(dialog->priv->behaviour_tab.choose_desktop_combo_box),
"changed",
(GCallback)cb_choose_desktop_combo_box_changed,
dialog);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), notebook);
gtk_widget_show_all (notebook);
/* Window should not be resizable */
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_OK);
}
ButtonConfigGui::ButtonConfigGui(SettingsDialog* dlg, GtkWidget* w, Settings* settings, int button, bool withDevice)
{
XOJ_INIT_TYPE(ButtonConfigGui);
this->settings = settings;
this->button = button;
this->withDevice = withDevice;
GtkWidget* table = gtk_table_new(8, 2, false);
if (withDevice)
{
this->cbDevice = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDevice), _C("No device"));
GList* devices = gdk_devices_list();
for (GList* l = devices; l != NULL; l = l->next)
{
GdkDevice* dev = (GdkDevice*) l->data;
string devType = "";
if (dev->source == GDK_SOURCE_MOUSE)
{
devType = _("mouse");
}
else if (dev->source == GDK_SOURCE_PEN)
{
devType = _("pen");
}
else if (dev->source == GDK_SOURCE_ERASER)
{
devType = _("eraser");
}
else if (dev->source == GDK_SOURCE_CURSOR)
{
devType = _("cursor");
}
char* txt = g_strdup_printf("%s (%s)", dev->name, devType.c_str());
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDevice), txt);
g_free(txt);
}
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Device")), 0, 1, 0, 1, GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), this->cbDevice, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
cbDisableDrawing = gtk_check_button_new_with_label(_C("Disable drawing for this device"));
gtk_table_attach(GTK_TABLE(table), cbDisableDrawing, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
}
else
{
this->cbDevice = NULL;
this->cbDisableDrawing = NULL;
}
GtkListStore* typeModel = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
GtkTreeIter iter;
ADD_TYPE_CB("empty.svg", _C("Don't change"), TOOL_NONE);
ADD_TYPE_CB("tool_pencil.svg", _C("Pen"), TOOL_PEN);
ADD_TYPE_CB("tool_eraser.svg", _C("Eraser"), TOOL_ERASER);
ADD_TYPE_CB("tool_highlighter.png", _C("Hilighter"), TOOL_HILIGHTER);
ADD_TYPE_CB("tool_text.svg", _C("Text"), TOOL_TEXT);
ADD_TYPE_CB("tool_image.svg", _C("Insert image"), TOOL_IMAGE);
ADD_TYPE_CB("stretch.svg", _C("Vertical space"), TOOL_VERTICAL_SPACE);
ADD_TYPE_CB("lasso.svg", _C("Select region"), TOOL_SELECT_REGION);
ADD_TYPE_CB("rect-select.svg", _C("Select rectangle"), TOOL_SELECT_RECT);
//ADD_TYPE_CB("rect-draw.svg", _C("Draw rectangle"), TOOL_DRAW_RECT);
//ADD_TYPE_CB("circle-draw.svg", _C("Draw circle"), TOOL_DRAW_CIRCLE);
ADD_TYPE_CB("hand.svg", _C("Hand"), TOOL_HAND);
GtkCellRenderer* renderer = NULL;
this->cbTool = gtk_combo_box_new_with_model(GTK_TREE_MODEL(typeModel));
g_signal_connect(cbTool, "changed", G_CALLBACK(&cbSelectCallback), this);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(this->cbTool), renderer, false);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(this->cbTool), renderer, "pixbuf", 0, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(this->cbTool), renderer, true);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(this->cbTool), renderer, "text", 1, NULL);
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Tool")), 0, 1, 2, 3, GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), cbTool, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
this->cbThickness = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Don't change"));
gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Thin"));
gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Medium"));
gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Thick"));
gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 0);
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Thickness")), 0, 1, 3, 4,
GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), this->cbThickness, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
this->colorButton = gtk_color_button_new();
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Color")), 0, 1, 4, 5, GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), colorButton, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
this->cbDrawingType = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Don't change"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Enable Ruler"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Enable Stroke Recognizer"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Disable Ruler & Stroke Recognizer"));
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Ruler & Stroke Reco.")), 0, 1, 5, 6, GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), this->cbDrawingType, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
this->cbEraserType = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Don't change"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Standard"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Whiteout"));
gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Delete stroke"));
gtk_table_attach(GTK_TABLE(table), newLabel(_C("Eraser type")), 0, 1, 8, 9, GTK_FILL, GTK_FILL, 20, 0);
gtk_table_attach(GTK_TABLE(table), this->cbEraserType, 1, 2, 8, 9,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_container_add(GTK_CONTAINER(w), table);
gtk_widget_show_all(table);
loadSettings();
}
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;
}
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);
}
/* public functions */
GtkWidget *
asgtk_gradient_new ()
{
ASGtkGradient *ge;
GtkWidget *main_vbox, *main_hbox;
GtkWidget *scrolled_window ;
GtkWidget *list_vbox ;
GtkWidget *frame, *hbox, *vbox, *btn, *table;
GtkWidget *label ;
ge = g_object_new (ASGTK_TYPE_GRADIENT, NULL);
colorize_gtk_window( GTK_WIDGET(ge) );
gtk_container_set_border_width( GTK_CONTAINER (ge), 5 );
main_vbox = GTK_DIALOG(ge)->vbox ;
main_hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (main_hbox);
gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, TRUE, TRUE, 0);
list_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), list_vbox, FALSE, FALSE, 0);
frame = gtk_frame_new("Gradient direction : ");
gtk_box_pack_start (GTK_BOX (list_vbox), frame, FALSE, FALSE, 5);
table = gtk_table_new( 2, 2, FALSE );
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 3);
ge->l2r_radio = gtk_radio_button_new_with_label( NULL, "Left to Right" );
gtk_table_attach_defaults (GTK_TABLE (table), ge->l2r_radio, 0, 1, 0, 1);
ge->t2b_radio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(ge->l2r_radio), "Top to Bottom" );
gtk_table_attach_defaults (GTK_TABLE (table), ge->t2b_radio, 0, 1, 1, 2);
ge->tl2br_radio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(ge->t2b_radio), "Top-Left to Bottom-Right" );
gtk_table_attach_defaults (GTK_TABLE (table), ge->tl2br_radio, 1, 2, 0, 1);
ge->bl2tr_radio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(ge->tl2br_radio), "Bottom-Left to Top-Right" );
gtk_table_attach_defaults (GTK_TABLE (table), ge->bl2tr_radio, 1, 2, 1, 2);
gtk_widget_show_all (table);
gtk_widget_show (table);
colorize_gtk_widget( frame, get_colorschemed_style_normal() );
g_signal_connect ((gpointer) ge->l2r_radio, "clicked", G_CALLBACK (on_direction_clicked), ge);
g_signal_connect ((gpointer) ge->tl2br_radio, "clicked", G_CALLBACK (on_direction_clicked), ge);
g_signal_connect ((gpointer) ge->t2b_radio, "clicked", G_CALLBACK (on_direction_clicked), ge);
g_signal_connect ((gpointer) ge->bl2tr_radio, "clicked", G_CALLBACK (on_direction_clicked), ge);
ge->screen_width_check = gtk_check_button_new_with_label("Use screen width");
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ge->screen_width_check), TRUE );
ge->width_entry = gtk_spin_button_new_with_range( 1, 10000, 1 );
gtk_widget_set_sensitive( ge->width_entry, FALSE );
ge->screen_height_check = gtk_check_button_new_with_label("Use screen height");
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ge->screen_height_check), TRUE );
ge->height_entry = gtk_spin_button_new_with_range( 1, 10000, 1 );
gtk_widget_set_sensitive( ge->height_entry, FALSE );
g_signal_connect ((gpointer) ge->screen_width_check, "clicked", G_CALLBACK (on_size_clicked), ge);
g_signal_connect ((gpointer) ge->screen_height_check, "clicked", G_CALLBACK (on_size_clicked), ge);
ge->size_frame = gtk_frame_new("Rendered gradient size : ");
gtk_box_pack_start (GTK_BOX (list_vbox), ge->size_frame, FALSE, FALSE, 5);
colorize_gtk_tree_view_window( GTK_WIDGET(ge->size_frame) );
table = gtk_table_new( 2, 4, FALSE );
gtk_container_set_border_width( GTK_CONTAINER (table), 3 );
gtk_container_add( GTK_CONTAINER(ge->size_frame), table );
gtk_table_attach_defaults (GTK_TABLE (table), gtk_label_new("Width : "), 0, 1, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (table), ge->width_entry, 1, 2, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (table), gtk_label_new("Height : "), 2, 3, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (table), ge->height_entry, 3, 4, 0, 1);
gtk_table_attach (GTK_TABLE (table), ge->screen_width_check, 0, 2, 1, 2, GTK_FILL, GTK_FILL, 10, 0);
gtk_table_attach (GTK_TABLE (table), ge->screen_height_check, 2, 4, 1, 2, GTK_FILL, GTK_FILL, 10, 0);
gtk_widget_show_all (table);
gtk_widget_show (table);
colorize_gtk_widget( ge->size_frame, get_colorschemed_style_normal() );
scrolled_window = asgtk_gradient_create_color_list( ge );
gtk_box_pack_start (GTK_BOX (list_vbox), scrolled_window, FALSE, FALSE, 0);
ge->color_entry = gtk_entry_new_with_max_length(24);
gtk_entry_set_width_chars( GTK_ENTRY(ge->color_entry), 16 );
#if 0
ge->color_preview = gtk_color_button_new();
g_signal_connect ((gpointer) ge->color_preview, "clicked", G_CALLBACK (on_color_preview_clicked), ge);
#else
ge->color_preview = gtk_image_new();
update_color_preview( ge, DEFAULT_COLOR_STR );
#endif
ge->offset_entry = gtk_spin_button_new_with_range( 0., 1., 0.05 );
frame = gtk_frame_new("Change point attributes : ");
gtk_box_pack_end (GTK_BOX (list_vbox), frame, FALSE, FALSE, 5);
colorize_gtk_tree_view_window( GTK_WIDGET(frame) );
vbox = gtk_vbox_new( FALSE, 5 );
gtk_container_add( GTK_CONTAINER(frame), vbox );
table = gtk_table_new( 4, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER (table), 3 );
// hbox = gtk_hbox_new( FALSE, 5 );
// gtk_container_set_border_width( GTK_CONTAINER (hbox), 3 );
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
label = gtk_label_new("Color : ");
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
label = gtk_label_new("Offset : ");
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 0, 1);
gtk_table_attach (GTK_TABLE (table), ge->color_entry, 1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 2, 2);
gtk_table_attach (GTK_TABLE (table), ge->offset_entry, 3, 4, 0, 1, GTK_SHRINK, GTK_SHRINK, 2, 2);
frame = gtk_frame_new(NULL);
colorize_gtk_tree_view_window( GTK_WIDGET(frame) );
gtk_widget_set_size_request( frame, COLOR_PREVIEW_WIDTH, COLOR_PREVIEW_HEIGHT );
gtk_container_set_border_width( GTK_CONTAINER (table), 0 );
gtk_container_add( GTK_CONTAINER(frame), ge->color_preview );
gtk_widget_show( ge->color_preview );
btn = gtk_button_new();
gtk_container_set_border_width( GTK_CONTAINER (btn), 0 );
//btn = gtk_button_new_with_label(" Color selector ");
colorize_gtk_widget( GTK_WIDGET(btn), get_colorschemed_style_button());
gtk_container_add (GTK_CONTAINER (btn), frame);
gtk_widget_show (frame);
g_signal_connect ((gpointer) frame, "size-allocate",
G_CALLBACK (color_preview_size_alloc), ge);
gtk_table_attach (GTK_TABLE (table), btn, 0, 2, 1, 2, GTK_FILL, GTK_SHRINK, 2, 2);
g_signal_connect ((gpointer) btn, "clicked", G_CALLBACK (on_color_clicked), ge);
gtk_widget_show_all (table);
gtk_widget_show (table);
hbox = gtk_hbox_new( FALSE, 5 );
gtk_container_set_border_width( GTK_CONTAINER (hbox), 3 );
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
ge->delete_btn = btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_widget_set_sensitive( ge->delete_btn, FALSE );
colorize_gtk_widget( GTK_WIDGET(btn), get_colorschemed_style_button());
gtk_box_pack_end (GTK_BOX (hbox), btn, FALSE, FALSE, 0);
g_signal_connect ((gpointer) btn, "clicked", G_CALLBACK (on_delete_point_clicked), ge);
btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
colorize_gtk_widget( GTK_WIDGET(btn), get_colorschemed_style_button());
gtk_box_pack_end (GTK_BOX (hbox), btn, FALSE, FALSE, 0);
g_signal_connect ((gpointer) btn, "clicked", G_CALLBACK (on_add_point_clicked), ge);
ge->apply_btn = btn = gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_widget_set_sensitive( ge->apply_btn, FALSE );
colorize_gtk_widget( GTK_WIDGET(btn), get_colorschemed_style_button());
gtk_box_pack_end (GTK_BOX (hbox), btn, FALSE, FALSE, 0);
g_signal_connect ((gpointer) btn, "clicked", G_CALLBACK (on_apply_point_clicked), ge);
gtk_widget_show_all (hbox);
gtk_widget_show (hbox);
/* The preview : */
ge->image_view = ASGTK_IMAGE_VIEW(asgtk_image_view_new());
gtk_widget_set_size_request (GTK_WIDGET(ge->image_view), PREVIEW_WIDTH, PREVIEW_HEIGHT);
gtk_box_pack_end (GTK_BOX (main_hbox), GTK_WIDGET(ge->image_view), TRUE, TRUE, 0);
asgtk_image_view_set_aspect ( ge->image_view,
get_screen_width(NULL), get_screen_height(NULL) );
asgtk_image_view_set_resize ( ge->image_view,
ASGTK_IMAGE_VIEW_SCALE_TO_VIEW|
ASGTK_IMAGE_VIEW_TILE_TO_ASPECT,
ASGTK_IMAGE_VIEW_RESIZE_ALL );
gtk_widget_show_all (list_vbox);
gtk_widget_show_all (main_hbox);
gtk_widget_hide(ge->image_view->details_label);
btn = gtk_check_button_new_with_label( "Use screen aspect ratio" );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(btn), TRUE );
gtk_widget_show (btn);
colorize_gtk_widget( btn, get_colorschemed_style_normal() );
g_signal_connect (G_OBJECT (btn), "toggled",
G_CALLBACK (asgtk_image_view_screen_aspect_toggle), (gpointer) ge->image_view);
gtk_button_set_alignment( GTK_BUTTON(btn), 1.0, 0.5);
asgtk_image_view_add_detail( ge->image_view, btn, 0 );
btn = gtk_check_button_new_with_label( "Scale to fit this view" );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(btn), TRUE );
gtk_widget_show (btn);
colorize_gtk_widget( btn, get_colorschemed_style_normal() );
g_signal_connect (G_OBJECT (btn), "toggled",
G_CALLBACK (asgtk_image_view_scale_to_view_toggle), (gpointer) ge->image_view);
gtk_button_set_alignment( GTK_BUTTON(btn), 1.0, 0.5);
asgtk_image_view_add_detail( ge->image_view, btn, 0 );
btn = asgtk_add_button_to_box( NULL, GTK_STOCK_REFRESH, NULL, G_CALLBACK(on_refresh_clicked), ge );
asgtk_image_view_add_tool( ge->image_view, btn, 3 );
LOCAL_DEBUG_OUT( "created image ASGtkGradient object %p", ge );
return GTK_WIDGET (ge);
}
/* Main UI */
GtkWidget *
pgd_annots_create_widget (PopplerDocument *document)
{
PgdAnnotsDemo *demo;
GtkWidget *label;
GtkWidget *vbox, *vbox2;
GtkWidget *button;
GtkWidget *hbox, *page_selector;
GtkWidget *hpaned;
GtkWidget *swindow, *treeview;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkListStore *model;
GtkTreeIter iter;
gchar *str;
gint n_pages;
gint i;
demo = g_new0 (PgdAnnotsDemo, 1);
demo->doc = g_object_ref (document);
demo->cursor = GDK_LAST_CURSOR;
demo->mode = MODE_NORMAL;
n_pages = poppler_document_get_n_pages (document);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
label = gtk_label_new ("Page:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
page_selector = gtk_spin_button_new_with_range (1, n_pages, 1);
g_signal_connect (G_OBJECT (page_selector), "value-changed",
G_CALLBACK (pgd_annots_page_selector_value_changed),
(gpointer) demo);
gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0);
gtk_widget_show (page_selector);
str = g_strdup_printf ("of %d", n_pages);
label = gtk_label_new (str);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
g_free (str);
demo->remove_button = gtk_button_new_with_mnemonic ("_Remove");
gtk_widget_set_sensitive (demo->remove_button, FALSE);
g_signal_connect (G_OBJECT (demo->remove_button), "clicked",
G_CALLBACK (pgd_annots_remove_annot),
(gpointer) demo);
gtk_box_pack_end (GTK_BOX (hbox), demo->remove_button, FALSE, FALSE, 6);
gtk_widget_show (demo->remove_button);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("_Add");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (pgd_annots_start_add_annot),
(gpointer) demo);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
model = gtk_list_store_new(SELECTED_N_COLUMNS,
G_TYPE_INT, G_TYPE_STRING);
for (i = 0; i < G_N_ELEMENTS (supported_annots); i++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
SELECTED_TYPE_COLUMN, supported_annots[i].type,
SELECTED_LABEL_COLUMN, supported_annots[i].label,
-1);
}
demo->type_selector = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (demo->type_selector), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (demo->type_selector), renderer,
"text", SELECTED_LABEL_COLUMN,
NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (demo->type_selector), 0);
gtk_box_pack_end (GTK_BOX (hbox), demo->type_selector, FALSE, FALSE, 0);
gtk_widget_show (demo->type_selector);
button = gtk_color_button_new ();
demo->annot_color.red = 65535;
demo->annot_color.alpha = 1.0;
#if GTK_CHECK_VERSION(3,4,0)
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_color);
#else
gtk_color_button_set_rgba (GTK_COLOR_BUTTON (button), &demo->annot_color);
#endif
g_signal_connect (button, "notify::color",
G_CALLBACK (pgd_annot_color_changed),
(gpointer)demo);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button);
gtk_widget_show (hbox);
demo->timer_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No annotations found</i>");
g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL);
gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0);
gtk_widget_show (demo->timer_label);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
demo->annot_view = pgd_annot_view_new ();
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_OBJECT);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model));
demo->tree_view = treeview;
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Type");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", ANNOTS_COLOR_COLUMN);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", ANNOTS_TYPE_COLUMN);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_annots_invisible_flag_toggled),
(gpointer) demo);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
ANNOTS_FLAG_INVISIBLE_COLUMN, "Invisible",
renderer,
"active", ANNOTS_FLAG_INVISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_annots_hidden_flag_toggled),
(gpointer) demo);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
ANNOTS_FLAG_HIDDEN_COLUMN, "Hidden",
renderer,
"active", ANNOTS_FLAG_HIDDEN_COLUMN,
NULL);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_annots_print_flag_toggled),
(gpointer) demo);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
ANNOTS_FLAG_PRINT_COLUMN, "Print",
renderer,
"active", ANNOTS_FLAG_PRINT_COLUMN,
NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (pgd_annots_selection_changed),
(gpointer) demo);
/* Annotation's list */
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
gtk_widget_show (swindow);
/* Annotation Properties */
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (swindow), demo->annot_view);
gtk_widget_show (demo->annot_view);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 6);
gtk_widget_show (swindow);
gtk_paned_add1 (GTK_PANED (hpaned), vbox2);
gtk_widget_show (vbox2);
/* Demo Area (Render) */
demo->darea = gtk_drawing_area_new ();
g_signal_connect (demo->darea, "draw",
G_CALLBACK (pgd_annots_view_drawing_area_draw),
demo);
g_signal_connect (demo->darea, "realize",
G_CALLBACK (pgd_annots_drawing_area_realize),
(gpointer)demo);
g_signal_connect (demo->darea, "button_press_event",
G_CALLBACK (pgd_annots_drawing_area_button_press),
(gpointer)demo);
g_signal_connect (demo->darea, "motion_notify_event",
G_CALLBACK (pgd_annots_drawing_area_motion_notify),
(gpointer)demo);
g_signal_connect (demo->darea, "button_release_event",
G_CALLBACK (pgd_annots_drawing_area_button_release),
(gpointer)demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
#if GTK_CHECK_VERSION(3, 7, 8)
gtk_container_add(GTK_CONTAINER(swindow), demo->darea);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea);
#endif
gtk_widget_show (demo->darea);
gtk_paned_add2 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_paned_set_position (GTK_PANED (hpaned), 300);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
g_object_weak_ref (G_OBJECT (vbox),
(GWeakNotify)pgd_annots_free,
demo);
pgd_annots_viewer_queue_redraw (demo);
pgd_annots_get_annots (demo);
demo->main_box = vbox;
return vbox;
}
static void
fcitx_config_widget_setup_ui(FcitxConfigWidget *self)
{
FcitxConfigFileDesc* cfdesc = self->cfdesc;
GtkWidget *cvbox = GTK_WIDGET(self);
GtkWidget *configNotebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(cvbox), configNotebook, TRUE, TRUE, 0);
if (cfdesc) {
bindtextdomain(cfdesc->domain, LOCALEDIR);
bind_textdomain_codeset(cfdesc->domain, "UTF-8");
FILE *fp;
fp = FcitxXDGGetFileWithPrefix(self->prefix, self->name, "r", NULL);
self->gconfig.configFile = FcitxConfigParseConfigFileFp(fp, cfdesc);
FcitxConfigGroupDesc *cgdesc = NULL;
FcitxConfigOptionDesc *codesc = NULL;
for (cgdesc = cfdesc->groupsDesc;
cgdesc != NULL;
cgdesc = (FcitxConfigGroupDesc*)cgdesc->hh.next) {
codesc = cgdesc->optionsDesc;
if (codesc == NULL)
continue;
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *table = gtk_table_new(2, HASH_COUNT(codesc), FALSE);
GtkWidget *plabel = gtk_label_new(D_(cfdesc->domain, cgdesc->groupName));
GtkWidget *scrollwnd = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(table), 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwnd), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwnd), table);
gtk_box_pack_start(GTK_BOX(hbox), scrollwnd, TRUE, TRUE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(configNotebook),
hbox,
plabel);
int i = 0;
for (; codesc != NULL;
codesc = (FcitxConfigOptionDesc*)codesc->hh.next, i++) {
const char *s;
if (codesc->desc && strlen(codesc->desc) != 0)
s = D_(cfdesc->domain, codesc->desc);
else
s = D_(cfdesc->domain, codesc->optionName);
GtkWidget *inputWidget = NULL;
void *argument = NULL;
switch (codesc->type) {
case T_Integer:
inputWidget = gtk_spin_button_new_with_range(-1.0, 10000.0, 1.0);
argument = inputWidget;
break;
case T_Color:
inputWidget = gtk_color_button_new();
argument = inputWidget;
break;
case T_Boolean:
inputWidget = gtk_check_button_new();
argument = inputWidget;
break;
case T_Font: {
inputWidget = gtk_hbox_new(FALSE, 0);
argument = gtk_font_button_new();
GtkWidget *button = gtk_button_new_with_label(_("Clear font setting"));
gtk_box_pack_start(GTK_BOX(inputWidget), argument, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button, FALSE, FALSE, 0);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(argument), FALSE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(argument), FALSE);
g_signal_connect(G_OBJECT(button), "clicked", (GCallback) set_none_font_clicked, argument);
}
break;
case T_Enum: {
int i;
FcitxConfigEnum *e = &codesc->configEnum;
#if GTK_CHECK_VERSION(2, 24, 0)
inputWidget = gtk_combo_box_text_new();
for (i = 0; i < e->enumCount; i ++) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(inputWidget), D_(cfdesc->domain, e->enumDesc[i]));
}
#else
inputWidget = gtk_combo_box_new_text();
for (i = 0; i < e->enumCount; i ++)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(inputWidget), D_(cfdesc->domain, e->enumDesc[i]));
}
#endif
argument = inputWidget;
}
break;
case T_Hotkey: {
GtkWidget *button[2];
button[0] = keygrab_button_new();
button[1] = keygrab_button_new();
inputWidget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button[0], FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(inputWidget), button[1], FALSE, TRUE, 0);
argument = g_array_new(FALSE, FALSE, sizeof(void*));
g_array_append_val(argument, button[0]);
g_array_append_val(argument, button[1]);
}
break;
case T_File:
case T_Char:
case T_String:
inputWidget = gtk_entry_new();
argument = inputWidget;
break;
default:
break;
}
if (inputWidget) {
GtkWidget* label = gtk_label_new(s);
g_object_set(label, "xalign", 0.0f, NULL);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i + 1, GTK_FILL, GTK_SHRINK, 5, 5);
gtk_table_attach(GTK_TABLE(table), inputWidget, 1, 2, i, i + 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 4);
FcitxConfigBindValue(self->gconfig.configFile, cgdesc->groupName, codesc->optionName, NULL, sync_filter, argument);
}
}
}
FcitxConfigBindSync(&self->gconfig);
}
if (self->parser) {
GHashTable* subconfigs = self->parser->subconfigs;
if (g_hash_table_size(subconfigs) != 0) {
GtkWidget *table = gtk_table_new(2, g_hash_table_size(subconfigs), FALSE);
GtkWidget *plabel = gtk_label_new(_("Other"));
GtkWidget *scrollwnd = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *viewport = gtk_viewport_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollwnd), viewport);
gtk_container_add(GTK_CONTAINER(viewport), table);
gtk_notebook_append_page(GTK_NOTEBOOK(configNotebook),
scrollwnd,
plabel);
HashForeachContext context;
context.i = 0;
context.table = table;
context.widget = self;
g_hash_table_foreach(subconfigs, hash_foreach_cb, &context);
}
}
gtk_widget_set_size_request(configNotebook, 500, -1);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(configNotebook), TRUE);
}
static GtkWidget *
create_selection_dir(GjayApp *gjay, struct SelectUI *sui)
{
GtkWidget *frame, *vbox, *top_hbox, *swin, *hbox2;
GtkWidget *dir_color, *dir_rating, *alignment;
GtkCellRenderer * text_renderer, * pixbuf_renderer;
GtkTreeViewColumn *column;
frame = gtk_frame_new(_("Directory Details"));
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize(frame, APP_WIDTH * 0.5, -1);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
top_hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), top_hbox, FALSE, FALSE, 0);
sui->dir_icon = gtk_image_new_from_pixbuf(
gjay_get_pixbuf(gjay, PM_ICON_CLOSED));
gtk_box_pack_start(GTK_BOX(top_hbox), sui->dir_icon, FALSE, FALSE, 0);
sui->dir_show = gjay_button_new_with_label_pixbuf(gjay, NULL,
PM_BUTTON_ALL);
gtk_widget_set_tooltip_text (sui->dir_show,
_("Select all songs in this directory"));
g_signal_connect(G_OBJECT(sui->dir_show), "clicked",
G_CALLBACK(dir_show_clicked), gjay);
gtk_box_pack_start(GTK_BOX(top_hbox), sui->dir_show, FALSE, FALSE, 0);
sui->dir_play = gjay_button_new_with_label_pixbuf(gjay, _("Play"),
PM_BUTTON_PLAY);
g_signal_connect(G_OBJECT(sui->dir_play), "clicked",
G_CALLBACK(dir_play_clicked), gjay);
gtk_box_pack_start(GTK_BOX(top_hbox), sui->dir_play, FALSE, FALSE, 0);
sui->dir_lbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox), sui->dir_lbox, TRUE, TRUE, 2);
sui->list_store = gtk_list_store_new(LAST_COLUMN, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_STRING);
sui->dir_tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (sui->list_store));
g_object_unref (G_OBJECT (sui->list_store));
text_renderer = gtk_cell_renderer_text_new ();
pixbuf_renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes ("Artist", text_renderer,
"text", ARTIST_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (sui->dir_tree), column);
column = gtk_tree_view_column_new_with_attributes ("Title", text_renderer,
"text", TITLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (sui->dir_tree), column);
column = gtk_tree_view_column_new_with_attributes ("Freq", pixbuf_renderer,
"pixbuf", FREQ_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (sui->dir_tree), column);
column = gtk_tree_view_column_new_with_attributes ("BPM", text_renderer,
"text", BPM_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (sui->dir_tree), column);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(swin), sui->dir_tree);
gtk_box_pack_start(GTK_BOX(sui->dir_lbox), swin, TRUE, TRUE, 2);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(sui->dir_lbox), hbox2, FALSE, FALSE, 2);
dir_color = gtk_color_button_new();
colorbutton_set_callback(GTK_COLOR_BUTTON(dir_color),
G_CALLBACK(dir_color_set),
gjay);
gtk_box_pack_start(GTK_BOX(hbox2), dir_color, FALSE, FALSE, 2);
alignment = gtk_alignment_new (0, 1, 0.1, 0.1);
gtk_box_pack_start(GTK_BOX(hbox2), alignment, FALSE, FALSE, 2);
dir_rating = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox2), dir_rating, TRUE, FALSE, 2);
return frame;
}
static GtkWidget *
create_selection_file(GjayApp *gjay, SelectUI *sui)
{
GtkWidget *frame, *label, *table, *vbox, *align, *top_hbox;
int i;
gchar *headings[] = {"Artist", "Title", "Freq", "BPM", "Color", 0};
frame = gtk_frame_new(_("Song Details"));
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize(frame, APP_WIDTH * 0.5, -1);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
top_hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), top_hbox, FALSE, FALSE, 0);
sui->song_icon = gtk_image_new_from_pixbuf(
gjay_get_pixbuf(gjay, PM_ICON_CLOSED));
gtk_box_pack_start(GTK_BOX(top_hbox), sui->song_icon, FALSE, FALSE, 0);
sui->song_play = gjay_button_new_with_label_pixbuf(gjay, _("Play"),
PM_BUTTON_PLAY);
g_signal_connect(G_OBJECT(sui->song_play), "clicked",
G_CALLBACK(song_play_clicked), gjay);
gtk_box_pack_start(GTK_BOX(top_hbox), sui->song_play, FALSE, FALSE, 0);
table = gtk_table_new(6, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
for(i=0; headings[i]; i++) {
gchar *buf;
label = gtk_label_new(NULL);
buf = g_strdup_printf("<b>%s</b>", headings[i]);
gtk_label_set_markup(GTK_LABEL(label), buf);
g_free(buf);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i+1,
GTK_FILL, GTK_FILL, 10, 5);
}
sui->song_artist = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_artist);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 0, 1);
sui->song_title = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_title);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 1, 2);
sui->song_freq = gtk_image_new_from_pixbuf(
gjay_get_pixbuf(gjay, PM_ICON_CLOSED));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_freq);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 2, 3);
sui->song_bpm = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_bpm);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 3, 4);
sui->song_color = gtk_color_button_new();
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_color);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 4, 5);
/* Rating is optional */
sui->rating_label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(sui->rating_label), "<b>Rating:</b>");
gtk_table_attach(GTK_TABLE(table), sui->rating_label, 0, 1, 5, 6,
GTK_FILL, GTK_FILL, 10, 5);
sui->song_rating = gtk_hscale_new_with_range(MIN_RATING,MAX_RATING, 0.2);
g_signal_connect (G_OBJECT(sui->song_rating), "value-changed",
G_CALLBACK (rating_changed), gjay);
align = gtk_alignment_new(0, 0.5, 1, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_rating);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 5, 6);
return frame;
}
/* 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));
}
/**
* show_properties_dialog
*
* Description:
* displays the properties dialog
**/
void
show_properties_dialog (void)
{
GtkWidget *notebook;
GtkWidget *cpage;
GtkWidget *gpage;
GtkWidget *kpage;
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *typemenu;
GtkWidget *pmapmenu;
GtkWidget *chkbox;
GtkWidget *table;
GtkWidget *dbut;
GtkWidget *frame;
GtkWidget *w;
GtkWidget *controls_list;
if (propbox)
return;
propbox = gtk_dialog_new_with_buttons (_("Robots Preferences"),
GTK_WINDOW (app),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (propbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (propbox), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (propbox)->vbox), 2);
/* Set up notebook and add it to hbox of the gtk_dialog */
g_signal_connect (G_OBJECT (propbox), "destroy",
G_CALLBACK (gtk_widget_destroyed), &propbox);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (propbox)->vbox), notebook,
TRUE, TRUE, 0);
/* The configuration page */
cpage = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (cpage), 12);
frame = games_frame_new (_("Game Type"));
gtk_box_pack_start (GTK_BOX (cpage), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
typemenu = gtk_combo_box_new_text ();
g_signal_connect (G_OBJECT (typemenu), "changed",
G_CALLBACK (type_selection), NULL);
fill_typemenu (typemenu);
gtk_box_pack_start (GTK_BOX (hbox), typemenu, TRUE, TRUE, 0);
frame = games_frame_new (_("Options"));
gtk_box_pack_start (GTK_BOX (cpage), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new (TRUE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
chkbox = gtk_check_button_new_with_mnemonic (_("_Use safe moves"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox),
properties.safe_moves);
g_signal_connect (G_OBJECT (chkbox), "clicked",
(GCallback) safe_cb, NULL);
gtk_box_pack_start (GTK_BOX (vbox), chkbox, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (chkbox,
_("Prevent accidental moves that result in getting killed."));
chkbox = gtk_check_button_new_with_mnemonic (_("U_se super safe moves"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox),
properties.super_safe_moves);
g_signal_connect (G_OBJECT (chkbox), "clicked",
(GCallback) super_safe_cb, NULL);
gtk_box_pack_start (GTK_BOX (vbox), chkbox, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (chkbox,
_("Prevents all moves that result in getting killed."));
frame = games_frame_new (_("Sound"));
gtk_box_pack_start (GTK_BOX (cpage), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new (TRUE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
chkbox = gtk_check_button_new_with_mnemonic (_("_Enable sounds"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox), properties.sound);
g_signal_connect (G_OBJECT (chkbox), "clicked",
(GCallback) sound_cb, NULL);
gtk_box_pack_start (GTK_BOX (vbox), chkbox, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (chkbox,
_("Play sounds for events like winning a level and dying."));
label = gtk_label_new_with_mnemonic (_("Game"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cpage, label);
/* The graphics page */
gpage = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (gpage), 12);
frame = games_frame_new (_("Graphics Theme"));
gtk_box_pack_start (GTK_BOX (gpage), frame, FALSE, FALSE, 0);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_container_add (GTK_CONTAINER (frame), table);
label = gtk_label_new_with_mnemonic (_("_Image theme:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
pmapmenu = make_theme_menu ();
g_signal_connect (G_OBJECT (pmapmenu), "changed",
G_CALLBACK (pmap_selection), NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), pmapmenu);
gtk_table_attach_defaults (GTK_TABLE (table), pmapmenu, 1, 2, 0, 1);
label = gtk_label_new_with_mnemonic (_("_Background color:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
w = gtk_color_button_new ();
gtk_color_button_set_color (GTK_COLOR_BUTTON (w), &properties.bgcolour);
g_signal_connect (G_OBJECT (w), "color_set",
G_CALLBACK (bg_color_callback), NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), w);
gtk_table_attach_defaults (GTK_TABLE (table), w, 1, 2, 1, 2);
label = gtk_label_new_with_mnemonic (_("Appearance"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), gpage, label);
/* The keyboard page */
kpage = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (kpage), 12);
frame = games_frame_new (_("Keyboard Controls"));
gtk_box_pack_start (GTK_BOX (kpage), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
controls_list = games_controls_list_new (KEY_PREFERENCES_GROUP);
games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list),
"key00", _("Key to move NW"), default_keys[0],
"key01", _("Key to move N"), default_keys[1],
"key02", _("Key to move NE"), default_keys[2],
"key03", _("Key to move W"), default_keys[3],
"key05", _("Key to move E"), default_keys[5],
"key06", _("Key to move SW"), default_keys[6],
"key07", _("Key to move S"), default_keys[7],
"key08", _("Key to move SE"), default_keys[8],
"key04", _("Key to hold"), default_keys[4],
"key09", _("Key to teleport"), default_keys[9],
"key10", _("Key to teleport randomly"), default_keys[10],
"key11", _("Key to wait"), default_keys[11],
NULL);
gtk_box_pack_start (GTK_BOX (vbox), controls_list, TRUE, TRUE, 0);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
dbut = gtk_button_new_with_mnemonic (_("_Restore Defaults"));
g_signal_connect (G_OBJECT (dbut), "clicked",
G_CALLBACK (defkey_cb), (gpointer) default_keys);
gtk_box_pack_start (GTK_BOX (hbox), dbut, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("Keyboard"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), kpage, label);
g_signal_connect (G_OBJECT (propbox), "delete_event",
G_CALLBACK (delete_cb), NULL);
g_signal_connect (G_OBJECT (propbox), "response",
G_CALLBACK (apply_cb), NULL);
gtk_window_set_modal (GTK_WINDOW (propbox), TRUE);
gtk_widget_show_all (propbox);
}
/**
* 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;
}
