summaryrefslogtreecommitdiff
path: root/applets/wncklet/window-list.c
diff options
context:
space:
mode:
Diffstat (limited to 'applets/wncklet/window-list.c')
-rw-r--r--applets/wncklet/window-list.c749
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));
+}