diff options
Diffstat (limited to 'applets/wncklet/window-list.c')
| -rw-r--r-- | applets/wncklet/window-list.c | 749 |
1 files changed, 749 insertions, 0 deletions
diff --git a/applets/wncklet/window-list.c b/applets/wncklet/window-list.c new file mode 100644 index 00000000..edde537d --- /dev/null +++ b/applets/wncklet/window-list.c @@ -0,0 +1,749 @@ +/* -*- mode: C; c-file-style: "linux" -*- */ +/* + * libwnck based tasklist applet. + * (C) 2001 Red Hat, Inc + * (C) 2001 Alexander Larsson + * + * Authors: Alexander Larsson + * + */ + +#define WNCK_I_KNOW_THIS_IS_UNSTABLE 1 + +#ifdef HAVE_CONFIG_H + #include <config.h> +#endif + +#include <string.h> + +#include <mate-panel-applet.h> +#include <mate-panel-applet-mateconf.h> + +#include <glib/gi18n.h> +#include <gtk/gtk.h> +#include <libwnck/libwnck.h> +#include <mateconf/mateconf-client.h> + +#include "wncklet.h" +#include "window-list.h" + +#define WINDOW_LIST_ICON "mate-panel-window-list" + +typedef struct { + GtkWidget* applet; + GtkWidget* tasklist; + + gboolean include_all_workspaces; + WnckTasklistGroupingType grouping; + gboolean move_unminimized_windows; + + GtkOrientation orientation; + int size; + + GtkIconTheme* icon_theme; + + /* Properties: */ + GtkWidget* properties_dialog; + GtkWidget* show_current_radio; + GtkWidget* show_all_radio; + GtkWidget* never_group_radio; + GtkWidget* auto_group_radio; + GtkWidget* always_group_radio; + GtkWidget* minimized_windows_label; + GtkWidget* move_minimized_radio; + GtkWidget* change_workspace_radio; + + /* new options, must be translated! */ + /*GtkWidget* style_group_radio; + GtkWidget* icon_group_radio; + GtkWidget* text_group_radio;*/ + + + + /* mateconf listeners id */ + guint listeners [3]; +} TasklistData; + +static void display_properties_dialog(GtkAction* action, TasklistData* tasklist); +static void display_help_dialog(GtkAction* action, TasklistData* tasklist); +static void display_about_dialog(GtkAction* action, TasklistData* tasklist); + +static void tasklist_update(TasklistData* tasklist) +{ + if (tasklist->orientation == GTK_ORIENTATION_HORIZONTAL) + { + gtk_widget_set_size_request(GTK_WIDGET(tasklist->tasklist), -1, tasklist->size); + } + else + { + gtk_widget_set_size_request(GTK_WIDGET(tasklist->tasklist), tasklist->size, -1); + } + + wnck_tasklist_set_grouping(WNCK_TASKLIST(tasklist->tasklist), tasklist->grouping); + wnck_tasklist_set_include_all_workspaces(WNCK_TASKLIST(tasklist->tasklist), tasklist->include_all_workspaces); + wnck_tasklist_set_switch_workspace_on_unminimize(WNCK_TASKLIST(tasklist->tasklist), tasklist->move_unminimized_windows); +} + +static void response_cb(GtkWidget* widget, int id, TasklistData* tasklist) +{ + if (id == GTK_RESPONSE_HELP) + { + wncklet_display_help(widget, "user-guide", "windowlist-prefs", WINDOW_LIST_ICON); + } + else + { + gtk_widget_hide(widget); + } +} + +static void applet_realized(MatePanelApplet* applet, TasklistData* tasklist) +{ + tasklist->icon_theme = gtk_icon_theme_get_for_screen(gtk_widget_get_screen(tasklist->applet)); +} + +static void applet_change_orient(MatePanelApplet* applet, MatePanelAppletOrient orient, TasklistData* tasklist) +{ + GtkOrientation new_orient; + + switch (orient) + { + case MATE_PANEL_APPLET_ORIENT_LEFT: + case MATE_PANEL_APPLET_ORIENT_RIGHT: + new_orient = GTK_ORIENTATION_VERTICAL; + break; + case MATE_PANEL_APPLET_ORIENT_UP: + case MATE_PANEL_APPLET_ORIENT_DOWN: + default: + new_orient = GTK_ORIENTATION_HORIZONTAL; + break; + } + + if (new_orient == tasklist->orientation) + return; + + tasklist->orientation = new_orient; + + tasklist_update(tasklist); +} + +static void applet_change_background(MatePanelApplet* applet, MatePanelAppletBackgroundType type, GdkColor* color, GdkPixmap* pixmap, TasklistData* tasklist) +{ + switch (type) + { + case PANEL_NO_BACKGROUND: + wnck_tasklist_set_button_relief(WNCK_TASKLIST(tasklist->tasklist), GTK_RELIEF_NORMAL); + break; + case PANEL_COLOR_BACKGROUND: + case PANEL_PIXMAP_BACKGROUND: + wnck_tasklist_set_button_relief(WNCK_TASKLIST(tasklist->tasklist), GTK_RELIEF_NONE); + break; + } +} + +static void applet_change_pixel_size(MatePanelApplet* applet, gint size, TasklistData* tasklist) +{ + if (tasklist->size == size) + return; + + tasklist->size = size; + + tasklist_update(tasklist); +} + +static void destroy_tasklist(GtkWidget* widget, TasklistData* tasklist) +{ + MateConfClient* client = mateconf_client_get_default(); + + mateconf_client_notify_remove(client, tasklist->listeners[0]); + mateconf_client_notify_remove(client, tasklist->listeners[1]); + mateconf_client_notify_remove(client, tasklist->listeners[2]); + + g_object_unref(G_OBJECT(client)); + + tasklist->listeners[0] = 0; + tasklist->listeners[1] = 0; + tasklist->listeners[2] = 0; + + if (tasklist->properties_dialog) + gtk_widget_destroy(tasklist->properties_dialog); + + g_free(tasklist); +} + +static const GtkActionEntry tasklist_menu_actions[] = { + { + "TasklistPreferences", + GTK_STOCK_PROPERTIES, + N_("_Preferences"), + NULL, + NULL, + G_CALLBACK(display_properties_dialog) + }, + { + "TasklistHelp", + GTK_STOCK_HELP, + N_("_Help"), + NULL, + NULL, + G_CALLBACK(display_help_dialog) + }, + { + "TasklistAbout", + GTK_STOCK_ABOUT, + N_("_About"), + NULL, + NULL, + G_CALLBACK(display_about_dialog) + } +}; + +static void tasklist_properties_update_content_radio(TasklistData* tasklist) +{ + GtkWidget* button; + + if (tasklist->show_current_radio == NULL) + return; + + if (tasklist->include_all_workspaces) + { + button = tasklist->show_all_radio; + } + else + { + button = tasklist->show_current_radio; + } + + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); + + gtk_widget_set_sensitive(tasklist->minimized_windows_label, tasklist->include_all_workspaces); + gtk_widget_set_sensitive(tasklist->move_minimized_radio, tasklist->include_all_workspaces); + gtk_widget_set_sensitive(tasklist->change_workspace_radio, tasklist->include_all_workspaces); +} + +static void display_all_workspaces_changed(MateConfClient* client, guint cnxn_id, MateConfEntry* entry, TasklistData* tasklist) +{ + gboolean value; + + if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL) + return; + + value = mateconf_value_get_bool(entry->value); + + tasklist->include_all_workspaces = (value != 0); + tasklist_update(tasklist); + + tasklist_properties_update_content_radio(tasklist); +} + +static WnckTasklistGroupingType get_grouping_type(MateConfValue* value) +{ + WnckTasklistGroupingType type = -1; + const char* str; + + g_assert(value != NULL); + + /* Backwards compat for old type: */ + if (value->type == MATECONF_VALUE_BOOL) + { + type = (mateconf_value_get_bool(value)) ? WNCK_TASKLIST_AUTO_GROUP : WNCK_TASKLIST_NEVER_GROUP; + + } + else if (value->type == MATECONF_VALUE_STRING) + { + str = mateconf_value_get_string(value); + + if (g_ascii_strcasecmp(str, "never") == 0) + { + type = WNCK_TASKLIST_NEVER_GROUP; + } + else if (g_ascii_strcasecmp(str, "auto") == 0) + { + type = WNCK_TASKLIST_AUTO_GROUP; + } + else if (g_ascii_strcasecmp(str, "always") == 0) + { + type = WNCK_TASKLIST_ALWAYS_GROUP; + } + } + + return type; +} + +static GtkWidget* get_grouping_button(TasklistData* tasklist, WnckTasklistGroupingType type) +{ + switch (type) + { + default: + case WNCK_TASKLIST_NEVER_GROUP: + return tasklist->never_group_radio; + break; + case WNCK_TASKLIST_AUTO_GROUP: + return tasklist->auto_group_radio; + break; + case WNCK_TASKLIST_ALWAYS_GROUP: + return tasklist->always_group_radio; + break; + } +} + +static void group_windows_changed(MateConfClient* client, guint cnxn_id, MateConfEntry* entry, TasklistData* tasklist) +{ + WnckTasklistGroupingType type; + GtkWidget* button; + + if (!entry->value || (entry->value->type != MATECONF_VALUE_BOOL && entry->value->type != MATECONF_VALUE_STRING)) + return; + + type = get_grouping_type(entry->value); + + if (type == -1) + { + g_warning("tasklist: Unknown value for MateConf key 'group_windows'"); + return; + } + + tasklist->grouping = type; + tasklist_update(tasklist); + + button = get_grouping_button(tasklist, type); + + if (button && !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) + { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); + } +} + +static void tasklist_update_unminimization_radio(TasklistData* tasklist) +{ + GtkWidget* button; + + if (tasklist->move_minimized_radio == NULL) + return; + + if (tasklist->move_unminimized_windows) + { + button = tasklist->move_minimized_radio; + } + else + { + button = tasklist->change_workspace_radio; + } + + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); +} + + +static void move_unminimized_windows_changed(MateConfClient* client, guint cnxn_id, MateConfEntry* entry, TasklistData* tasklist) +{ + gboolean value; + + if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL) + return; + + value = mateconf_value_get_bool(entry->value); + + tasklist->move_unminimized_windows = (value != 0); + tasklist_update(tasklist); + + tasklist_update_unminimization_radio(tasklist); +} + +static void setup_mateconf(TasklistData* tasklist) +{ + MateConfClient* client; + char* key; + + client = mateconf_client_get_default(); + + key = mate_panel_applet_mateconf_get_full_key(MATE_PANEL_APPLET(tasklist->applet), "display_all_workspaces"); + tasklist->listeners[0] = mateconf_client_notify_add(client, key, (MateConfClientNotifyFunc) display_all_workspaces_changed, tasklist, NULL, NULL); + g_free(key); + + key = mate_panel_applet_mateconf_get_full_key(MATE_PANEL_APPLET(tasklist->applet), "group_windows"); + tasklist->listeners[1] = mateconf_client_notify_add(client, key, (MateConfClientNotifyFunc) group_windows_changed, tasklist, NULL, NULL); + g_free(key); + + key = mate_panel_applet_mateconf_get_full_key(MATE_PANEL_APPLET(tasklist->applet), "move_unminimized_windows"); + tasklist->listeners[2] = mateconf_client_notify_add(client, key, (MateConfClientNotifyFunc) move_unminimized_windows_changed, tasklist, NULL, NULL); + g_free(key); + + g_object_unref(G_OBJECT(client)); +} + +static void applet_size_request(GtkWidget* widget, GtkRequisition* requisition, TasklistData* tasklist) +{ + int len; + const int* size_hints; + GtkRequisition child_req; + WnckTasklist* wncktl = WNCK_TASKLIST(tasklist->tasklist); + + gtk_widget_get_child_requisition(tasklist->applet, &child_req); + + size_hints = wnck_tasklist_get_size_hint_list(wncktl, &len); + g_assert(len % 2 == 0); + + mate_panel_applet_set_size_hints(MATE_PANEL_APPLET(tasklist->applet), size_hints, len, 0); +} + +static GdkPixbuf* icon_loader_func(const char* icon, int size, unsigned int flags, void* data) +{ + TasklistData* tasklist; + GdkPixbuf* retval; + char* icon_no_extension; + char* p; + + tasklist = data; + + if (icon == NULL || strcmp(icon, "") == 0) + return NULL; + + if (g_path_is_absolute(icon)) + { + if (g_file_test(icon, G_FILE_TEST_EXISTS)) + { + return gdk_pixbuf_new_from_file_at_size(icon, size, size, NULL); + } + else + { + char* basename; + + basename = g_path_get_basename(icon); + retval = icon_loader_func(basename, size, flags, data); + g_free(basename); + + return retval; + } + } + + /* This is needed because some .desktop files have an icon name *and* + * an extension as icon */ + icon_no_extension = g_strdup(icon); + p = strrchr(icon_no_extension, '.'); + + if (p && (strcmp(p, ".png") == 0 || strcmp(p, ".xpm") == 0 || strcmp(p, ".svg") == 0)) + { + *p = 0; + } + + retval = gtk_icon_theme_load_icon(tasklist->icon_theme, icon_no_extension, size, 0, NULL); + g_free(icon_no_extension); + + return retval; +} + +gboolean window_list_applet_fill(MatePanelApplet* applet) +{ + TasklistData* tasklist; + GtkActionGroup* action_group; + gchar* ui_path; + GError* error; + MateConfValue* value; + + tasklist = g_new0(TasklistData, 1); + + tasklist->applet = GTK_WIDGET(applet); + + mate_panel_applet_set_flags(MATE_PANEL_APPLET(tasklist->applet), MATE_PANEL_APPLET_EXPAND_MAJOR | MATE_PANEL_APPLET_EXPAND_MINOR | MATE_PANEL_APPLET_HAS_HANDLE); + + mate_panel_applet_add_preferences(applet, "/schemas/apps/window_list_applet/prefs", NULL); + + setup_mateconf(tasklist); + + error = NULL; + + tasklist->include_all_workspaces = mate_panel_applet_mateconf_get_bool(applet, "display_all_workspaces", &error); + + if (error) + { + g_error_free(error); + tasklist->include_all_workspaces = FALSE; /* Default value */ + } + + error = NULL; + tasklist->grouping = -1; + + value = mate_panel_applet_mateconf_get_value(applet, "group_windows", &error); + + if (error) + { + g_error_free(error); + } + else if (value) + { + tasklist->grouping = get_grouping_type(value); + mateconf_value_free(value); + } + + if (tasklist->grouping < 0) + tasklist->grouping = WNCK_TASKLIST_AUTO_GROUP; /* Default value */ + + error = NULL; + tasklist->move_unminimized_windows = mate_panel_applet_mateconf_get_bool(applet, "move_unminimized_windows", &error); + + if (error) + { + g_error_free(error); + tasklist->move_unminimized_windows = TRUE; /* Default value */ + } + + tasklist->size = mate_panel_applet_get_size(applet); + + switch (mate_panel_applet_get_orient(applet)) + { + case MATE_PANEL_APPLET_ORIENT_LEFT: + case MATE_PANEL_APPLET_ORIENT_RIGHT: + tasklist->orientation = GTK_ORIENTATION_VERTICAL; + break; + case MATE_PANEL_APPLET_ORIENT_UP: + case MATE_PANEL_APPLET_ORIENT_DOWN: + default: + tasklist->orientation = GTK_ORIENTATION_HORIZONTAL; + break; + } + + tasklist->tasklist = wnck_tasklist_new(NULL); + + wnck_tasklist_set_icon_loader(WNCK_TASKLIST(tasklist->tasklist), icon_loader_func, tasklist, NULL); + + g_signal_connect(G_OBJECT(tasklist->tasklist), "destroy", G_CALLBACK(destroy_tasklist), tasklist); + + g_signal_connect(G_OBJECT(tasklist->applet), "size_request", G_CALLBACK(applet_size_request), tasklist); + tasklist_update(tasklist); + gtk_widget_show(tasklist->tasklist); + + gtk_container_add(GTK_CONTAINER(tasklist->applet), tasklist->tasklist); + + g_signal_connect(G_OBJECT(tasklist->applet), "realize", G_CALLBACK(applet_realized), tasklist); + g_signal_connect(G_OBJECT(tasklist->applet), "change_orient", G_CALLBACK(applet_change_orient), tasklist); + g_signal_connect(G_OBJECT(tasklist->applet), "change_size", G_CALLBACK(applet_change_pixel_size), tasklist); + g_signal_connect(G_OBJECT(tasklist->applet), "change_background", G_CALLBACK(applet_change_background), tasklist); + + mate_panel_applet_set_background_widget(MATE_PANEL_APPLET(tasklist->applet), GTK_WIDGET(tasklist->applet)); + + action_group = gtk_action_group_new("Tasklist Applet Actions"); + gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE); + gtk_action_group_add_actions(action_group, tasklist_menu_actions, G_N_ELEMENTS(tasklist_menu_actions), tasklist); + ui_path = g_build_filename(WNCK_MENU_UI_DIR, "window-list-menu.xml", NULL); + mate_panel_applet_setup_menu_from_file(MATE_PANEL_APPLET(tasklist->applet), ui_path, action_group); + g_free(ui_path); + + if (mate_panel_applet_get_locked_down(MATE_PANEL_APPLET(tasklist->applet))) + { + GtkAction* action; + + action = gtk_action_group_get_action(action_group, "TasklistPreferences"); + gtk_action_set_visible(action, FALSE); + } + + g_object_unref(action_group); + + gtk_widget_show(tasklist->applet); + + return TRUE; +} + + +static void display_help_dialog(GtkAction* action, TasklistData* tasklist) +{ + wncklet_display_help(tasklist->applet, "user-guide", "windowlist", WINDOW_LIST_ICON); +} + +static void display_about_dialog(GtkAction* action, TasklistData* tasklist) +{ + static const gchar* authors[] = { + "Alexander Larsson <[email protected]>", + NULL + }; + + const char* documenters [] = { + "Sun MATE Documentation Team <[email protected]>", + NULL + }; + + char copyright[] = \ + "Copyright \xc2\xa9 2001-2002 Red Hat, Inc."; + + gtk_show_about_dialog(GTK_WINDOW(tasklist->applet), + "program-name", _("Window List"), + "authors", authors, + "comments", _("The Window List shows a list of all windows in a set of buttons and lets you browse them."), + "copyright", copyright, + "documenters", documenters, + "icon-name", WINDOW_LIST_ICON, + "logo-icon-name", WINDOW_LIST_ICON, + "translator-credits", _("translator-credits"), + "version", VERSION, + "website", "http://matsusoft.com.ar/projects/mate/", + NULL); +} + +static void group_windows_toggled(GtkToggleButton* button, TasklistData* tasklist) +{ + if (gtk_toggle_button_get_active(button)) + { + char* str = g_object_get_data(G_OBJECT(button), "group_value"); + mate_panel_applet_mateconf_set_string(MATE_PANEL_APPLET(tasklist->applet), "group_windows", str, NULL); + } +} + +/*static void group_button_toggled(GtkToggleButton* button, TasklistData* tasklist) +{ + if (gtk_toggle_button_get_active(button)) + { + char* str = g_object_get_data(G_OBJECT(button), "group_value"); + + printf("str: %s\n", str); + // Add later! + //mate_panel_applet_mateconf_set_string(MATE_PANEL_APPLET(tasklist->applet), "group_button", str, NULL); + } +}*/ + +static void move_minimized_toggled(GtkToggleButton* button, TasklistData* tasklist) +{ + mate_panel_applet_mateconf_set_bool(MATE_PANEL_APPLET(tasklist->applet), "move_unminimized_windows", gtk_toggle_button_get_active(button), NULL); +} + +static void display_all_workspaces_toggled(GtkToggleButton* button, TasklistData* tasklist) +{ + mate_panel_applet_mateconf_set_bool(MATE_PANEL_APPLET(tasklist->applet), "display_all_workspaces", gtk_toggle_button_get_active(button), NULL); +} + +#define WID(s) GTK_WIDGET(gtk_builder_get_object(builder, s)) + +static void setup_sensitivity(TasklistData* tasklist, MateConfClient* client, GtkBuilder* builder, const char* wid1, const char* wid2, const char* wid3, const char* key) +{ + MatePanelApplet* applet = MATE_PANEL_APPLET(tasklist->applet); + char* fullkey; + GtkWidget* w; + + fullkey = mate_panel_applet_mateconf_get_full_key(applet, key); + + if (mateconf_client_key_is_writable(client, fullkey, NULL)) + { + g_free(fullkey); + return; + } + + g_free(fullkey); + + w = WID(wid1); + g_assert(w != NULL); + gtk_widget_set_sensitive(w, FALSE); + + if (wid2 != NULL) + { + w = WID(wid2); + g_assert(w != NULL); + gtk_widget_set_sensitive(w, FALSE); + } + + if (wid3 != NULL) + { + w = WID(wid3); + g_assert(w != NULL); + gtk_widget_set_sensitive(w, FALSE); + } +} + +static void setup_dialog(GtkBuilder* builder, TasklistData* tasklist) +{ + MateConfClient* client; + GtkWidget* button; + + client = mateconf_client_get_default(); + + tasklist->show_current_radio = WID("show_current_radio"); + tasklist->show_all_radio = WID("show_all_radio"); + + setup_sensitivity(tasklist, client, builder, "show_current_radio", "show_all_radio", NULL, "display_all_workspaces" /* key */); + + tasklist->never_group_radio = WID("never_group_radio"); + tasklist->auto_group_radio = WID("auto_group_radio"); + tasklist->always_group_radio = WID("always_group_radio"); + + setup_sensitivity(tasklist, client, builder, "never_group_radio", "auto_group_radio", "always_group_radio", "group_windows" /* key */); + + tasklist->minimized_windows_label = WID("minimized_windows_label"); + tasklist->move_minimized_radio = WID("move_minimized_radio"); + tasklist->change_workspace_radio = WID("change_workspace_radio"); + + + /*tasklist->style_group_radio = WID("style_button_radio"); + tasklist->icon_group_radio = WID("icon_only_radio"); + tasklist->text_group_radio = WID("text_only_radio");*/ + + setup_sensitivity(tasklist, client, builder, "move_minimized_radio", "change_workspace_radio", NULL, "move_unminimized_windows" /* key */); + + /* Window grouping: */ + button = get_grouping_button(tasklist, tasklist->grouping); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); + g_object_set_data(G_OBJECT(tasklist->never_group_radio), "group_value", "never"); + g_object_set_data(G_OBJECT(tasklist->auto_group_radio), "group_value", "auto"); + g_object_set_data(G_OBJECT(tasklist->always_group_radio), "group_value", "always"); + + g_signal_connect(G_OBJECT(tasklist->never_group_radio), "toggled", (GCallback) group_windows_toggled, tasklist); + g_signal_connect(G_OBJECT(tasklist->auto_group_radio), "toggled", (GCallback) group_windows_toggled, tasklist); + g_signal_connect(G_OBJECT(tasklist->always_group_radio), "toggled", (GCallback) group_windows_toggled, tasklist); + + /* Button list */ + //button = get_grouping_button(tasklist, tasklist->grouping); + //gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); + /*g_object_set_data(G_OBJECT(tasklist->style_group_radio), "group_value", "style"); + g_object_set_data(G_OBJECT(tasklist->icon_group_radio), "group_value", "icon"); + g_object_set_data(G_OBJECT(tasklist->text_group_radio), "group_value", "text"); + + g_signal_connect(G_OBJECT(tasklist->style_group_radio), "toggled", (GCallback) group_button_toggled, tasklist); + g_signal_connect(G_OBJECT(tasklist->icon_group_radio), "toggled", (GCallback) group_button_toggled, tasklist); + g_signal_connect(G_OBJECT(tasklist->text_group_radio), "toggled", (GCallback) group_button_toggled, tasklist);*/ + + /* move window when unminimizing: */ + tasklist_update_unminimization_radio(tasklist); + g_signal_connect(G_OBJECT(tasklist->move_minimized_radio), "toggled", (GCallback) move_minimized_toggled, tasklist); + + /* Tasklist content: */ + tasklist_properties_update_content_radio (tasklist); + g_signal_connect(G_OBJECT(tasklist->show_all_radio), "toggled", (GCallback) display_all_workspaces_toggled, tasklist); + + g_signal_connect_swapped(WID("done_button"), "clicked", (GCallback) gtk_widget_hide, tasklist->properties_dialog); + g_signal_connect(tasklist->properties_dialog, "response", G_CALLBACK(response_cb), tasklist); + + g_object_unref(G_OBJECT(client)); +} + +static void display_properties_dialog(GtkAction* action, TasklistData* tasklist) +{ + if (tasklist->properties_dialog == NULL) + { + GtkBuilder* builder; + GError* error; + + builder = gtk_builder_new(); + gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); + + error = NULL; + gtk_builder_add_from_file(builder, TASKLIST_BUILDERDIR "/window-list.ui", &error); + + if (error) + { + g_warning("Error loading preferences: %s", error->message); + g_error_free(error); + return; + } + + tasklist->properties_dialog = WID("tasklist_properties_dialog"); + + g_object_add_weak_pointer(G_OBJECT(tasklist->properties_dialog), (void**) &tasklist->properties_dialog); + + setup_dialog(builder, tasklist); + + g_object_unref(builder); + } + + gtk_window_set_icon_name(GTK_WINDOW(tasklist->properties_dialog), WINDOW_LIST_ICON); + + gtk_window_set_resizable(GTK_WINDOW(tasklist->properties_dialog), FALSE); + gtk_window_set_screen(GTK_WINDOW(tasklist->properties_dialog), gtk_widget_get_screen(tasklist->applet)); + gtk_window_present(GTK_WINDOW(tasklist->properties_dialog)); +} |