2 * (SLIK) SimpLIstic sKin functions
4 * Copyright (C) 2008 - 2012 The Geeqie Team
8 * This software is released under the GNU General Public License (GNU GPL).
9 * Please read the included file COPYING for more information.
10 * This software comes with no warranty of any kind, use at your own risk!
23 #include <gdk/gdkkeysyms.h>
28 #include "history_list.h"
32 *-----------------------------------------------------------------------------
33 * widget and layout utilities
34 *-----------------------------------------------------------------------------
37 GtkWidget *pref_box_new(GtkWidget *parent_box, gboolean fill,
38 GtkOrientation orientation, gboolean padding)
42 if (orientation == GTK_ORIENTATION_HORIZONTAL)
44 box = gtk_hbox_new(FALSE, padding);
48 box = gtk_vbox_new(FALSE, padding);
51 gtk_box_pack_start(GTK_BOX(parent_box), box, fill, fill, 0);
57 GtkWidget *pref_group_new(GtkWidget *parent_box, gboolean fill,
58 const gchar *text, GtkOrientation orientation)
65 vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
67 /* add additional spacing if necessary */
68 if (GTK_IS_VBOX(parent_box))
70 GList *list = gtk_container_get_children(GTK_CONTAINER(parent_box));
73 pref_spacer(vbox, PREF_PAD_GROUP - PREF_PAD_GAP);
78 gtk_box_pack_start(GTK_BOX(parent_box), vbox, fill, fill, 0);
79 gtk_widget_show(vbox);
81 label = gtk_label_new(text);
82 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
83 pref_label_bold(label, TRUE, FALSE);
85 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
86 gtk_widget_show(label);
88 hbox = gtk_hbox_new(FALSE, PREF_PAD_INDENT);
89 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
90 gtk_widget_show(hbox);
92 /* indent using empty box */
95 if (orientation == GTK_ORIENTATION_HORIZONTAL)
97 box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
101 box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
103 gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 0);
104 gtk_widget_show(box);
106 g_object_set_data(G_OBJECT(box), "pref_group", vbox);
111 GtkWidget *pref_group_parent(GtkWidget *child)
120 group = g_object_get_data(G_OBJECT(parent), "pref_group");
121 if (group && GTK_IS_WIDGET(group)) return group;
123 parent = gtk_widget_get_parent(parent);
129 GtkWidget *pref_frame_new(GtkWidget *parent_box, gboolean fill,
131 GtkOrientation orientation, gboolean padding)
134 GtkWidget *frame = NULL;
136 frame = gtk_frame_new(text);
137 gtk_box_pack_start(GTK_BOX(parent_box), frame, fill, fill, 0);
138 gtk_widget_show(frame);
140 if (orientation == GTK_ORIENTATION_HORIZONTAL)
142 box = gtk_hbox_new(FALSE, padding);
146 box = gtk_vbox_new(FALSE, padding);
148 gtk_container_add(GTK_CONTAINER(frame), box);
149 gtk_container_set_border_width(GTK_CONTAINER(box), PREF_PAD_BORDER);
150 gtk_widget_show(box);
155 GtkWidget *pref_spacer(GtkWidget *parent_box, gboolean padding)
159 spacer = gtk_hbox_new(FALSE, 0);
160 gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
161 gtk_widget_show(spacer);
166 GtkWidget *pref_line(GtkWidget *parent_box, gboolean padding)
170 if (GTK_IS_HBOX(parent_box))
172 spacer = gtk_vseparator_new();
176 spacer = gtk_hseparator_new();
179 gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
180 gtk_widget_show(spacer);
185 GtkWidget *pref_label_new(GtkWidget *parent_box, const gchar *text)
189 label = gtk_label_new(text);
190 gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
191 gtk_widget_show(label);
196 GtkWidget *pref_label_new_mnemonic(GtkWidget *parent_box, const gchar *text, GtkWidget *widget)
200 label = gtk_label_new_with_mnemonic(text);
201 gtk_label_set_mnemonic_widget(GTK_LABEL(label), widget);
202 gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
203 gtk_widget_show(label);
208 void pref_label_bold(GtkWidget *label, gboolean bold, gboolean increase_size)
213 if (!bold && !increase_size) return;
215 pal = pango_attr_list_new();
219 pa = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
221 pa->end_index = G_MAXINT;
222 pango_attr_list_insert(pal, pa);
227 pa = pango_attr_scale_new(PANGO_SCALE_LARGE);
229 pa->end_index = G_MAXINT;
230 pango_attr_list_insert(pal, pa);
233 gtk_label_set_attributes(GTK_LABEL(label), pal);
234 pango_attr_list_unref(pal);
237 GtkWidget *pref_button_new(GtkWidget *parent_box, const gchar *stock_id,
238 const gchar *text, gboolean hide_stock_text,
239 GCallback func, gpointer data)
243 if (stock_id && !text && !hide_stock_text)
245 button = gtk_button_new_from_stock(stock_id);
249 GtkWidget *image = NULL;
250 GtkWidget *label = NULL;
252 button = gtk_button_new();
254 if (stock_id) image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON);
257 label = gtk_label_new_with_mnemonic(text);
258 gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
259 gtk_label_set_mnemonic_widget(GTK_LABEL(label), button);
267 hbox = gtk_hbox_new(FALSE, PREF_PAD_BUTTON_ICON_GAP);
269 align = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
270 gtk_container_add(GTK_CONTAINER(button), align);
271 gtk_widget_show(align);
273 gtk_container_add(GTK_CONTAINER(align), hbox);
274 gtk_widget_show(hbox);
276 gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
277 gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
283 gtk_container_add(GTK_CONTAINER(button), image);
287 gtk_container_add(GTK_CONTAINER(button), label);
291 if (image) gtk_widget_show(image);
292 if (label) gtk_widget_show(label);
295 if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
299 gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
300 gtk_widget_show(button);
306 static GtkWidget *real_pref_checkbox_new(GtkWidget *parent_box, const gchar *text, gboolean mnemonic_text,
307 gboolean active, GCallback func, gpointer data)
313 button = gtk_check_button_new_with_mnemonic(text);
317 button = gtk_check_button_new_with_label(text);
319 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
320 if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
322 gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
323 gtk_widget_show(button);
328 GtkWidget *pref_checkbox_new(GtkWidget *parent_box, const gchar *text, gboolean active,
329 GCallback func, gpointer data)
331 return real_pref_checkbox_new(parent_box, text, FALSE, active, func, data);
334 GtkWidget *pref_checkbox_new_mnemonic(GtkWidget *parent_box, const gchar *text, gboolean active,
335 GCallback func, gpointer data)
337 return real_pref_checkbox_new(parent_box, text, TRUE, active, func, data);
340 static void pref_checkbox_int_cb(GtkWidget *widget, gpointer data)
342 gboolean *result = data;
344 *result = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
347 GtkWidget *pref_checkbox_new_int(GtkWidget *parent_box, const gchar *text, gboolean active,
352 button = pref_checkbox_new(parent_box, text, active,
353 G_CALLBACK(pref_checkbox_int_cb), result);
359 static void pref_checkbox_link_sensitivity_cb(GtkWidget *button, gpointer data)
361 GtkWidget *widget = data;
363 gtk_widget_set_sensitive(widget, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
366 void pref_checkbox_link_sensitivity(GtkWidget *button, GtkWidget *widget)
368 g_signal_connect(G_OBJECT(button), "toggled",
369 G_CALLBACK(pref_checkbox_link_sensitivity_cb), widget);
371 pref_checkbox_link_sensitivity_cb(button, widget);
374 static void pref_checkbox_link_sensitivity_swap_cb(GtkWidget *button, gpointer data)
376 GtkWidget *widget = data;
378 gtk_widget_set_sensitive(widget, !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
381 void pref_checkbox_link_sensitivity_swap(GtkWidget *button, GtkWidget *widget)
383 g_signal_connect(G_OBJECT(button), "toggled",
384 G_CALLBACK(pref_checkbox_link_sensitivity_swap_cb), widget);
386 pref_checkbox_link_sensitivity_swap_cb(button, widget);
389 static GtkWidget *real_pref_radiobutton_new(GtkWidget *parent_box, GtkWidget *sibling,
390 const gchar *text, gboolean mnemonic_text, gboolean active,
391 GCallback func, gpointer data)
398 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(sibling));
407 button = gtk_radio_button_new_with_mnemonic(group, text);
411 button = gtk_radio_button_new_with_label(group, text);
414 if (active) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
415 if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
417 gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
418 gtk_widget_show(button);
423 GtkWidget *pref_radiobutton_new(GtkWidget *parent_box, GtkWidget *sibling,
424 const gchar *text, gboolean active,
425 GCallback func, gpointer data)
427 return real_pref_radiobutton_new(parent_box, sibling, text, FALSE, active, func, data);
430 GtkWidget *pref_radiobutton_new_mnemonic(GtkWidget *parent_box, GtkWidget *sibling,
431 const gchar *text, gboolean active,
432 GCallback func, gpointer data)
434 return real_pref_radiobutton_new(parent_box, sibling, text, TRUE, active, func, data);
437 #define PREF_RADIO_VALUE_KEY "pref_radio_value"
439 static void pref_radiobutton_int_cb(GtkWidget *widget, gpointer data)
441 gboolean *result = data;
443 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
445 *result = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), PREF_RADIO_VALUE_KEY));
449 GtkWidget *pref_radiobutton_new_int(GtkWidget *parent_box, GtkWidget *sibling,
450 const gchar *text, gboolean active,
451 gboolean *result, gboolean value,
452 GCallback func, gpointer data)
456 button = pref_radiobutton_new(parent_box, sibling, text, active,
457 G_CALLBACK(pref_radiobutton_int_cb), result);
458 g_object_set_data(G_OBJECT(button), PREF_RADIO_VALUE_KEY, GINT_TO_POINTER(value));
459 if (active) *result = value;
464 static GtkWidget *real_pref_spin_new(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
465 gboolean mnemonic_text,
466 gdouble min, gdouble max, gdouble step, gint digits,
468 GCallback func, gpointer data)
474 box = pref_box_new(parent_box, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
476 spin = gtk_spin_button_new_with_range(min, max, step);
477 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), digits);
478 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
482 g_signal_connect(G_OBJECT(spin), "value_changed", G_CALLBACK(func), data);
489 label = pref_label_new_mnemonic(box, text, spin);
493 label = pref_label_new(box, text);
495 pref_link_sensitivity(label, spin);
498 gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
499 gtk_widget_show(spin);
501 /* perhaps this should only be PREF_PAD_GAP distance from spinbutton ? */
504 label = pref_label_new(box, suffix);
505 pref_link_sensitivity(label, spin);
511 GtkWidget *pref_spin_new(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
512 gdouble min, gdouble max, gdouble step, gint digits,
514 GCallback func, gpointer data)
516 return real_pref_spin_new(parent_box, text, suffix, FALSE,
517 min, max, step, digits, value, func, data);
520 GtkWidget *pref_spin_new_mnemonic(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
521 gdouble min, gdouble max, gdouble step, gint digits,
523 GCallback func, gpointer data)
525 return real_pref_spin_new(parent_box, text, suffix, TRUE,
526 min, max, step, digits, value, func, data);
529 static void pref_spin_int_cb(GtkWidget *widget, gpointer data)
532 *var = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
535 GtkWidget *pref_spin_new_int(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
536 gint min, gint max, gint step,
537 gint value, gint *value_var)
540 return pref_spin_new(parent_box, text, suffix,
541 (gdouble)min, (gdouble)max, (gdouble)step, 0,
543 G_CALLBACK(pref_spin_int_cb), value_var);
547 void pref_spin_set_blocking(GtkWidget *spin, gdouble value, gpointer block_data)
549 g_signal_handlers_block_matched(G_OBJECT(spin), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, block_data);
550 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
551 g_signal_handlers_unblock_matched(G_OBJECT(spin), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, block_data);
555 static void pref_link_sensitivity_cb(GtkWidget *watch, GtkStateType prev_state, gpointer data)
557 GtkWidget *widget = data;
559 #if GTK_CHECK_VERSION(2,20,0)
560 gtk_widget_set_sensitive(widget, gtk_widget_is_sensitive(watch));
562 gtk_widget_set_sensitive(widget, GTK_WIDGET_IS_SENSITIVE(watch));
566 void pref_link_sensitivity(GtkWidget *widget, GtkWidget *watch)
568 g_signal_connect(G_OBJECT(watch), "state_changed",
569 G_CALLBACK(pref_link_sensitivity_cb), widget);
572 void pref_signal_block_data(GtkWidget *widget, gpointer data)
574 g_signal_handlers_block_matched(widget, G_SIGNAL_MATCH_DATA,
575 0, 0, NULL, NULL, data);
578 void pref_signal_unblock_data(GtkWidget *widget, gpointer data)
580 g_signal_handlers_unblock_matched(widget, G_SIGNAL_MATCH_DATA,
581 0, 0, NULL, NULL, data);
584 GtkWidget *pref_table_new(GtkWidget *parent_box, gint columns, gint rows,
585 gboolean homogeneous, gboolean fill)
589 table = gtk_table_new(rows, columns, homogeneous);
590 gtk_table_set_row_spacings(GTK_TABLE(table), PREF_PAD_GAP);
591 gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_SPACE);
595 gtk_box_pack_start(GTK_BOX(parent_box), table, fill, fill, 0);
596 gtk_widget_show(table);
602 GtkWidget *pref_table_box(GtkWidget *table, gint column, gint row,
603 GtkOrientation orientation, const gchar *text)
610 shell = gtk_vbox_new(FALSE, 0);
611 box = pref_group_new(shell, TRUE, text, orientation);
615 if (orientation == GTK_ORIENTATION_HORIZONTAL)
617 box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
621 box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
626 gtk_table_attach(GTK_TABLE(table), shell, column, column + 1, row, row + 1,
627 GTK_EXPAND | GTK_FILL, 0, 0, 0);
629 gtk_widget_show(shell);
634 GtkWidget *pref_table_label(GtkWidget *table, gint column, gint row,
635 const gchar *text, gfloat alignment)
640 align = gtk_alignment_new(alignment, 0.50, 0.0, 0.0);
641 gtk_table_attach(GTK_TABLE(table), align, column, column + 1, row, row + 1,
643 gtk_widget_show(align);
644 label = gtk_label_new(text);
645 gtk_container_add(GTK_CONTAINER(align), label);
646 gtk_widget_show(label);
651 GtkWidget *pref_table_button(GtkWidget *table, gint column, gint row,
652 const gchar *stock_id, const gchar *text, gboolean hide_stock_text,
653 GCallback func, gpointer data)
657 button = pref_button_new(NULL, stock_id, text, hide_stock_text, func, data);
658 gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
660 gtk_widget_show(button);
666 static GtkWidget *pref_table_checkbox(GtkWidget *table, gint column, gint row,
667 const gchar *text, gint active,
668 GCallback func, gpointer data)
672 button = gtk_check_button_new_with_label(text);
673 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
674 if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
676 gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
677 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
678 gtk_widget_show(button);
684 GtkWidget *pref_table_spin(GtkWidget *table, gint column, gint row,
685 const gchar *text, const gchar *suffix,
686 gdouble min, gdouble max, gdouble step, gint digits,
688 GCallback func, gpointer data)
694 spin = gtk_spin_button_new_with_range(min, max, step);
695 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), digits);
696 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
699 g_signal_connect(G_OBJECT(spin), "value_changed", G_CALLBACK(func), data);
704 label = pref_table_label(table, column, row, text, 1.0);
705 pref_link_sensitivity(label, spin);
711 box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
712 gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
713 gtk_widget_show(spin);
715 label = pref_label_new(box, suffix);
716 pref_link_sensitivity(label, spin);
723 gtk_table_attach(GTK_TABLE(table), box, column, column + 1, row, row + 1,
724 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
725 gtk_widget_show(box);
730 GtkWidget *pref_table_spin_new_int(GtkWidget *table, gint column, gint row,
731 const gchar *text, const gchar *suffix,
732 gint min, gint max, gint step,
733 gint value, gint *value_var)
736 return pref_table_spin(table, column, row,
738 (gdouble)min, (gdouble)max, (gdouble)step, 0,
740 G_CALLBACK(pref_spin_int_cb), value_var);
744 #if ! GTK_CHECK_VERSION(2,12,0)
746 static void pref_toolbar_destroy_cb(GtkWidget *widget, gpointer data)
748 GtkTooltips *tips = data;
750 g_object_unref(G_OBJECT(tips));
755 GtkWidget *pref_toolbar_new(GtkWidget *parent_box, GtkToolbarStyle style)
758 #if ! GTK_CHECK_VERSION(2,12,0)
762 tbar = gtk_toolbar_new();
763 gtk_toolbar_set_style(GTK_TOOLBAR(tbar), style);
767 gtk_box_pack_start(GTK_BOX(parent_box), tbar, FALSE, FALSE, 0);
768 gtk_widget_show(tbar);
771 #if ! GTK_CHECK_VERSION(2,12,0)
772 tips = gtk_tooltips_new();
774 /* take ownership of tooltips */
775 # ifdef GTK_OBJECT_FLOATING
777 g_object_ref(G_OBJECT(tips));
778 gtk_object_sink(GTK_OBJECT(tips));
781 g_object_ref_sink(G_OBJECT(tips));
784 g_object_set_data(G_OBJECT(tbar), "tooltips", tips);
785 g_signal_connect(G_OBJECT(tbar), "destroy",
786 G_CALLBACK(pref_toolbar_destroy_cb), tips);
788 gtk_tooltips_enable(tips);
794 GtkWidget *pref_toolbar_button(GtkWidget *toolbar,
795 const gchar *stock_id, const gchar *label, gboolean toggle,
796 const gchar *description,
797 GCallback func, gpointer data)
805 item = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(stock_id));
809 item = GTK_WIDGET(gtk_toggle_tool_button_new());
816 item = GTK_WIDGET(gtk_tool_button_new_from_stock(stock_id));
820 item = GTK_WIDGET(gtk_tool_button_new(NULL, NULL));
823 gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(item), TRUE);
825 if (label) gtk_tool_button_set_label(GTK_TOOL_BUTTON(item), label);
827 if (func) g_signal_connect(item, "clicked", func, data);
828 gtk_container_add(GTK_CONTAINER(toolbar), item);
829 gtk_widget_show(item);
834 #if GTK_CHECK_VERSION(2,12,0)
836 gtk_widget_set_tooltip_text(item, description);
841 tips = g_object_get_data(G_OBJECT(toolbar), "tooltips");
842 gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(item), tips, description, NULL);
849 void pref_toolbar_button_set_icon(GtkWidget *button, GtkWidget *widget, const gchar *stock_id)
853 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), widget);
857 gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(button), stock_id);
861 GtkWidget *pref_toolbar_spacer(GtkWidget *toolbar)
865 item = GTK_WIDGET(gtk_separator_tool_item_new());
866 gtk_container_add(GTK_CONTAINER(toolbar), item);
867 gtk_widget_show(item);
874 *-----------------------------------------------------------------------------
875 * date selection entry
876 *-----------------------------------------------------------------------------
879 #define DATE_SELECION_KEY "date_selection_data"
882 typedef struct _DateSelection DateSelection;
883 struct _DateSelection
898 static void date_selection_popup_hide(DateSelection *ds)
900 if (!ds->window) return;
902 #if GTK_CHECK_VERSION(2,20,0)
903 if (gtk_widget_has_grab(ds->window))
905 if (GTK_WIDGET_HAS_GRAB(ds->window))
908 gtk_grab_remove(ds->window);
909 gdk_keyboard_ungrab(GDK_CURRENT_TIME);
910 gdk_pointer_ungrab(GDK_CURRENT_TIME);
913 gtk_widget_hide(ds->window);
915 gtk_widget_destroy(ds->window);
919 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), FALSE);
922 static gboolean date_selection_popup_release_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
924 DateSelection *ds = data;
926 date_selection_popup_hide(ds);
930 static gboolean date_selection_popup_press_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
932 DateSelection *ds = data;
938 xr = (gint)event->x_root;
939 yr = (gint)event->y_root;
941 window = gtk_widget_get_window(ds->window);
942 gdk_window_get_origin(window, &x, &y);
943 w = gdk_window_get_width(window);
944 h = gdk_window_get_height(window);
946 if (xr < x || yr < y || xr > x + w || yr > y + h)
948 g_signal_connect(G_OBJECT(ds->window), "button_release_event",
949 G_CALLBACK(date_selection_popup_release_cb), ds);
956 static void date_selection_popup_sync(DateSelection *ds)
958 guint day, month, year;
960 gtk_calendar_get_date(GTK_CALENDAR(ds->calendar), &year, &month, &day);
961 date_selection_set(ds->box, day, month + 1, year);
964 static gboolean date_selection_popup_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
966 DateSelection *ds = data;
968 switch (event->keyval)
973 case GDK_ISO_Left_Tab:
974 date_selection_popup_sync(ds);
975 date_selection_popup_hide(ds);
978 date_selection_popup_hide(ds);
987 static void date_selection_day_cb(GtkWidget *widget, gpointer data)
989 DateSelection *ds = data;
991 date_selection_popup_sync(ds);
994 static void date_selection_doubleclick_cb(GtkWidget *widget, gpointer data)
996 DateSelection *ds = data;
998 date_selection_popup_hide(ds);
1001 static void date_selection_popup(DateSelection *ds)
1005 gint day, month, year;
1006 GtkAllocation button_allocation;
1007 GtkAllocation window_allocation;
1009 if (ds->window) return;
1011 ds->window = gtk_window_new(GTK_WINDOW_POPUP);
1012 gtk_window_set_resizable(GTK_WINDOW(ds->window), FALSE);
1013 g_signal_connect(G_OBJECT(ds->window), "button_press_event",
1014 G_CALLBACK(date_selection_popup_press_cb), ds);
1015 g_signal_connect(G_OBJECT(ds->window), "key_press_event",
1016 G_CALLBACK(date_selection_popup_keypress_cb), ds);
1018 ds->calendar = gtk_calendar_new();
1019 gtk_container_add(GTK_CONTAINER(ds->window), ds->calendar);
1020 gtk_widget_show(ds->calendar);
1022 date_selection_get(ds->box, &day, &month, &year);
1023 gtk_calendar_select_month(GTK_CALENDAR(ds->calendar), month - 1, year);
1024 gtk_calendar_select_day(GTK_CALENDAR(ds->calendar), day);
1026 g_signal_connect(G_OBJECT(ds->calendar), "day_selected",
1027 G_CALLBACK(date_selection_day_cb), ds);
1028 g_signal_connect(G_OBJECT(ds->calendar), "day_selected_double_click",
1029 G_CALLBACK(date_selection_doubleclick_cb), ds);
1031 gtk_widget_realize(ds->window);
1033 gdk_window_get_origin(gtk_widget_get_window(ds->button), &wx, &wy);
1035 gtk_widget_get_allocation(ds->button, &button_allocation);
1036 gtk_widget_get_allocation(ds->window, &window_allocation);
1038 x = wx + button_allocation.x + button_allocation.width - window_allocation.width;
1039 y = wy + button_allocation.y + button_allocation.height;
1041 if (y + window_allocation.height > gdk_screen_height())
1043 y = wy + button_allocation.y - window_allocation.height;
1048 gtk_window_move(GTK_WINDOW(ds->window), x, y);
1049 gtk_widget_show(ds->window);
1051 gtk_widget_grab_focus(ds->calendar);
1052 gdk_pointer_grab(gtk_widget_get_window(ds->window), TRUE,
1053 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK,
1054 NULL, NULL, GDK_CURRENT_TIME);
1055 gdk_keyboard_grab(gtk_widget_get_window(ds->window), TRUE, GDK_CURRENT_TIME);
1056 gtk_grab_add(ds->window);
1058 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), TRUE);
1061 static void date_selection_button_cb(GtkWidget *widget, gpointer data)
1063 DateSelection *ds = data;
1065 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ds->button)) == (!ds->window))
1067 date_selection_popup(ds);
1071 static void button_size_allocate_cb(GtkWidget *button, GtkAllocation *allocation, gpointer data)
1073 GtkWidget *spin = data;
1074 GtkRequisition spin_requisition;
1075 gtk_widget_get_requisition(spin, &spin_requisition);
1077 if (allocation->height > spin_requisition.height)
1079 GtkAllocation button_allocation;
1080 GtkAllocation spin_allocation;
1082 gtk_widget_get_allocation(button, &button_allocation);
1083 gtk_widget_get_allocation(spin, &spin_allocation);
1084 button_allocation.height = spin_requisition.height;
1085 button_allocation.y = spin_allocation.y +
1086 (spin_allocation.height - spin_requisition.height) / 2;
1087 gtk_widget_size_allocate(button, &button_allocation);
1091 static void spin_increase(GtkWidget *spin, gint value)
1095 gtk_widget_size_request(spin, &req);
1096 gtk_widget_set_size_request(spin, req.width + value, -1);
1099 static void date_selection_destroy_cb(GtkWidget *widget, gpointer data)
1101 DateSelection *ds = data;
1103 date_selection_popup_hide(ds);
1108 GtkWidget *date_selection_new(void)
1113 ds = g_new0(DateSelection, 1);
1115 ds->box = gtk_hbox_new(FALSE, 2);
1116 g_signal_connect(G_OBJECT(ds->box), "destroy",
1117 G_CALLBACK(date_selection_destroy_cb), ds);
1119 /* FIXME: use option menu with text format of month instead of a spin button */
1120 ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
1121 ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
1122 ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
1123 spin_increase(ds->spin_y, 5);
1125 ds->button = gtk_toggle_button_new();
1126 g_signal_connect(G_OBJECT(ds->button), "size_allocate",
1127 G_CALLBACK(button_size_allocate_cb), ds->spin_y);
1129 arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
1130 gtk_container_add(GTK_CONTAINER(ds->button), arrow);
1131 gtk_widget_show(arrow);
1133 gtk_box_pack_start(GTK_BOX(ds->box), ds->button, FALSE, FALSE, 0);
1134 g_signal_connect(G_OBJECT(ds->button), "clicked",
1135 G_CALLBACK(date_selection_button_cb), ds);
1136 gtk_widget_show(ds->button);
1138 g_object_set_data(G_OBJECT(ds->box), DATE_SELECION_KEY, ds);
1143 void date_selection_set(GtkWidget *widget, gint day, gint month, gint year)
1147 ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
1150 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), (gdouble)day);
1151 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), (gdouble)month);
1152 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), (gdouble)year);
1156 void date_selection_get(GtkWidget *widget, gint *day, gint *month, gint *year)
1160 ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
1163 if (day) *day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_d));
1164 if (month) *month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_m));
1165 if (year) *year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_y));
1168 void date_selection_time_set(GtkWidget *widget, time_t t)
1175 date_selection_set(widget, lt->tm_mday, lt->tm_mon + 1, lt->tm_year + 1900);
1178 time_t date_selection_time_get(GtkWidget *widget)
1185 date_selection_get(widget, &day, &month ,&year);
1191 lt.tm_mon = month - 1;
1192 lt.tm_year = year - 1900;
1200 *-----------------------------------------------------------------------------
1201 * Sizer, without using a GtkPaned
1202 *-----------------------------------------------------------------------------
1205 #define SIZER_DATA_KEY "sizer_data"
1207 typedef struct _SizerData SizerData;
1212 GtkWidget *bounding_widget;
1213 SizerPositionType position;
1226 gboolean handle_prelit;
1230 static gint sizer_default_handle_size(void)
1232 gint handle_size = 5;
1236 paned = gtk_hpaned_new();
1238 style = gtk_rc_get_style(paned);
1239 gtk_widget_set_style(paned, style);
1240 gtk_widget_style_get(paned, "handle_size", &handle_size, NULL);
1242 gtk_widget_destroy(paned);
1247 static gboolean sizer_motion_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1249 SizerData *sd = data;
1252 GtkAllocation parent_allocation;
1254 if (!sd->in_drag) return FALSE;
1256 x = sd->press_x - bevent->x_root;
1257 y = sd->press_y - bevent->y_root;
1259 w = sd->press_width;
1260 h = sd->press_height;
1262 if (sd->position & SIZER_POS_LEFT)
1266 else if (sd->position & SIZER_POS_RIGHT)
1271 if (sd->position & SIZER_POS_TOP)
1275 else if (sd->position & SIZER_POS_BOTTOM)
1280 if (sd->hsize_min >= 0) w = MAX(w, sd->hsize_min);
1281 if (sd->vsize_min >= 0) h = MAX(h, sd->vsize_min);
1283 if (sd->bounding_widget)
1285 GtkAllocation sizer_allocation;
1286 GtkAllocation bounding_allocation;
1287 gtk_widget_get_allocation(sd->sizer, &sizer_allocation);
1288 gtk_widget_get_allocation(sd->bounding_widget, &bounding_allocation);
1289 w = CLAMP(w, sizer_allocation.width, bounding_allocation.width);
1290 h = CLAMP(h, sizer_allocation.height, bounding_allocation.height);
1294 GtkAllocation sizer_allocation;
1295 gtk_widget_get_allocation(sd->sizer, &sizer_allocation);
1296 if (w < sizer_allocation.width) w = sizer_allocation.width;
1297 if (h < sizer_allocation.height) h = sizer_allocation.height;
1300 if (sd->hsize_max >= 0) w = MIN(w, sd->hsize_max);
1301 if (sd->vsize_max >= 0) h = MIN(h, sd->vsize_max);
1303 gtk_widget_get_allocation(sd->parent, &parent_allocation);
1304 if (w == parent_allocation.width) w = -1;
1305 if (h == parent_allocation.height) h = -1;
1307 if (w > 0 || h > 0) gtk_widget_set_size_request(sd->parent, w, h);
1312 static gboolean sizer_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1314 SizerData *sd = data;
1315 GtkAllocation parent_allocation;
1317 if (bevent->button != MOUSE_BUTTON_LEFT) return FALSE;
1320 sd->press_x = bevent->x_root;
1321 sd->press_y = bevent->y_root;
1323 gtk_widget_get_allocation(sd->parent, &parent_allocation);
1324 sd->press_width = parent_allocation.width;
1325 sd->press_height = parent_allocation.height;
1327 gdk_pointer_grab(gtk_widget_get_window(sd->sizer), FALSE,
1328 GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
1329 NULL, NULL, bevent->time);
1330 gtk_grab_add(sd->sizer);
1335 static gboolean sizer_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1337 SizerData *sd = data;
1339 if (bevent->button != MOUSE_BUTTON_LEFT) return FALSE;
1341 #if GTK_CHECK_VERSION(2,20,0)
1342 if (gdk_pointer_is_grabbed() && gtk_widget_has_grab(sd->sizer))
1344 if (gdk_pointer_is_grabbed() && GTK_WIDGET_HAS_GRAB(sd->sizer))
1347 gtk_grab_remove(sd->sizer);
1348 gdk_pointer_ungrab(bevent->time);
1351 sd->in_drag = FALSE;
1356 static void sizer_set_prelight(SizerData *sd, gboolean prelit)
1358 GtkAllocation sizer_allocation;
1359 gtk_widget_get_allocation(sd->sizer, &sizer_allocation);
1361 sd->handle_prelit = prelit;
1362 gtk_widget_queue_draw_area(sd->sizer, 0, 0,
1363 sizer_allocation.width, sizer_allocation.height);
1366 static gboolean sizer_enter_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1368 SizerData *sd = data;
1370 sizer_set_prelight(sd, TRUE);
1374 static gboolean sizer_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1376 SizerData *sd = data;
1378 sizer_set_prelight(sd, FALSE);
1382 static gboolean sizer_expose_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1384 SizerData *sd = data;
1386 GtkOrientation orientation;
1388 GtkAllocation allocation;
1391 if (sd->position & SIZER_POS_LEFT || sd->position & SIZER_POS_RIGHT)
1393 orientation = GTK_ORIENTATION_VERTICAL;
1397 orientation = GTK_ORIENTATION_HORIZONTAL;
1400 if (sd->handle_prelit)
1402 state = GTK_STATE_PRELIGHT;
1406 state = gtk_widget_get_state(widget);
1409 gtk_widget_get_allocation(widget, &allocation);
1410 #if GTK_CHECK_VERSION(3,0,0)
1411 cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
1413 gtk_render_handle (gtk_widget_get_style_context (widget),
1414 cr, allocation.x, allocation.y, allocation.width, allocation.height);
1417 gdk_region_get_clipbox(event->region, &clip);
1419 gtk_paint_handle(gtk_widget_get_style(widget), gtk_widget_get_window(widget), state,
1420 GTK_SHADOW_NONE, &clip, widget, "paned",
1422 allocation.width, allocation.height,
1429 static void sizer_realize_cb(GtkWidget *widget, gpointer data)
1431 SizerData *sd = data;
1435 if (sd->position & SIZER_POS_TOP || sd->position & SIZER_POS_BOTTOM)
1437 n = GDK_SB_V_DOUBLE_ARROW;
1439 if (sd->position & SIZER_POS_LEFT || sd->position & SIZER_POS_RIGHT)
1441 n = (n != 0) ? GDK_FLEUR : GDK_SB_H_DOUBLE_ARROW;
1444 if (n != 0 && gtk_widget_get_window(widget))
1447 cursor = gdk_cursor_new(n);
1448 gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
1449 gdk_cursor_unref(cursor);
1453 static void sizer_destroy_cb(GtkWidget *widget, gpointer data)
1455 SizerData *sd = data;
1460 GtkWidget *sizer_new(GtkWidget *parent, GtkWidget *bounding_widget,
1461 SizerPositionType position)
1466 sd = g_new0(SizerData, 1);
1468 sd->sizer = gtk_event_box_new();
1469 sd->parent = parent;
1470 sd->bounding_widget = bounding_widget;
1471 sd->position = position;
1477 sd->in_drag = FALSE;
1478 sd->handle_prelit = FALSE;
1480 g_signal_connect(G_OBJECT(sd->sizer), "destroy",
1481 G_CALLBACK(sizer_destroy_cb), sd);
1483 g_signal_connect(G_OBJECT(sd->sizer), "motion_notify_event",
1484 G_CALLBACK(sizer_motion_cb), sd);
1485 g_signal_connect(G_OBJECT(sd->sizer), "button_press_event",
1486 G_CALLBACK(sizer_press_cb), sd);
1487 g_signal_connect(G_OBJECT(sd->sizer), "button_release_event",
1488 G_CALLBACK(sizer_release_cb), sd);
1490 g_signal_connect(G_OBJECT(sd->sizer), "enter_notify_event",
1491 G_CALLBACK(sizer_enter_cb), sd);
1492 g_signal_connect(G_OBJECT(sd->sizer), "leave_notify_event",
1493 G_CALLBACK(sizer_leave_cb), sd);
1495 gtk_widget_set_events(sd->sizer, GDK_POINTER_MOTION_MASK |
1496 GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK |
1497 GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1499 g_signal_connect(sd->sizer, "realize",
1500 G_CALLBACK(sizer_realize_cb), sd);
1501 g_signal_connect(sd->sizer, "expose_event",
1502 G_CALLBACK(sizer_expose_cb), sd);
1504 handle_size = sizer_default_handle_size();
1506 gtk_widget_set_size_request(sd->sizer, handle_size, handle_size);
1508 /* use this if you add a shadow border to the handle */
1509 gtk_widget_set_size_request(sd->sizer, handle_size + sd->sizer->style->xthickness * 2,
1510 handle_size + sd->sizer->style->ythickness * 2);
1513 g_object_set_data(G_OBJECT(sd->sizer), SIZER_DATA_KEY,sd);
1518 void sizer_set_limits(GtkWidget *sizer,
1519 gint hsize_min, gint hsize_max,
1520 gint vsize_min, gint vsize_max)
1524 sd = g_object_get_data(G_OBJECT(sizer), SIZER_DATA_KEY);
1527 sd->hsize_min = hsize_min;
1528 sd->hsize_max = hsize_max;
1529 sd->vsize_min = vsize_min;
1530 sd->vsize_max = vsize_max;
1535 *-----------------------------------------------------------------------------
1536 * storing data in a history list with key,data pairs
1537 *-----------------------------------------------------------------------------
1540 #define PREF_LIST_MARKER_INT "[INT]:"
1541 #define PREF_LIST_MARKER_DOUBLE "[DOUBLE]:"
1542 #define PREF_LIST_MARKER_STRING "[STRING]:"
1544 static GList *pref_list_find(const gchar *group, const gchar *token)
1551 work = history_list_get_by_key(group);
1554 const gchar *text = work->data;
1556 if (strncmp(text, token, l) == 0) return work;
1564 static gboolean pref_list_get(const gchar *group, const gchar *key, const gchar *marker, const gchar **result)
1570 if (!group || !key || !marker)
1576 token = g_strconcat(key, marker, NULL);
1578 work = pref_list_find(group, token);
1581 *result = (const gchar *)work->data + strlen(token);
1582 if (strlen(*result) == 0) *result = NULL;
1596 static void pref_list_set(const gchar *group, const gchar *key, const gchar *marker, const gchar *text)
1602 if (!group || !key || !marker) return;
1604 token = g_strconcat(key, marker, NULL);
1605 path = g_strconcat(token, text, NULL);
1607 work = pref_list_find(group, token);
1610 gchar *old_path = work->data;
1621 history_list_item_remove(group, old_path);
1626 history_list_add_to_key(group, path, 0);
1633 void pref_list_int_set(const gchar *group, const gchar *key, gint value)
1637 text = g_strdup_printf("%d", value);
1638 pref_list_set(group, key, PREF_LIST_MARKER_INT, text);
1642 gboolean pref_list_int_get(const gchar *group, const gchar *key, gint *result)
1652 if (pref_list_get(group, key, PREF_LIST_MARKER_INT, &text) && text)
1654 *result = (gint)strtol(text, NULL, 10);
1662 void pref_list_double_set(const gchar *group, const gchar *key, gdouble value)
1664 gchar text[G_ASCII_DTOSTR_BUF_SIZE];
1666 g_ascii_dtostr(text, sizeof(text), value);
1667 pref_list_set(group, key, PREF_LIST_MARKER_DOUBLE, text);
1670 gboolean pref_list_double_get(const gchar *group, const gchar *key, gdouble *result)
1680 if (pref_list_get(group, key, PREF_LIST_MARKER_DOUBLE, &text) && text)
1682 *result = g_ascii_strtod(text, NULL);
1690 void pref_list_string_set(const gchar *group, const gchar *key, const gchar *value)
1692 pref_list_set(group, key, PREF_LIST_MARKER_STRING, value);
1695 gboolean pref_list_string_get(const gchar *group, const gchar *key, const gchar **result)
1697 return pref_list_get(group, key, PREF_LIST_MARKER_STRING, result);
1701 void pref_color_button_set_cb(GtkWidget *widget, gpointer data)
1703 GdkColor *color = data;
1705 gtk_color_button_get_color(GTK_COLOR_BUTTON(widget), color);
1708 GtkWidget *pref_color_button_new(GtkWidget *parent_box,
1709 const gchar *title, const GdkColor *color,
1710 GCallback func, gpointer data)
1716 button = gtk_color_button_new_with_color(color);
1720 button = gtk_color_button_new();
1723 if (func) g_signal_connect(G_OBJECT(button), "color-set", func, data);
1730 gtk_color_button_set_title(GTK_COLOR_BUTTON(button), title);
1731 label = gtk_label_new(title);
1733 hbox = gtk_hbox_new(TRUE, 0);
1734 gtk_box_pack_start(GTK_BOX(parent_box), hbox, TRUE, TRUE, 0);
1736 gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
1737 gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
1739 gtk_widget_show_all(hbox);
1743 gtk_widget_show(button);
1750 *-----------------------------------------------------------------------------
1752 *-----------------------------------------------------------------------------
1755 gchar *text_widget_text_pull(GtkWidget *text_widget)
1757 if (GTK_IS_TEXT_VIEW(text_widget))
1759 GtkTextBuffer *buffer;
1760 GtkTextIter start, end;
1762 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_widget));
1763 gtk_text_buffer_get_bounds(buffer, &start, &end);
1765 return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
1767 else if (GTK_IS_ENTRY(text_widget))
1769 return g_strdup(gtk_entry_get_text(GTK_ENTRY(text_widget)));
1778 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */