From 80be398c40c0750b95fa17c50d97f6510381c70d Mon Sep 17 00:00:00 2001 From: Berke Viktor Date: Wed, 17 Aug 2011 06:51:34 +0200 Subject: [PATCH] add gtk+ preference tool --- src/gtk2-prefs/callbacks.cpp | 224 ++++++++++ src/gtk2-prefs/callbacks.h | 71 +++ src/gtk2-prefs/config.h | 59 +++ src/gtk2-prefs/interface.cpp | 836 +++++++++++++++++++++++++++++++++++ src/gtk2-prefs/interface.h | 5 + src/gtk2-prefs/main.cpp | 611 +++++++++++++++++++++++++ src/gtk2-prefs/main.h | 32 ++ src/gtk2-prefs/makefile.mak | 24 + src/gtk2-prefs/support.cpp | 146 ++++++ src/gtk2-prefs/support.h | 44 ++ src/gtk2-prefs/sys_win32.h | 28 ++ src/gtk2-prefs/win32util.cpp | 80 ++++ src/gtk2-prefs/win32util.h | 26 ++ 13 files changed, 2186 insertions(+) create mode 100644 src/gtk2-prefs/callbacks.cpp create mode 100644 src/gtk2-prefs/callbacks.h create mode 100644 src/gtk2-prefs/config.h create mode 100644 src/gtk2-prefs/interface.cpp create mode 100644 src/gtk2-prefs/interface.h create mode 100644 src/gtk2-prefs/main.cpp create mode 100644 src/gtk2-prefs/main.h create mode 100644 src/gtk2-prefs/makefile.mak create mode 100644 src/gtk2-prefs/support.cpp create mode 100644 src/gtk2-prefs/support.h create mode 100644 src/gtk2-prefs/sys_win32.h create mode 100644 src/gtk2-prefs/win32util.cpp create mode 100644 src/gtk2-prefs/win32util.h diff --git a/src/gtk2-prefs/callbacks.cpp b/src/gtk2-prefs/callbacks.cpp new file mode 100644 index 00000000..9cc5c928 --- /dev/null +++ b/src/gtk2-prefs/callbacks.cpp @@ -0,0 +1,224 @@ +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#include "main.h" + + + +extern GtkWidget* g_main_window; + +void +on_main_showpreviewtoggle_toggled (GtkToggleButton *togglebutton, + gpointer user_data) +{ + if (gtk_toggle_button_get_active (togglebutton)) { + gtk_widget_show(lookup_widget(g_main_window, "main_previewhbox")); + gtk_button_set_label(GTK_BUTTON(togglebutton), "Hide preview <<"); + gtk_window_resize(GTK_WINDOW(g_main_window), 700, 330); + } else { + gtk_widget_hide(lookup_widget(g_main_window, "main_previewhbox")); + gtk_button_set_label(GTK_BUTTON(togglebutton), "Show preview >>"); + gtk_window_resize(GTK_WINDOW(g_main_window), 300, 330); + } + +} + + +/* +extern GtkWidget* g_fontsel_dialog; + + +void +on_fontsel_dialog_response (GtkDialog *dialog, + gint id, + gpointer user_data) +{ + + switch(id) { + case GTK_RESPONSE_OK: + { + const char* font = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(dialog)); + std::string f = (font ? font : ""); + set_theme(get_selected_theme(), f); + break; + } +// case GTK_RESPONSE_CANCEL: +// gtk_widget_destroy(g_fontsel_dialog); +// g_fontsel_dialog = 0; +// return; + + } + gtk_widget_destroy(g_fontsel_dialog); + g_fontsel_dialog = 0; + +} + + +gboolean +on_fontsel_dialog_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + gtk_widget_destroy(g_fontsel_dialog); + g_fontsel_dialog = 0; + + return FALSE; +} + + +void +on_main_fontselectbutton_clicked (GtkButton *button, + gpointer user_data) +{ + g_fontsel_dialog = create_fontsel_dialog(); + gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(g_fontsel_dialog), get_current_font().c_str()); + gtk_widget_show(g_fontsel_dialog); +} +*/ + + + + + +void +on_main_ok_button_clicked (GtkButton *button, + gpointer user_data) +{ + if (save_current_theme()) + gtk_main_quit(); +} + + +void +on_main_cancel_button_clicked (GtkButton *button, + gpointer user_data) +{ + gtk_main_quit(); +} + + +void +on_main_reset_button_clicked (GtkButton *button, + gpointer user_data) +{ + set_theme(get_orig_theme(), get_orig_font()); +} + + +gboolean +on_main_window_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + program_shutdown(); + return true; +} + + +void +on_main_use_default_font_radio_toggled (GtkToggleButton *togglebutton, + gpointer user_data) +{ + bool default_font = gtk_toggle_button_get_active(togglebutton); + + gtk_widget_set_sensitive(lookup_widget(g_main_window, "main_font_selector_button"), !default_font); + + apply_theme(get_selected_theme(), get_selected_font()); +} + + +void +on_main_font_selector_button_font_set (GtkFontButton *fontbutton, + gpointer user_data) +{ + apply_theme(get_selected_theme(), get_selected_font()); +} + + +void +on_new2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_open2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_save2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_save_as2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_quit2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_cut2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_copy2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_paste2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_delete2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + + +void +on_about2_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + +} + diff --git a/src/gtk2-prefs/callbacks.h b/src/gtk2-prefs/callbacks.h new file mode 100644 index 00000000..5759aebc --- /dev/null +++ b/src/gtk2-prefs/callbacks.h @@ -0,0 +1,71 @@ +#include + + +void +on_main_showpreviewtoggle_toggled (GtkToggleButton *togglebutton, + gpointer user_data); + +void +on_main_ok_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_main_cancel_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_main_reset_button_clicked (GtkButton *button, + gpointer user_data); + +gboolean +on_main_window_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data); + +void +on_main_use_default_font_radio_toggled (GtkToggleButton *togglebutton, + gpointer user_data); + +void +on_main_font_selector_button_font_set (GtkFontButton *fontbutton, + gpointer user_data); + +void +on_new2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_open2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save_as2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_quit2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_cut2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_copy2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_paste2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_delete2_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about2_activate (GtkMenuItem *menuitem, + gpointer user_data); diff --git a/src/gtk2-prefs/config.h b/src/gtk2-prefs/config.h new file mode 100644 index 00000000..4501a33b --- /dev/null +++ b/src/gtk2-prefs/config.h @@ -0,0 +1,59 @@ +/* Define to 1 if you have the header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* For gmessages.h error message */ +#define G_HAVE_ISO_VARARGS + +/* For mkdir */ +#define HAVE_DIRECT_H 1 + +/* Name of package */ +#define PACKAGE gtk2-prefs + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#define PACKAGE_NAME gtk2-prefs + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING gtk2-prefs 0.4.1 + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME gtk2-prefs + +/* Define to the version of this package. */ +#define PACKAGE_VERSION 0.4.1 + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION 0.4.1 diff --git a/src/gtk2-prefs/interface.cpp b/src/gtk2-prefs/interface.cpp new file mode 100644 index 00000000..adfcc66b --- /dev/null +++ b/src/gtk2-prefs/interface.cpp @@ -0,0 +1,836 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +GtkWidget* +create_main_window (void) +{ + GtkWidget *main_window; + GtkWidget *main_hbox; + GtkWidget *vbox1; + GtkWidget *hbox1; + GtkWidget *frame2; + GtkWidget *alignment3; + GtkWidget *scrolledwindow3; + GtkWidget *main_themelist; + GtkWidget *label1234; + GtkWidget *frame3; + GtkWidget *alignment4; + GtkWidget *vbox7; + GtkWidget *hbox8; + GtkWidget *vbox9; + GtkWidget *main_use_default_font_radio; + GSList *main_use_default_font_radio_group = NULL; + GtkWidget *main_use_custom_font_radio; + GtkWidget *alignment5; + GtkWidget *vbox10; + GtkWidget *hbox9; + GtkWidget *vbox11; + GtkWidget *main_font_selector_button; + GtkWidget *label669; + GtkWidget *vbox13; + GtkWidget *hbox6666; + GtkWidget *main_use_system_config_checkbutton; + GtkWidget *main_showpreviewtoggle; + GtkWidget *hbuttonbox1; + GtkWidget *hbox7; + GtkWidget *hbox6665; + GtkWidget *image2; + GtkWidget *label2; + GtkWidget *vbox6; + GtkWidget *hbox5; + GtkWidget *main_ok_button; + GtkWidget *main_cancel_button; + GtkWidget *main_reset_button; + GtkWidget *alignment2; + GtkWidget *hbox6; + GtkWidget *image1; + GtkWidget *label667; + GtkWidget *main_previewhbox; + GtkWidget *vseparator2; + GtkWidget *frame4; + GtkWidget *alignment6; + GtkWidget *vbox12; + GtkWidget *main_previewbook; + GtkWidget *table1; + GtkWidget *vbox2; + GtkWidget *checkbutton1; + GtkWidget *checkbutton2; + GtkWidget *button4; + GtkWidget *togglebutton1; + GtkObject *spinbutton1_adj; + GtkWidget *spinbutton1; + GtkWidget *vbox4; + GtkWidget *menubar2; + GtkWidget *menuitem5; + GtkWidget *menuitem5_menu; + GtkWidget *new2; + GtkWidget *open2; + GtkWidget *save2; + GtkWidget *save_as2; + GtkWidget *separatormenuitem2; + GtkWidget *quit2; + GtkWidget *menuitem6; + GtkWidget *menuitem6_menu; + GtkWidget *cut2; + GtkWidget *copy2; + GtkWidget *paste2; + GtkWidget *delete2; + GtkWidget *menuitem8; + GtkWidget *menuitem8_menu; + GtkWidget *about2; + GtkWidget *combobox1; + GtkWidget *comboboxentry1; + GtkWidget *hscale1; + GtkWidget *scrolledwindow1; + GtkWidget *preview_treeview; + GtkWidget *statusbar1; + GtkWidget *progressbar1; + GtkWidget *vseparator1; + GtkWidget *frame1; + GtkWidget *vbox3; + GtkWidget *radiobutton1; + GSList *radiobutton1_group = NULL; + GtkWidget *radiobutton2; + GtkWidget *radiobutton3; + GtkWidget *label6; + GtkWidget *label4; + GtkWidget *scrolledwindow2; + GtkWidget *textview1; + GtkWidget *label5; + GtkWidget *vbox5; + GtkWidget *hbox4; + GtkWidget *about_label; + GtkWidget *label666; + GtkWidget *label670; + GtkAccelGroup *accel_group; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + accel_group = gtk_accel_group_new (); + + main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_name (main_window, "main_window"); + gtk_window_set_title (GTK_WINDOW (main_window), "Gtk2 Theme Selector"); + + main_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (main_hbox, "main_hbox"); + gtk_widget_show (main_hbox); + gtk_container_add (GTK_CONTAINER (main_window), main_hbox); + gtk_widget_set_size_request (main_hbox, 310, 320); + + vbox1 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox1, "vbox1"); + gtk_widget_show (vbox1); + gtk_box_pack_start (GTK_BOX (main_hbox), vbox1, TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (vbox1), 3); + + hbox1 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox1, "hbox1"); + gtk_widget_show (hbox1); + gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0); + + frame2 = gtk_frame_new (NULL); + gtk_widget_set_name (frame2, "frame2"); + gtk_widget_show (frame2); + gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0); + gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); + + alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_widget_set_name (alignment3, "alignment3"); + gtk_widget_show (alignment3); + gtk_container_add (GTK_CONTAINER (frame2), alignment3); + gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 0, 0, 12, 0); + + scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_set_name (scrolledwindow3, "scrolledwindow3"); + gtk_widget_show (scrolledwindow3); + gtk_container_add (GTK_CONTAINER (alignment3), scrolledwindow3); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); + + main_themelist = gtk_tree_view_new (); + gtk_widget_set_name (main_themelist, "main_themelist"); + gtk_widget_show (main_themelist); + gtk_container_add (GTK_CONTAINER (scrolledwindow3), main_themelist); + GTK_WIDGET_SET_FLAGS (main_themelist, GTK_CAN_DEFAULT); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (main_themelist), FALSE); + + label1234 = gtk_label_new ("Theme"); + gtk_widget_set_name (label1234, "label1234"); + gtk_widget_show (label1234); + gtk_frame_set_label_widget (GTK_FRAME (frame2), label1234); + gtk_label_set_use_markup (GTK_LABEL (label1234), TRUE); + + frame3 = gtk_frame_new (NULL); + gtk_widget_set_name (frame3, "frame3"); + gtk_widget_show (frame3); + gtk_box_pack_start (GTK_BOX (vbox1), frame3, FALSE, FALSE, 9); + gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_NONE); + + alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_widget_set_name (alignment4, "alignment4"); + gtk_widget_show (alignment4); + gtk_container_add (GTK_CONTAINER (frame3), alignment4); + gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 0, 0, 12, 0); + + vbox7 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox7, "vbox7"); + gtk_widget_show (vbox7); + gtk_container_add (GTK_CONTAINER (alignment4), vbox7); + + hbox8 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox8, "hbox8"); + gtk_widget_show (hbox8); + gtk_box_pack_start (GTK_BOX (vbox7), hbox8, FALSE, FALSE, 0); + + vbox9 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox9, "vbox9"); + gtk_widget_show (vbox9); + gtk_box_pack_start (GTK_BOX (hbox8), vbox9, TRUE, TRUE, 0); + + main_use_default_font_radio = gtk_radio_button_new_with_mnemonic (NULL, "Use theme default font"); + gtk_widget_set_name (main_use_default_font_radio, "main_use_default_font_radio"); + gtk_widget_show (main_use_default_font_radio); + gtk_box_pack_start (GTK_BOX (vbox9), main_use_default_font_radio, FALSE, FALSE, 0); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (main_use_default_font_radio), main_use_default_font_radio_group); + main_use_default_font_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (main_use_default_font_radio)); + + main_use_custom_font_radio = gtk_radio_button_new_with_mnemonic (NULL, "Use custom font:"); + gtk_widget_set_name (main_use_custom_font_radio, "main_use_custom_font_radio"); + gtk_widget_show (main_use_custom_font_radio); + gtk_box_pack_start (GTK_BOX (vbox9), main_use_custom_font_radio, FALSE, FALSE, 0); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (main_use_custom_font_radio), main_use_default_font_radio_group); + main_use_default_font_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (main_use_custom_font_radio)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (main_use_custom_font_radio), TRUE); + + alignment5 = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_widget_set_name (alignment5, "alignment5"); + gtk_widget_show (alignment5); + gtk_box_pack_start (GTK_BOX (vbox9), alignment5, TRUE, TRUE, 0); + gtk_alignment_set_padding (GTK_ALIGNMENT (alignment5), 0, 0, 12, 0); + + vbox10 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox10, "vbox10"); + gtk_widget_show (vbox10); + gtk_container_add (GTK_CONTAINER (alignment5), vbox10); + + hbox9 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox9, "hbox9"); + gtk_widget_show (hbox9); + gtk_box_pack_start (GTK_BOX (vbox10), hbox9, FALSE, FALSE, 0); + + vbox11 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox11, "vbox11"); + gtk_widget_show (vbox11); + gtk_box_pack_start (GTK_BOX (hbox9), vbox11, TRUE, TRUE, 0); + + main_font_selector_button = gtk_font_button_new (); + gtk_widget_set_name (main_font_selector_button, "main_font_selector_button"); + gtk_widget_show (main_font_selector_button); + gtk_box_pack_start (GTK_BOX (vbox11), main_font_selector_button, FALSE, FALSE, 0); + + label669 = gtk_label_new ("Font"); + gtk_widget_set_name (label669, "label669"); + gtk_widget_show (label669); + gtk_frame_set_label_widget (GTK_FRAME (frame3), label669); + gtk_label_set_use_markup (GTK_LABEL (label669), TRUE); + + vbox13 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox13, "vbox13"); + gtk_widget_show (vbox13); + gtk_box_pack_start (GTK_BOX (vbox1), vbox13, FALSE, FALSE, 0); + + hbox6666 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox6666, "hbox6666"); + gtk_widget_show (hbox6666); + gtk_box_pack_start (GTK_BOX (vbox13), hbox6666, TRUE, TRUE, 0); + + main_use_system_config_checkbutton = gtk_check_button_new_with_mnemonic ("Apply for all users"); + gtk_widget_set_name (main_use_system_config_checkbutton, "main_use_system_config_checkbutton"); + gtk_widget_show (main_use_system_config_checkbutton); + gtk_box_pack_start (GTK_BOX (hbox6666), main_use_system_config_checkbutton, FALSE, FALSE, 12); + gtk_tooltips_set_tip (tooltips, main_use_system_config_checkbutton, "If this is enabled, the program will update the system-wide configuration file. NOT RECOMMENDED!", NULL); + + main_showpreviewtoggle = gtk_toggle_button_new_with_mnemonic ("Show preview >>"); + gtk_widget_set_name (main_showpreviewtoggle, "main_showpreviewtoggle"); + gtk_widget_show (main_showpreviewtoggle); + gtk_box_pack_end (GTK_BOX (hbox6666), main_showpreviewtoggle, FALSE, FALSE, 2); + + hbuttonbox1 = gtk_hbutton_box_new (); + gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); + gtk_widget_show (hbuttonbox1); + gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 0); + + hbox7 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox7, "hbox7"); + gtk_widget_show (hbox7); + gtk_box_pack_start (GTK_BOX (vbox1), hbox7, FALSE, TRUE, 6); + + hbox6665 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox6665, "hbox6665"); + gtk_widget_show (hbox6665); + gtk_box_pack_start (GTK_BOX (hbox7), hbox6665, TRUE, FALSE, 0); + + image2 = gtk_image_new_from_stock ("gtk-dialog-info", GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_widget_set_name (image2, "image2"); + gtk_widget_show (image2); + gtk_box_pack_start (GTK_BOX (hbox6665), image2, FALSE, FALSE, 0); + + label2 = gtk_label_new ("You should restart your programs\nfor this change to take effect."); + gtk_widget_set_name (label2, "label2"); + gtk_widget_show (label2); + gtk_box_pack_start (GTK_BOX (hbox6665), label2, FALSE, FALSE, 0); + gtk_label_set_line_wrap (GTK_LABEL (label2), TRUE); + gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); + + vbox6 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox6, "vbox6"); + gtk_widget_show (vbox6); + gtk_box_pack_start (GTK_BOX (vbox1), vbox6, FALSE, FALSE, 0); + + hbox5 = gtk_hbox_new (TRUE, 0); + gtk_widget_set_name (hbox5, "hbox5"); + gtk_widget_show (hbox5); + gtk_box_pack_start (GTK_BOX (vbox6), hbox5, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox5), 4); + + main_ok_button = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_set_name (main_ok_button, "main_ok_button"); + gtk_widget_show (main_ok_button); + gtk_box_pack_end (GTK_BOX (hbox5), main_ok_button, TRUE, TRUE, 4); + GTK_WIDGET_SET_FLAGS (main_ok_button, GTK_CAN_DEFAULT); + + main_cancel_button = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_set_name (main_cancel_button, "main_cancel_button"); + gtk_widget_show (main_cancel_button); + gtk_box_pack_end (GTK_BOX (hbox5), main_cancel_button, TRUE, TRUE, 4); + GTK_WIDGET_SET_FLAGS (main_cancel_button, GTK_CAN_DEFAULT); + + main_reset_button = gtk_button_new (); + gtk_widget_set_name (main_reset_button, "main_reset_button"); + gtk_widget_show (main_reset_button); + gtk_box_pack_end (GTK_BOX (hbox5), main_reset_button, TRUE, TRUE, 4); + + alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); + gtk_widget_set_name (alignment2, "alignment2"); + gtk_widget_show (alignment2); + gtk_container_add (GTK_CONTAINER (main_reset_button), alignment2); + + hbox6 = gtk_hbox_new (FALSE, 2); + gtk_widget_set_name (hbox6, "hbox6"); + gtk_widget_show (hbox6); + gtk_container_add (GTK_CONTAINER (alignment2), hbox6); + + image1 = gtk_image_new_from_stock ("gtk-revert-to-saved", GTK_ICON_SIZE_BUTTON); + gtk_widget_set_name (image1, "image1"); + gtk_widget_show (image1); + gtk_box_pack_start (GTK_BOX (hbox6), image1, FALSE, FALSE, 0); + + label667 = gtk_label_new_with_mnemonic ("_Reset"); + gtk_widget_set_name (label667, "label667"); + gtk_widget_show (label667); + gtk_box_pack_start (GTK_BOX (hbox6), label667, FALSE, FALSE, 0); + + main_previewhbox = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (main_previewhbox, "main_previewhbox"); + gtk_box_pack_start (GTK_BOX (main_hbox), main_previewhbox, TRUE, TRUE, 0); + + vseparator2 = gtk_vseparator_new (); + gtk_widget_set_name (vseparator2, "vseparator2"); + gtk_widget_show (vseparator2); + gtk_box_pack_start (GTK_BOX (main_previewhbox), vseparator2, FALSE, TRUE, 4); + + frame4 = gtk_frame_new (NULL); + gtk_widget_set_name (frame4, "frame4"); + gtk_widget_show (frame4); + gtk_box_pack_start (GTK_BOX (main_previewhbox), frame4, TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (frame4), 3); + gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_NONE); + + alignment6 = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_widget_set_name (alignment6, "alignment6"); + gtk_widget_show (alignment6); + gtk_container_add (GTK_CONTAINER (frame4), alignment6); + + vbox12 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox12, "vbox12"); + gtk_widget_show (vbox12); + gtk_container_add (GTK_CONTAINER (alignment6), vbox12); + + main_previewbook = gtk_notebook_new (); + gtk_widget_set_name (main_previewbook, "main_previewbook"); + gtk_widget_show (main_previewbook); + gtk_box_pack_start (GTK_BOX (vbox12), main_previewbook, TRUE, TRUE, 0); + + table1 = gtk_table_new (3, 3, FALSE); + gtk_widget_set_name (table1, "table1"); + gtk_widget_show (table1); + gtk_container_add (GTK_CONTAINER (main_previewbook), table1); + gtk_container_set_border_width (GTK_CONTAINER (table1), 5); + + vbox2 = gtk_vbox_new (FALSE, 4); + gtk_widget_set_name (vbox2, "vbox2"); + gtk_widget_show (vbox2); + gtk_table_attach (GTK_TABLE (table1), vbox2, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + checkbutton1 = gtk_check_button_new_with_mnemonic ("check button 1"); + gtk_widget_set_name (checkbutton1, "checkbutton1"); + gtk_widget_show (checkbutton1); + gtk_box_pack_start (GTK_BOX (vbox2), checkbutton1, FALSE, FALSE, 0); + + checkbutton2 = gtk_check_button_new_with_mnemonic ("check button 2"); + gtk_widget_set_name (checkbutton2, "checkbutton2"); + gtk_widget_show (checkbutton2); + gtk_box_pack_start (GTK_BOX (vbox2), checkbutton2, FALSE, FALSE, 0); + + button4 = gtk_button_new_with_mnemonic ("button"); + gtk_widget_set_name (button4, "button4"); + gtk_widget_show (button4); + gtk_box_pack_start (GTK_BOX (vbox2), button4, FALSE, FALSE, 0); + + togglebutton1 = gtk_toggle_button_new_with_mnemonic ("toggle button"); + gtk_widget_set_name (togglebutton1, "togglebutton1"); + gtk_widget_show (togglebutton1); + gtk_box_pack_start (GTK_BOX (vbox2), togglebutton1, FALSE, FALSE, 0); + + spinbutton1_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0); + gtk_widget_set_name (spinbutton1, "spinbutton1"); + gtk_widget_show (spinbutton1); + gtk_box_pack_start (GTK_BOX (vbox2), spinbutton1, FALSE, FALSE, 0); + + vbox4 = gtk_vbox_new (FALSE, 4); + gtk_widget_set_name (vbox4, "vbox4"); + gtk_widget_show (vbox4); + gtk_table_attach (GTK_TABLE (table1), vbox4, 2, 3, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + menubar2 = gtk_menu_bar_new (); + gtk_widget_set_name (menubar2, "menubar2"); + gtk_widget_show (menubar2); + gtk_box_pack_start (GTK_BOX (vbox4), menubar2, FALSE, FALSE, 0); + + menuitem5 = gtk_menu_item_new_with_mnemonic ("_File"); + gtk_widget_set_name (menuitem5, "menuitem5"); + gtk_widget_show (menuitem5); + gtk_container_add (GTK_CONTAINER (menubar2), menuitem5); + + menuitem5_menu = gtk_menu_new (); + gtk_widget_set_name (menuitem5_menu, "menuitem5_menu"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem5), menuitem5_menu); + + new2 = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group); + gtk_widget_set_name (new2, "new2"); + gtk_widget_show (new2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), new2); + + open2 = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group); + gtk_widget_set_name (open2, "open2"); + gtk_widget_show (open2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), open2); + + save2 = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group); + gtk_widget_set_name (save2, "save2"); + gtk_widget_show (save2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), save2); + + save_as2 = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group); + gtk_widget_set_name (save_as2, "save_as2"); + gtk_widget_show (save_as2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), save_as2); + + separatormenuitem2 = gtk_separator_menu_item_new (); + gtk_widget_set_name (separatormenuitem2, "separatormenuitem2"); + gtk_widget_show (separatormenuitem2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), separatormenuitem2); + gtk_widget_set_sensitive (separatormenuitem2, FALSE); + + quit2 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); + gtk_widget_set_name (quit2, "quit2"); + gtk_widget_show (quit2); + gtk_container_add (GTK_CONTAINER (menuitem5_menu), quit2); + + menuitem6 = gtk_menu_item_new_with_mnemonic ("_Edit"); + gtk_widget_set_name (menuitem6, "menuitem6"); + gtk_widget_show (menuitem6); + gtk_container_add (GTK_CONTAINER (menubar2), menuitem6); + + menuitem6_menu = gtk_menu_new (); + gtk_widget_set_name (menuitem6_menu, "menuitem6_menu"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem6), menuitem6_menu); + + cut2 = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); + gtk_widget_set_name (cut2, "cut2"); + gtk_widget_show (cut2); + gtk_container_add (GTK_CONTAINER (menuitem6_menu), cut2); + + copy2 = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); + gtk_widget_set_name (copy2, "copy2"); + gtk_widget_show (copy2); + gtk_container_add (GTK_CONTAINER (menuitem6_menu), copy2); + + paste2 = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); + gtk_widget_set_name (paste2, "paste2"); + gtk_widget_show (paste2); + gtk_container_add (GTK_CONTAINER (menuitem6_menu), paste2); + + delete2 = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); + gtk_widget_set_name (delete2, "delete2"); + gtk_widget_show (delete2); + gtk_container_add (GTK_CONTAINER (menuitem6_menu), delete2); + + menuitem8 = gtk_menu_item_new_with_mnemonic ("_Help"); + gtk_widget_set_name (menuitem8, "menuitem8"); + gtk_widget_show (menuitem8); + gtk_container_add (GTK_CONTAINER (menubar2), menuitem8); + + menuitem8_menu = gtk_menu_new (); + gtk_widget_set_name (menuitem8_menu, "menuitem8_menu"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem8), menuitem8_menu); + + about2 = gtk_menu_item_new_with_mnemonic ("_About"); + gtk_widget_set_name (about2, "about2"); + gtk_widget_show (about2); + gtk_container_add (GTK_CONTAINER (menuitem8_menu), about2); + + combobox1 = gtk_combo_box_new_text (); + gtk_widget_set_name (combobox1, "combobox1"); + gtk_widget_show (combobox1); + gtk_box_pack_start (GTK_BOX (vbox4), combobox1, FALSE, FALSE, 0); + gtk_combo_box_append_text (GTK_COMBO_BOX (combobox1), "item 1"); + gtk_combo_box_append_text (GTK_COMBO_BOX (combobox1), "item 2"); + gtk_combo_box_append_text (GTK_COMBO_BOX (combobox1), "item 3"); + + comboboxentry1 = gtk_combo_box_entry_new_text (); + gtk_widget_set_name (comboboxentry1, "comboboxentry1"); + gtk_widget_show (comboboxentry1); + gtk_box_pack_start (GTK_BOX (vbox4), comboboxentry1, FALSE, FALSE, 0); + gtk_widget_set_size_request (comboboxentry1, 80, 25); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxentry1), "item 1"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxentry1), "item 2"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxentry1), "item 3"); + + hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (15, 0, 50, 1, 0, 0))); + gtk_widget_set_name (hscale1, "hscale1"); + gtk_widget_show (hscale1); + gtk_box_pack_start (GTK_BOX (vbox4), hscale1, TRUE, TRUE, 0); + gtk_scale_set_digits (GTK_SCALE (hscale1), 0); + + scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_set_name (scrolledwindow1, "scrolledwindow1"); + gtk_widget_show (scrolledwindow1); + gtk_table_attach (GTK_TABLE (table1), scrolledwindow1, 2, 3, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + preview_treeview = gtk_tree_view_new (); + gtk_widget_set_name (preview_treeview, "preview_treeview"); + gtk_widget_show (preview_treeview); + gtk_container_add (GTK_CONTAINER (scrolledwindow1), preview_treeview); + gtk_tree_view_set_reorderable (GTK_TREE_VIEW (preview_treeview), TRUE); + + statusbar1 = gtk_statusbar_new (); + gtk_widget_set_name (statusbar1, "statusbar1"); + gtk_widget_show (statusbar1); + gtk_table_attach (GTK_TABLE (table1), statusbar1, 1, 3, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_widget_set_size_request (statusbar1, 6, 20); + + progressbar1 = gtk_progress_bar_new (); + gtk_widget_set_name (progressbar1, "progressbar1"); + gtk_widget_show (progressbar1); + gtk_table_attach (GTK_TABLE (table1), progressbar1, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_widget_set_size_request (progressbar1, 80, 20); + gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progressbar1), 0.56); + gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar1), "56%"); + + vseparator1 = gtk_vseparator_new (); + gtk_widget_set_name (vseparator1, "vseparator1"); + gtk_widget_show (vseparator1); + gtk_table_attach (GTK_TABLE (table1), vseparator1, 1, 2, 0, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 5, 0); + + frame1 = gtk_frame_new (NULL); + gtk_widget_set_name (frame1, "frame1"); + gtk_widget_show (frame1); + gtk_table_attach (GTK_TABLE (table1), frame1, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND), 0, 0); + gtk_frame_set_label_align (GTK_FRAME (frame1), 0.5, 0.5); + + vbox3 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox3, "vbox3"); + gtk_widget_show (vbox3); + gtk_container_add (GTK_CONTAINER (frame1), vbox3); + gtk_container_set_border_width (GTK_CONTAINER (vbox3), 5); + + radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "radio 1"); + gtk_widget_set_name (radiobutton1, "radiobutton1"); + gtk_widget_show (radiobutton1); + gtk_box_pack_start (GTK_BOX (vbox3), radiobutton1, FALSE, FALSE, 0); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group); + radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1)); + + radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "radio 2"); + gtk_widget_set_name (radiobutton2, "radiobutton2"); + gtk_widget_show (radiobutton2); + gtk_box_pack_start (GTK_BOX (vbox3), radiobutton2, FALSE, FALSE, 0); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group); + radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2)); + + radiobutton3 = gtk_radio_button_new_with_mnemonic (NULL, "radio 3"); + gtk_widget_set_name (radiobutton3, "radiobutton3"); + gtk_widget_show (radiobutton3); + gtk_box_pack_start (GTK_BOX (vbox3), radiobutton3, FALSE, FALSE, 0); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton3), radiobutton1_group); + radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton3)); + + label6 = gtk_label_new ("frame"); + gtk_widget_set_name (label6, "label6"); + gtk_widget_show (label6); + gtk_frame_set_label_widget (GTK_FRAME (frame1), label6); + gtk_misc_set_padding (GTK_MISC (label6), 1, 0); + + label4 = gtk_label_new ("Common widgets"); + gtk_widget_set_name (label4, "label4"); + gtk_widget_show (label4); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (main_previewbook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (main_previewbook), 0), label4); + + scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_set_name (scrolledwindow2, "scrolledwindow2"); + gtk_widget_show (scrolledwindow2); + gtk_container_add (GTK_CONTAINER (main_previewbook), scrolledwindow2); + + textview1 = gtk_text_view_new (); + gtk_widget_set_name (textview1, "textview1"); + gtk_widget_show (textview1); + gtk_container_add (GTK_CONTAINER (scrolledwindow2), textview1); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview1), GTK_WRAP_WORD); + gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview1), 8); + gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview1), 8); + gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview1)), "You can type some text here.\nYou can also click the right mouse button for a popup menu.", -1); + + label5 = gtk_label_new ("Text area"); + gtk_widget_set_name (label5, "label5"); + gtk_widget_show (label5); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (main_previewbook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (main_previewbook), 1), label5); + + vbox5 = gtk_vbox_new (FALSE, 0); + gtk_widget_set_name (vbox5, "vbox5"); + gtk_widget_show (vbox5); + gtk_container_add (GTK_CONTAINER (main_previewbook), vbox5); + + hbox4 = gtk_hbox_new (FALSE, 0); + gtk_widget_set_name (hbox4, "hbox4"); + gtk_widget_show (hbox4); + gtk_box_pack_start (GTK_BOX (vbox5), hbox4, TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox4), 7); + + about_label = gtk_label_new (""); + gtk_widget_set_name (about_label, "about_label"); + gtk_widget_show (about_label); + gtk_box_pack_start (GTK_BOX (hbox4), about_label, FALSE, FALSE, 0); + gtk_label_set_line_wrap (GTK_LABEL (about_label), TRUE); + + label666 = gtk_label_new ("About"); + gtk_widget_set_name (label666, "label666"); + gtk_widget_show (label666); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (main_previewbook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (main_previewbook), 2), label666); + + label670 = gtk_label_new ("Preview"); + gtk_widget_set_name (label670, "label670"); + gtk_widget_show (label670); + gtk_frame_set_label_widget (GTK_FRAME (frame4), label670); + gtk_label_set_use_markup (GTK_LABEL (label670), TRUE); + + g_signal_connect ((gpointer) main_window, "delete_event", + G_CALLBACK (on_main_window_delete_event), + NULL); + g_signal_connect ((gpointer) main_use_default_font_radio, "toggled", + G_CALLBACK (on_main_use_default_font_radio_toggled), + NULL); + g_signal_connect ((gpointer) main_font_selector_button, "font_set", + G_CALLBACK (on_main_font_selector_button_font_set), + NULL); + g_signal_connect ((gpointer) main_showpreviewtoggle, "toggled", + G_CALLBACK (on_main_showpreviewtoggle_toggled), + NULL); + g_signal_connect ((gpointer) main_ok_button, "clicked", + G_CALLBACK (on_main_ok_button_clicked), + NULL); + g_signal_connect ((gpointer) main_cancel_button, "clicked", + G_CALLBACK (on_main_cancel_button_clicked), + NULL); + g_signal_connect ((gpointer) main_reset_button, "clicked", + G_CALLBACK (on_main_reset_button_clicked), + NULL); + g_signal_connect ((gpointer) new2, "activate", + G_CALLBACK (on_new2_activate), + NULL); + g_signal_connect ((gpointer) open2, "activate", + G_CALLBACK (on_open2_activate), + NULL); + g_signal_connect ((gpointer) save2, "activate", + G_CALLBACK (on_save2_activate), + NULL); + g_signal_connect ((gpointer) save_as2, "activate", + G_CALLBACK (on_save_as2_activate), + NULL); + g_signal_connect ((gpointer) quit2, "activate", + G_CALLBACK (on_quit2_activate), + NULL); + g_signal_connect ((gpointer) cut2, "activate", + G_CALLBACK (on_cut2_activate), + NULL); + g_signal_connect ((gpointer) copy2, "activate", + G_CALLBACK (on_copy2_activate), + NULL); + g_signal_connect ((gpointer) paste2, "activate", + G_CALLBACK (on_paste2_activate), + NULL); + g_signal_connect ((gpointer) delete2, "activate", + G_CALLBACK (on_delete2_activate), + NULL); + g_signal_connect ((gpointer) about2, "activate", + G_CALLBACK (on_about2_activate), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (main_window, main_window, "main_window"); + GLADE_HOOKUP_OBJECT (main_window, main_hbox, "main_hbox"); + GLADE_HOOKUP_OBJECT (main_window, vbox1, "vbox1"); + GLADE_HOOKUP_OBJECT (main_window, hbox1, "hbox1"); + GLADE_HOOKUP_OBJECT (main_window, frame2, "frame2"); + GLADE_HOOKUP_OBJECT (main_window, alignment3, "alignment3"); + GLADE_HOOKUP_OBJECT (main_window, scrolledwindow3, "scrolledwindow3"); + GLADE_HOOKUP_OBJECT (main_window, main_themelist, "main_themelist"); + GLADE_HOOKUP_OBJECT (main_window, label1234, "label1234"); + GLADE_HOOKUP_OBJECT (main_window, frame3, "frame3"); + GLADE_HOOKUP_OBJECT (main_window, alignment4, "alignment4"); + GLADE_HOOKUP_OBJECT (main_window, vbox7, "vbox7"); + GLADE_HOOKUP_OBJECT (main_window, hbox8, "hbox8"); + GLADE_HOOKUP_OBJECT (main_window, vbox9, "vbox9"); + GLADE_HOOKUP_OBJECT (main_window, main_use_default_font_radio, "main_use_default_font_radio"); + GLADE_HOOKUP_OBJECT (main_window, main_use_custom_font_radio, "main_use_custom_font_radio"); + GLADE_HOOKUP_OBJECT (main_window, alignment5, "alignment5"); + GLADE_HOOKUP_OBJECT (main_window, vbox10, "vbox10"); + GLADE_HOOKUP_OBJECT (main_window, hbox9, "hbox9"); + GLADE_HOOKUP_OBJECT (main_window, vbox11, "vbox11"); + GLADE_HOOKUP_OBJECT (main_window, main_font_selector_button, "main_font_selector_button"); + GLADE_HOOKUP_OBJECT (main_window, label669, "label669"); + GLADE_HOOKUP_OBJECT (main_window, vbox13, "vbox13"); + GLADE_HOOKUP_OBJECT (main_window, hbox6666, "hbox6666"); + GLADE_HOOKUP_OBJECT (main_window, main_use_system_config_checkbutton, "main_use_system_config_checkbutton"); + GLADE_HOOKUP_OBJECT (main_window, main_showpreviewtoggle, "main_showpreviewtoggle"); + GLADE_HOOKUP_OBJECT (main_window, hbuttonbox1, "hbuttonbox1"); + GLADE_HOOKUP_OBJECT (main_window, hbox7, "hbox7"); + GLADE_HOOKUP_OBJECT (main_window, hbox6665, "hbox6665"); + GLADE_HOOKUP_OBJECT (main_window, image2, "image2"); + GLADE_HOOKUP_OBJECT (main_window, label2, "label2"); + GLADE_HOOKUP_OBJECT (main_window, vbox6, "vbox6"); + GLADE_HOOKUP_OBJECT (main_window, hbox5, "hbox5"); + GLADE_HOOKUP_OBJECT (main_window, main_ok_button, "main_ok_button"); + GLADE_HOOKUP_OBJECT (main_window, main_cancel_button, "main_cancel_button"); + GLADE_HOOKUP_OBJECT (main_window, main_reset_button, "main_reset_button"); + GLADE_HOOKUP_OBJECT (main_window, alignment2, "alignment2"); + GLADE_HOOKUP_OBJECT (main_window, hbox6, "hbox6"); + GLADE_HOOKUP_OBJECT (main_window, image1, "image1"); + GLADE_HOOKUP_OBJECT (main_window, label667, "label667"); + GLADE_HOOKUP_OBJECT (main_window, main_previewhbox, "main_previewhbox"); + GLADE_HOOKUP_OBJECT (main_window, vseparator2, "vseparator2"); + GLADE_HOOKUP_OBJECT (main_window, frame4, "frame4"); + GLADE_HOOKUP_OBJECT (main_window, alignment6, "alignment6"); + GLADE_HOOKUP_OBJECT (main_window, vbox12, "vbox12"); + GLADE_HOOKUP_OBJECT (main_window, main_previewbook, "main_previewbook"); + GLADE_HOOKUP_OBJECT (main_window, table1, "table1"); + GLADE_HOOKUP_OBJECT (main_window, vbox2, "vbox2"); + GLADE_HOOKUP_OBJECT (main_window, checkbutton1, "checkbutton1"); + GLADE_HOOKUP_OBJECT (main_window, checkbutton2, "checkbutton2"); + GLADE_HOOKUP_OBJECT (main_window, button4, "button4"); + GLADE_HOOKUP_OBJECT (main_window, togglebutton1, "togglebutton1"); + GLADE_HOOKUP_OBJECT (main_window, spinbutton1, "spinbutton1"); + GLADE_HOOKUP_OBJECT (main_window, vbox4, "vbox4"); + GLADE_HOOKUP_OBJECT (main_window, menubar2, "menubar2"); + GLADE_HOOKUP_OBJECT (main_window, menuitem5, "menuitem5"); + GLADE_HOOKUP_OBJECT (main_window, menuitem5_menu, "menuitem5_menu"); + GLADE_HOOKUP_OBJECT (main_window, new2, "new2"); + GLADE_HOOKUP_OBJECT (main_window, open2, "open2"); + GLADE_HOOKUP_OBJECT (main_window, save2, "save2"); + GLADE_HOOKUP_OBJECT (main_window, save_as2, "save_as2"); + GLADE_HOOKUP_OBJECT (main_window, separatormenuitem2, "separatormenuitem2"); + GLADE_HOOKUP_OBJECT (main_window, quit2, "quit2"); + GLADE_HOOKUP_OBJECT (main_window, menuitem6, "menuitem6"); + GLADE_HOOKUP_OBJECT (main_window, menuitem6_menu, "menuitem6_menu"); + GLADE_HOOKUP_OBJECT (main_window, cut2, "cut2"); + GLADE_HOOKUP_OBJECT (main_window, copy2, "copy2"); + GLADE_HOOKUP_OBJECT (main_window, paste2, "paste2"); + GLADE_HOOKUP_OBJECT (main_window, delete2, "delete2"); + GLADE_HOOKUP_OBJECT (main_window, menuitem8, "menuitem8"); + GLADE_HOOKUP_OBJECT (main_window, menuitem8_menu, "menuitem8_menu"); + GLADE_HOOKUP_OBJECT (main_window, about2, "about2"); + GLADE_HOOKUP_OBJECT (main_window, combobox1, "combobox1"); + GLADE_HOOKUP_OBJECT (main_window, comboboxentry1, "comboboxentry1"); + GLADE_HOOKUP_OBJECT (main_window, hscale1, "hscale1"); + GLADE_HOOKUP_OBJECT (main_window, scrolledwindow1, "scrolledwindow1"); + GLADE_HOOKUP_OBJECT (main_window, preview_treeview, "preview_treeview"); + GLADE_HOOKUP_OBJECT (main_window, statusbar1, "statusbar1"); + GLADE_HOOKUP_OBJECT (main_window, progressbar1, "progressbar1"); + GLADE_HOOKUP_OBJECT (main_window, vseparator1, "vseparator1"); + GLADE_HOOKUP_OBJECT (main_window, frame1, "frame1"); + GLADE_HOOKUP_OBJECT (main_window, vbox3, "vbox3"); + GLADE_HOOKUP_OBJECT (main_window, radiobutton1, "radiobutton1"); + GLADE_HOOKUP_OBJECT (main_window, radiobutton2, "radiobutton2"); + GLADE_HOOKUP_OBJECT (main_window, radiobutton3, "radiobutton3"); + GLADE_HOOKUP_OBJECT (main_window, label6, "label6"); + GLADE_HOOKUP_OBJECT (main_window, label4, "label4"); + GLADE_HOOKUP_OBJECT (main_window, scrolledwindow2, "scrolledwindow2"); + GLADE_HOOKUP_OBJECT (main_window, textview1, "textview1"); + GLADE_HOOKUP_OBJECT (main_window, label5, "label5"); + GLADE_HOOKUP_OBJECT (main_window, vbox5, "vbox5"); + GLADE_HOOKUP_OBJECT (main_window, hbox4, "hbox4"); + GLADE_HOOKUP_OBJECT (main_window, about_label, "about_label"); + GLADE_HOOKUP_OBJECT (main_window, label666, "label666"); + GLADE_HOOKUP_OBJECT (main_window, label670, "label670"); + GLADE_HOOKUP_OBJECT_NO_REF (main_window, tooltips, "tooltips"); + + gtk_widget_grab_default (main_themelist); + gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group); + + return main_window; +} + diff --git a/src/gtk2-prefs/interface.h b/src/gtk2-prefs/interface.h new file mode 100644 index 00000000..11c79152 --- /dev/null +++ b/src/gtk2-prefs/interface.h @@ -0,0 +1,5 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget* create_main_window (void); diff --git a/src/gtk2-prefs/main.cpp b/src/gtk2-prefs/main.cpp new file mode 100644 index 00000000..334c23d1 --- /dev/null +++ b/src/gtk2-prefs/main.cpp @@ -0,0 +1,611 @@ +/*************************************************************************** + main.cpp - description + ------------------- + begin : Wed Jan 1 19:06:46 GMT+4 2003 + copyright : (C) 2003 - 2005 by Alex Shaduri + email : ashaduri '@' gmail.com + ***************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include + +#ifdef _WIN32 +#include "win32util.h" +#include +#else +#include +#endif + +#ifdef HAVE_UNISTD_H +#include +#endif + +#include "interface.h" +#include "callbacks.h" +#include "support.h" + +#include "main.h" + + +// ------------------------------------------------------ + + + +GtkWidget* g_main_window = 0; +// GtkWidget* g_fontsel_dialog = 0; + + +static std::string s_tmp_file; + + + +// ------------------------------------------------------ + + + +static std::string gchar_to_string(gchar* gstr) +{ + std::string str = (gstr ? gstr : ""); + g_free(gstr); + return str; +} + + + +std::string get_home_dir() +{ + std::string dir; + + if (g_get_home_dir()) + dir = g_get_home_dir(); + +#ifdef _WIN32 + if (dir == "") { + dir = win32_get_registry_value_string(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", "Personal"); + } + if (dir == "") { + dir = win32_get_registry_value_string(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", "User"); + } +#endif + + return dir; + +} + + + + +// ------------------------------------------------------ + + +static std::string s_orig_theme; +static std::string s_orig_font; + +std::string& get_orig_theme() +{ + return s_orig_theme; +} + + +std::string& get_orig_font() +{ + return s_orig_font; +} + + +// ------------------------------------------------------ + + +std::string get_current_theme() +{ + + GtkSettings* settings = gtk_settings_get_default(); + gchar* theme; + g_object_get(settings, "gtk-theme-name", &theme, NULL); + + return gchar_to_string(theme); +} + + + + +std::string get_current_font() +{ + return gchar_to_string(pango_font_description_to_string(gtk_rc_get_style(g_main_window)->font_desc)); +} + + + +// ------------------------------------------------------ + + + +std::string get_selected_theme() +{ + GtkTreeView* treeview = GTK_TREE_VIEW(lookup_widget(g_main_window, "main_themelist")); + GtkTreeModel* model = gtk_tree_view_get_model(treeview); + GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview); + + GtkTreeIter iter; + gtk_tree_selection_get_selected(selection, 0, &iter); + + gchar* theme_name; + gtk_tree_model_get(model, &iter, 0, &theme_name, -1); +// std::cout << theme_name << "\n"; + return gchar_to_string(theme_name); +} + + + +std::string get_selected_font() +{ +// GtkWidget* fontentry = lookup_widget(g_main_window, "main_fontentry"); +// return gtk_entry_get_text(GTK_ENTRY(fontentry)); + + bool default_font = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(g_main_window, "main_use_default_font_radio"))); + + if (default_font) + return ""; + + GtkWidget* fontbutton = lookup_widget(g_main_window, "main_font_selector_button"); + return gtk_font_button_get_font_name(GTK_FONT_BUTTON(fontbutton)); +} + + +// ------------------------------------------------------ + + + +static void themelist_selection_changed_cb(GtkTreeSelection* selection, gpointer data) +{ + if (gtk_tree_selection_get_selected (selection, 0, 0)) + apply_theme(get_selected_theme(), get_current_font()); +} + + + +// ------------------------------------------------------ + + + +static void populate_with_themes(GtkWidget* w) +{ + + std::string search_path = gchar_to_string(gtk_rc_get_theme_dir()); + //std::string search_path = gchar_to_string(g_build_filename("lib", "gtk-2.0", "2.10.0", "engines", NULL)); + + if (search_path.size() && search_path[search_path.size() -1] != G_DIR_SEPARATOR) + search_path += G_DIR_SEPARATOR_S; + + GDir* gdir = g_dir_open(search_path.c_str(), 0, NULL); + if (gdir == NULL) + return; + + + char* name; + GList* glist = 0; + + while ( (name = const_cast(g_dir_read_name(gdir))) != NULL ) { + std::string filename = name; + +// if (g_ascii_strup(fname.c_str(), -1) == "Default") +// continue; + + std::string fullname = search_path + filename; + std::string rc = fullname; rc += G_DIR_SEPARATOR_S; rc += "gtk-2.0"; rc += G_DIR_SEPARATOR_S; rc += "gtkrc"; + + bool is_dir = 0; + if (g_file_test(fullname.c_str(), G_FILE_TEST_IS_DIR)) + is_dir = 1; + + if (is_dir && g_file_test(rc.c_str(), G_FILE_TEST_IS_REGULAR)) { + glist = g_list_insert_sorted(glist, g_strdup(filename.c_str()), (GCompareFunc)strcmp); + } + } + + g_dir_close(gdir); + + + + + // ---------------- tree + + + GtkTreeView* treeview = GTK_TREE_VIEW(w); + GtkListStore *store = gtk_list_store_new (1, G_TYPE_STRING); + gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store)); + + GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes ( + "Theme", gtk_cell_renderer_text_new(), + "text", 0, + NULL); + gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); + + + GtkTreeIter iter; + + int i =0, curr=0; + while (char* theme = (char*)g_list_nth_data(glist, i)) { + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, 0, theme, -1); + + if (strcmp(theme, get_current_theme().c_str()) == 0) { + curr = i; + } + + ++i; + } + + + GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); + + // set the default theme + + // THIS IS IMPORTANT!!! + gtk_widget_grab_focus(w); + + std::stringstream str; + str << curr; + GtkTreePath* selpath = gtk_tree_path_new_from_string (str.str().c_str()); + if (selpath) { + gtk_tree_selection_select_path(selection, selpath); + gtk_tree_view_scroll_to_cell(treeview, selpath, NULL, true, 0.5, 0.0); + gtk_tree_path_free(selpath); + } + + g_signal_connect (G_OBJECT (selection), "changed", + G_CALLBACK (themelist_selection_changed_cb), NULL); + + g_object_unref (G_OBJECT (store)); + + + // ---------------- font + +// GtkWidget* fontentry = lookup_widget(g_main_window, "main_fontentry"); +// gtk_entry_set_text(GTK_ENTRY(fontentry), get_current_font().c_str()); + + GtkWidget* fontbutton = lookup_widget(g_main_window, "main_font_selector_button"); + gtk_font_button_set_font_name(GTK_FONT_BUTTON(fontbutton), get_current_font().c_str()); + + +} + + + + +// ------------------------------------------------------ + +#ifdef _WIN32 +static void redirect_to_file (const gchar* log_domain, GLogLevelFlags log_level, + const gchar* message, gpointer user_data) +{ + std::fstream f; + f.open("g_stdout.txt", std::ios::app); + f << message << "\n"; + f.close(); +} +#endif + +// ------------------------------------------------------ + + + + +int main(int argc, char *argv[]) +{ + + // work around pango weirdness +#ifdef _WIN32 + // no longer needed as of pango 1.2.5, but won't do any harm +// putenv("PANGO_WIN32_NO_UNISCRIBE=1"); +#endif + + + + + std::string user = g_get_user_name(); + std::string tmp = g_get_tmp_dir(); + std::string tmp_file = tmp + G_DIR_SEPARATOR_S + "gtk_prefs_tmprc_" + user; + s_tmp_file = tmp_file; + gtk_rc_add_default_file(tmp_file.c_str()); + + + + gtk_init (&argc, &argv); + + // redirect gtk warnings to file when in win32 +#if defined _WIN32 && !defined DEBUG + g_log_set_handler ("GLib", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("GModule", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("GLib-GObject", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("GThread", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("Gtk", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("Gdk", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); + g_log_set_handler ("GdkPixbuf", GLogLevelFlags(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL + | G_LOG_FLAG_RECURSION), redirect_to_file, NULL); +#endif + + + add_pixmap_directory("."); + + g_main_window = create_main_window(); + + + populate_with_themes(lookup_widget(g_main_window, "main_themelist")); + + + std::string about_text = std::string("Gtk2 Theme Selector v") + "\n\ +\n\ +by Alex Shaduri \n\ +\n\ + The authors make NO WARRANTY or representation, either express or implied, with respect to this software, its quality, accuracy, merchantability, or fitness for a particular purpose. This software is provided \"AS IS\", and you, its user, assume the entire risk as to its quality and accuracy.\n\ +\n\ + This is free software, and you are welcome to redistribute it under terms of GNU General Public License v2."; + + + gtk_label_set_text(GTK_LABEL(lookup_widget(g_main_window, "about_label")), about_text.c_str()); + + + GtkTreeView* treeview = GTK_TREE_VIEW(lookup_widget(g_main_window, "preview_treeview")); + GtkTreeStore *store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT); + gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store)); + + + GtkTreeViewColumn* column1 = gtk_tree_view_column_new_with_attributes ("Text", gtk_cell_renderer_text_new(), "text", 0, NULL); + gtk_tree_view_column_set_sizing(column1, GTK_TREE_VIEW_COLUMN_GROW_ONLY); + gtk_tree_view_column_set_resizable(column1, true); + gtk_tree_view_column_set_reorderable (column1, true); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column1); + + GtkTreeViewColumn* column2 = gtk_tree_view_column_new_with_attributes ("Number", gtk_cell_renderer_text_new(), "text", 1, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column2); + + + GtkTreeIter iter1, iter2; + + gtk_tree_store_append (store, &iter1, NULL); + gtk_tree_store_set (store, &iter1, 0, "Parent 2", 1, 66, -1); + + gtk_tree_store_append (store, &iter1, NULL); + gtk_tree_store_set (store, &iter1, 0, "Parent 1", 1, 65, -1); + + gtk_tree_store_append (store, &iter2, &iter1); + gtk_tree_store_set (store, &iter2, 0, "Child 1", 1, 67, -1); + + gtk_tree_view_column_set_sort_column_id(column1, 0); + gtk_tree_view_column_set_sort_order (column1, GTK_SORT_ASCENDING); + gtk_tree_view_column_set_sort_indicator(column1, true); + gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_ASCENDING); + + g_object_unref (G_OBJECT (store)); + + + get_orig_theme() = get_current_theme(); + get_orig_font() = get_current_font(); + + + gtk_widget_show (g_main_window); + + + gtk_main(); + + return EXIT_SUCCESS; + +} + + + +// ------------------------------- + + + +void set_theme(const std::string& theme_name, const std::string& font) +{ + // set widgets accordingly + + // tree + GtkTreeView* treeview = GTK_TREE_VIEW(lookup_widget(g_main_window, "main_themelist")); + GtkTreeModel* model = gtk_tree_view_get_model(treeview); + GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview); + + GtkTreeIter iter; + gtk_tree_model_get_iter_first(model, &iter); + + while(gtk_tree_model_iter_next(model, &iter)) { + + gchar* text; + gtk_tree_model_get (model, &iter, 0, &text, -1); + std::string theme = gchar_to_string(text); + + if (theme_name == theme) { + gtk_tree_selection_select_iter(selection, &iter); + break; + } + + } + + + // font +// GtkWidget* fontentry = lookup_widget(g_main_window, "main_fontentry"); +// gtk_entry_set_text(GTK_ENTRY(fontentry), font.c_str()); + + if (font != "") { + GtkWidget* fontbutton = lookup_widget(g_main_window, "main_font_selector_button"); + gtk_font_button_set_font_name(GTK_FONT_BUTTON(fontbutton), get_current_font().c_str()); + } + + + apply_theme(get_selected_theme(), get_selected_font()); + +} + + + + +void apply_theme(const std::string& theme_name, const std::string& font) +{ + + std::stringstream strstr; + strstr << "gtk-theme-name = \"" << theme_name << "\"\n"; + + if (font != "") + strstr << "style \"user-font\"\n{\nfont_name=\"" << font << "\"\n}\nwidget_class \"*\" style \"user-font\""; + +// std::cout << strstr.str() << "\n\n\n"; + std::fstream f; + f.open(s_tmp_file.c_str(), std::ios::out); + f << strstr.str(); + f.close(); + + + GtkSettings* settings = gtk_settings_get_default(); + + gtk_rc_reparse_all_for_settings (settings, true); +// gtk_rc_parse_string(strstr.str().c_str()); +// gtk_rc_parse("/root/.gtk-tmp"); +// gtk_rc_reset_styles(settings); + + unlink(s_tmp_file.c_str()); + + while (gtk_events_pending()) + gtk_main_iteration(); + + +} + + + + +#ifdef _WIN32 +#ifdef HAVE_DIRECT_H +#include +#define mkdir(a) _mkdir(a) +#else +#define mkdir(a, b) mkdir(a) +#endif +#endif + + +bool save_current_theme() +{ + + std::string conf_file = ""; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(g_main_window, "main_use_system_config_checkbutton")))) { + + char* themes_dir_c = gtk_rc_get_theme_dir(); + char* conf_file_c = g_build_filename(themes_dir_c, "..", "..", "etc", "gtk-2.0", "gtkrc", NULL); + + conf_file = (conf_file_c ? conf_file_c : ""); + + // file doesn't exist, try to get it from gtk. + if (!g_file_test(conf_file.c_str(), G_FILE_TEST_EXISTS)) { + + gchar** rc_files = gtk_rc_get_default_files(); + if (rc_files[0] != 0) { + conf_file = rc_files[0]; + } + + } + + + g_free(themes_dir_c); + g_free(conf_file_c); + + + // mkdir a directory, only one level deep + char* etc = g_path_get_dirname(conf_file.c_str()); + if (!g_file_test(etc, G_FILE_TEST_IS_DIR)) { + mkdir(etc, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + } + g_free(etc); + + + } else { + + conf_file = get_home_dir(); + + if (conf_file[conf_file.length()-1] != G_DIR_SEPARATOR) + conf_file += G_DIR_SEPARATOR_S; + + conf_file += ".gtkrc-2.0"; + + } + + + + // ask + + GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + GtkWidget* dialog = gtk_dialog_new_with_buttons ("Query", GTK_WINDOW(window), + GtkDialogFlags(GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL), + GTK_STOCK_NO, GTK_RESPONSE_REJECT, + GTK_STOCK_YES, GTK_RESPONSE_ACCEPT, + NULL); + gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE); + GtkWidget* hbox = gtk_hbox_new(1, 1); + gtk_container_set_border_width(GTK_CONTAINER(hbox), 10); + + gtk_container_add (GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); + gtk_container_add (GTK_CONTAINER(hbox), + gtk_label_new((std::string("\n\nThe file \"") + conf_file + "\" will be overwritten.\nAre you sure?\n\n").c_str())); + + gtk_widget_show_all (dialog); + + bool ret = 0; + gint result = gtk_dialog_run (GTK_DIALOG (dialog)); + switch (result) { + case GTK_RESPONSE_ACCEPT: + ret = 1; + break; + } + gtk_widget_destroy(dialog); + gtk_widget_destroy(window); + + if (!ret) // the user pressed "No". + return false; + + + std::string font = get_selected_font(); + + std::fstream f; + f.open(conf_file.c_str(), std::ios::out); + f << "# Auto-written by gtk2_prefs. Do not edit.\n\n"; + f << "gtk-theme-name = \"" << get_selected_theme() << "\"\n"; + + if (font != "") + f << "style \"user-font\"\n{\n\tfont_name=\"" << font << "\"\n}\nwidget_class \"*\" style \"user-font\""; + f.close(); + + + return true; + +} + + + + +void program_shutdown() +{ + gtk_main_quit(); +} + + + + + diff --git a/src/gtk2-prefs/main.h b/src/gtk2-prefs/main.h new file mode 100644 index 00000000..ab4e5cbd --- /dev/null +++ b/src/gtk2-prefs/main.h @@ -0,0 +1,32 @@ +/*************************************************************************** + main.cpp - description + ------------------- + begin : Wed Jan 1 2003 + copyright : (C) 2003 - 2005 by Alex Shaduri + email : ashaduri '@' gmail.com + ***************************************************************************/ + +#ifndef _MAIN_H_ +#define _MAIN_H_ + + +#include + + +std::string& get_orig_theme(); +std::string& get_orig_font(); + +std::string get_current_theme(); +std::string get_current_font(); + +std::string get_selected_theme(); +std::string get_selected_font(); + +void set_theme(const std::string& theme_name, const std::string& font); +void apply_theme(const std::string& theme_name, const std::string& font); +bool save_current_theme(); + +void program_shutdown(); + + +#endif diff --git a/src/gtk2-prefs/makefile.mak b/src/gtk2-prefs/makefile.mak new file mode 100644 index 00000000..1eeeb565 --- /dev/null +++ b/src/gtk2-prefs/makefile.mak @@ -0,0 +1,24 @@ +include "..\makeinc.mak" + +TARGET = gtk2-prefs.exe + +PREF_OBJECTS = \ +callbacks.obj \ +interface.obj \ +support.obj \ +win32util.obj \ +main.obj + +CPPFLAGS = $(CPPFLAGS) /D_STL70_ /D_STATIC_CPPLIB /EHsc /DHAVE_CONFIG_H + +all: $(PREF_OBJECTS) $(TARGET) + +.cpp.obj: + $(CC) $(CPPFLAGS) $(GLIB) $(GTK) /I. /c $< + +$(TARGET): $(PREF_OBJECTS) + $(LINK) /out:$(TARGET) /entry:mainCRTStartup $(LDFLAGS) $(PREF_OBJECTS) ntstc_msvcrt.lib $(LIBS) + +clean: + del $(TARGET) + del *.obj diff --git a/src/gtk2-prefs/support.cpp b/src/gtk2-prefs/support.cpp new file mode 100644 index 00000000..bb19f284 --- /dev/null +++ b/src/gtk2-prefs/support.cpp @@ -0,0 +1,146 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include + +#include + +#include "support.h" + +GtkWidget* +lookup_widget (GtkWidget *widget, + const gchar *widget_name) +{ + GtkWidget *parent, *found_widget; + + for (;;) + { + if (GTK_IS_MENU (widget)) + parent = gtk_menu_get_attach_widget (GTK_MENU (widget)); + else + parent = widget->parent; + if (!parent) + parent = (GtkWidget*)g_object_get_data (G_OBJECT (widget), "GladeParentKey"); + if (parent == NULL) + break; + widget = parent; + } + + found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), + widget_name); + if (!found_widget) + g_warning ("Widget not found: %s", widget_name); + return found_widget; +} + +static GList *pixmaps_directories = NULL; + +/* Use this function to set the directory containing installed pixmaps. */ +void +add_pixmap_directory (const gchar *directory) +{ + pixmaps_directories = g_list_prepend (pixmaps_directories, + g_strdup (directory)); +} + +/* This is an internally used function to find pixmap files. */ +static gchar* +find_pixmap_file (const gchar *filename) +{ + GList *elem; + + /* We step through each of the pixmaps directory to find it. */ + elem = pixmaps_directories; + while (elem) + { + gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data, + G_DIR_SEPARATOR_S, filename); + if (g_file_test (pathname, G_FILE_TEST_EXISTS)) + return pathname; + g_free (pathname); + elem = elem->next; + } + return NULL; +} + +/* This is an internally used function to create pixmaps. */ +GtkWidget* +create_pixmap (GtkWidget *widget, + const gchar *filename) +{ + gchar *pathname = NULL; + GtkWidget *pixmap; + + if (!filename || !filename[0]) + return gtk_image_new (); + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return gtk_image_new (); + } + + pixmap = gtk_image_new_from_file (pathname); + g_free (pathname); + return pixmap; +} + +/* This is an internally used function to create pixmaps. */ +GdkPixbuf* +create_pixbuf (const gchar *filename) +{ + gchar *pathname = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + + if (!filename || !filename[0]) + return NULL; + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return NULL; + } + + pixbuf = gdk_pixbuf_new_from_file (pathname, &error); + if (!pixbuf) + { + fprintf (stderr, "Failed to load pixbuf file: %s: %s\n", + pathname, error->message); + g_error_free (error); + } + g_free (pathname); + return pixbuf; +} + +/* This is used to set ATK action descriptions. */ +void +glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description) +{ + gint n_actions, i; + + n_actions = atk_action_get_n_actions (action); + for (i = 0; i < n_actions; i++) + { + if (!strcmp (atk_action_get_name (action, i), action_name)) + atk_action_set_description (action, i, description); + } +} + diff --git a/src/gtk2-prefs/support.h b/src/gtk2-prefs/support.h new file mode 100644 index 00000000..2dea079c --- /dev/null +++ b/src/gtk2-prefs/support.h @@ -0,0 +1,44 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + +/* + * Public Functions. + */ + +/* + * This function returns a widget in a component created by Glade. + * Call it with the toplevel widget in the component (i.e. a window/dialog), + * or alternatively any widget in the component, and the name of the widget + * you want returned. + */ +GtkWidget* lookup_widget (GtkWidget *widget, + const gchar *widget_name); + + +/* Use this function to set the directory containing installed pixmaps. */ +void add_pixmap_directory (const gchar *directory); + + +/* + * Private Functions. + */ + +/* This is used to create the pixmaps used in the interface. */ +GtkWidget* create_pixmap (GtkWidget *widget, + const gchar *filename); + +/* This is used to create the pixbufs used in the interface. */ +GdkPixbuf* create_pixbuf (const gchar *filename); + +/* This is used to set ATK action descriptions. */ +void glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description); + diff --git a/src/gtk2-prefs/sys_win32.h b/src/gtk2-prefs/sys_win32.h new file mode 100644 index 00000000..0a106690 --- /dev/null +++ b/src/gtk2-prefs/sys_win32.h @@ -0,0 +1,28 @@ +/*************************************************************************** + sys_win32.h - description + ------------------- + begin : Wed Oct 22 2003 + copyright : (C) 2003 by Alex Shaduri, Irakli A. Elizbarashvili + email : alex_sh@land.ru + ***************************************************************************/ +#ifndef SYS_WIN32_H +#define SYS_WIN32_H + + + + + +#ifdef _WIN32 + +# define WIN32_LEAN_AND_MEAN +# include + +#endif + + + + + + + +#endif diff --git a/src/gtk2-prefs/win32util.cpp b/src/gtk2-prefs/win32util.cpp new file mode 100644 index 00000000..79cab17d --- /dev/null +++ b/src/gtk2-prefs/win32util.cpp @@ -0,0 +1,80 @@ +/*************************************************************************** + win32util.cpp - description + ------------------- + begin : Tue Jan 14 2003 + copyright : (C) 2003 by Alex Shaduri + email : alex_sh@land.ru + ***************************************************************************/ + +#ifdef _WIN32 + +#include +#include "sys_win32.h" +#include "win32util.h" + + + + + +std::string win32_get_registry_value_string(HKEY base, const std::string& keydir, const std::string& key) +{ + + HKEY reg_key = NULL; + DWORD type; + DWORD nbytes; + char* result = NULL; +//HKEY_CURRENT_USER + nbytes = 0; + if ( RegOpenKeyEx ( base, keydir.c_str(), 0, KEY_QUERY_VALUE, ®_key) == ERROR_SUCCESS + && RegQueryValueEx (reg_key, key.c_str(), 0, &type, NULL, &nbytes) == ERROR_SUCCESS ) { + result = (char*)malloc(nbytes + 1); + RegQueryValueEx (reg_key, key.c_str(), 0, &type, (BYTE*)result, &nbytes); + result[nbytes] = '\0'; + } + + if (reg_key != NULL) + RegCloseKey (reg_key); + + std::string ret = ""; + + if (result) { + ret = result; + } + + return ret; + +} + + + + +void win32_set_registry_value_string(HKEY base, const std::string& keydir, const std::string& key, const std::string& value) +{ + + HKEY reg_key = NULL; + DWORD nbytes; + + nbytes = value.length() + 1; + + if ( RegOpenKeyEx ( base, keydir.c_str(), 0, KEY_QUERY_VALUE, ®_key) == ERROR_SUCCESS) { + RegSetValueEx (reg_key, key.c_str(), 0, REG_SZ, (const BYTE*)(value.c_str()), nbytes); + } + + if (reg_key != NULL) + RegCloseKey (reg_key); + +} + + + + + + + +#endif + + + + + + diff --git a/src/gtk2-prefs/win32util.h b/src/gtk2-prefs/win32util.h new file mode 100644 index 00000000..8c194a19 --- /dev/null +++ b/src/gtk2-prefs/win32util.h @@ -0,0 +1,26 @@ +/*************************************************************************** + win32util.h - description + ------------------- + begin : Tue Jan 14 2003 + copyright : (C) 2003 by Alex Shaduri + email : alex_sh@land.ru + ***************************************************************************/ +#ifndef WIN32UTIL_H +#define WIN32UTIL_H + +#ifdef _WIN32 + +#include +#include "sys_win32.h" + + + +std::string win32_get_registry_value_string(HKEY base, const std::string& keydir, const std::string& key); +void win32_set_registry_value_string(HKEY base, const std::string& keydir, const std::string& key, const std::string& value); + + + + +#endif //_WIN32 + +#endif // WIN32UTIL_H