static void workspace_name_edited(GtkCellRendererText* cell_renderer_text, const gchar* path, const gchar* new_text, PagerData* pager) { const gint* indices; MatewnckWorkspace* workspace; GtkTreePath* p; p = gtk_tree_path_new_from_string(path); indices = gtk_tree_path_get_indices(p); workspace = matewnck_screen_get_workspace(pager->screen, indices[0]); if (workspace != NULL) { gchar* temp_name = g_strdup(new_text); matewnck_workspace_change_name(workspace, g_strstrip(temp_name)); g_free(temp_name); } else { g_warning("Edited name of workspace %d which no longer exists", indices[0]); } gtk_tree_path_free(p); }
static void matewnck_selector_add_workspace (MatewnckSelector *selector, MatewnckScreen *screen, int workspace_n) { MatewnckWorkspace *workspace; GtkWidget *item; GtkWidget *label; workspace = matewnck_screen_get_workspace (screen, workspace_n); /* We use a separator in which we add a label. This makes the menu item not * selectable without any hack. */ item = gtk_separator_menu_item_new (); label = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_widget_show (label); /* the handler will also take care of setting the name for the first time, * and we'll be able to adapt to theme changes */ g_signal_connect (G_OBJECT (label), "style-set", G_CALLBACK (matewnck_selector_workspace_label_style_set), workspace); matewncklet_connect_while_alive (workspace, "name_changed", G_CALLBACK (matewnck_selector_workspace_name_changed), label, label); gtk_container_add (GTK_CONTAINER (item), label); gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item); g_object_set_data (G_OBJECT (item), "matewnck-selector-workspace-n", GINT_TO_POINTER (workspace_n + 1)); }
static void update_workspaces_model(PagerData* pager) { int nr_ws, i; MatewnckWorkspace* workspace; GtkTreeIter iter; nr_ws = matewnck_screen_get_workspace_count(pager->screen); if (pager->properties_dialog) { if (nr_ws != gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pager->num_workspaces_spin))) gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_workspaces_spin), nr_ws); gtk_list_store_clear(pager->workspaces_store); for (i = 0; i < nr_ws; i++) { workspace = matewnck_screen_get_workspace(pager->screen, i); gtk_list_store_append(pager->workspaces_store, &iter); gtk_list_store_set(pager->workspaces_store, &iter, 0, matewnck_workspace_get_name(workspace), -1); } } }
static void refill_submenu_viewport (MatewnckActionMenu *menu) { GtkWidget *submenu; GList *children; GList *l; MatewnckScreen *screen; MatewnckWorkspace *workspace; int window_x, window_y; int viewport_x, viewport_y; int viewport_width, viewport_height; int screen_width, screen_height; int x, y; int number; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item)); /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (submenu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (submenu), l->data); g_list_free (children); screen = matewnck_window_get_screen (menu->priv->window); workspace = matewnck_screen_get_workspace (screen, 0); matewnck_window_get_geometry (menu->priv->window, &window_x, &window_y, NULL, NULL); viewport_x = matewnck_workspace_get_viewport_x (workspace); viewport_y = matewnck_workspace_get_viewport_y (workspace); window_x += viewport_x; window_y += viewport_y; viewport_width = matewnck_workspace_get_width (workspace); viewport_height = matewnck_workspace_get_height (workspace); screen_width = matewnck_screen_get_width (screen); screen_height = matewnck_screen_get_height (screen); number = 1; for (y = 0; y < viewport_height; y += screen_height) { char *label; GtkWidget *item; for (x = 0; x < viewport_width; x += screen_width) { /* Keep this in sync with what is in get_workspace_name_with_accel() */ if (number == 10) label = g_strdup_printf (_("Workspace 1_0")); else label = g_strdup_printf (_("Workspace %s%d"), number < 10 ? "_" : "", number); number++; item = make_menu_item (MOVE_TO_WORKSPACE); g_object_set_data (G_OBJECT (item), "viewport_x", GINT_TO_POINTER (x)); g_object_set_data (G_OBJECT (item), "viewport_y", GINT_TO_POINTER (y)); if (window_x >= x && window_x < x + screen_width && window_y >= y && window_y < y + screen_height) gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); set_item_text (item, label); set_item_stock (item, NULL); g_free (label); } } gtk_menu_reposition (GTK_MENU (submenu)); }
static char * get_workspace_name_with_accel (MatewnckWindow *window, int index) { const char *name; int number; name = matewnck_workspace_get_name (matewnck_screen_get_workspace (matewnck_window_get_screen (window), index)); g_assert (name != NULL); /* * If the name is of the form "Workspace x" where x is an unsigned * integer, insert a '_' before the number if it is less than 10 and * return it */ number = 0; if (sscanf (name, _("Workspace %d"), &number) == 1) { /* Keep this in sync with what is in refill_submenu_viewport() */ char *new_name; /* * Above name is a pointer into the Workspace struct. Here we make * a copy copy so we can have our wicked way with it. */ if (number == 10) new_name = g_strdup_printf (_("Workspace 1_0")); else new_name = g_strdup_printf (_("Workspace %s%d"), number < 10 ? "_" : "", number); return new_name; } else { /* * Otherwise this is just a normal name. Escape any _ characters so that * the user's workspace names do not get mangled. If the number is less * than 10 we provide an accelerator. */ char *new_name; const char *source; char *dest; /* * Assume the worst case, that every character is a _. We also * provide memory for " (_#)" */ new_name = g_malloc0 (strlen (name) * 2 + 6 + 1); /* * Now iterate down the strings, adding '_' to escape as we go */ dest = new_name; source = name; while (*source != '\0') { if (*source == '_') *dest++ = '_'; *dest++ = *source++; } /* People don't start at workstation 0, but workstation 1 */ if (index < 9) { g_snprintf (dest, 6, " (_%d)", index + 1); } else if (index == 9) { g_snprintf (dest, 6, " (_0)"); } return new_name; } }
static gboolean update_menu_state (MatewnckActionMenu *menu) { MatewnckActionMenuPrivate *priv; MatewnckWindowActions actions; MatewnckScreen *screen; MatewnckWorkspace *workspace; gboolean viewport_mode; gboolean move_workspace_sensitive; priv = menu->priv; priv->idle_handler = 0; actions = matewnck_window_get_actions (priv->window); screen = matewnck_window_get_screen (priv->window); viewport_mode = matewnck_screen_get_workspace_count (screen) == 1 && matewnck_workspace_is_virtual (matewnck_screen_get_workspace (screen, 0)); move_workspace_sensitive = viewport_mode || (actions & MATEWNCK_WINDOW_ACTION_CHANGE_WORKSPACE) != 0; if (matewnck_window_is_minimized (priv->window)) { set_item_text (priv->minimize_item, _("Unmi_nimize")); set_item_stock (priv->minimize_item, NULL); gtk_widget_set_sensitive (priv->minimize_item, (actions & MATEWNCK_WINDOW_ACTION_UNMINIMIZE) != 0); } else { set_item_text (priv->minimize_item, _("Mi_nimize")); set_item_stock (priv->minimize_item, MATEWNCK_STOCK_MINIMIZE); gtk_widget_set_sensitive (priv->minimize_item, (actions & MATEWNCK_WINDOW_ACTION_MINIMIZE) != 0); } if (matewnck_window_is_maximized (priv->window)) { set_item_text (priv->maximize_item, _("Unma_ximize")); set_item_stock (priv->maximize_item, NULL); gtk_widget_set_sensitive (priv->maximize_item, (actions & MATEWNCK_WINDOW_ACTION_UNMAXIMIZE) != 0); } else { set_item_text (priv->maximize_item, _("Ma_ximize")); set_item_stock (priv->maximize_item, MATEWNCK_STOCK_MAXIMIZE); gtk_widget_set_sensitive (priv->maximize_item, (actions & MATEWNCK_WINDOW_ACTION_MAXIMIZE) != 0); } g_signal_handlers_block_by_func (G_OBJECT (priv->above_item), item_activated_callback, GINT_TO_POINTER (ABOVE)); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->above_item), matewnck_window_is_above (priv->window)); g_signal_handlers_unblock_by_func (G_OBJECT (priv->above_item), item_activated_callback, GINT_TO_POINTER (ABOVE)); gtk_widget_set_sensitive (priv->above_item, (actions & MATEWNCK_WINDOW_ACTION_ABOVE) != 0); g_signal_handlers_block_by_func (G_OBJECT (priv->pin_item), item_activated_callback, GINT_TO_POINTER (PIN)); g_signal_handlers_block_by_func (G_OBJECT (priv->unpin_item), item_activated_callback, GINT_TO_POINTER (UNPIN)); if ((viewport_mode && matewnck_window_is_sticky (priv->window)) || (!viewport_mode && matewnck_window_is_pinned (priv->window))) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->pin_item), TRUE); else gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->unpin_item), TRUE); g_signal_handlers_unblock_by_func (G_OBJECT (priv->pin_item), item_activated_callback, GINT_TO_POINTER (PIN)); g_signal_handlers_unblock_by_func (G_OBJECT (priv->unpin_item), item_activated_callback, GINT_TO_POINTER (UNPIN)); gtk_widget_set_sensitive (priv->pin_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->unpin_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->close_item, (actions & MATEWNCK_WINDOW_ACTION_CLOSE) != 0); gtk_widget_set_sensitive (priv->move_item, (actions & MATEWNCK_WINDOW_ACTION_MOVE) != 0); gtk_widget_set_sensitive (priv->resize_item, (actions & MATEWNCK_WINDOW_ACTION_RESIZE) != 0); gtk_widget_set_sensitive (priv->workspace_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->left_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->right_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->up_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->down_item, move_workspace_sensitive); workspace = matewnck_window_get_workspace (priv->window); if (viewport_mode && !matewnck_window_is_sticky (priv->window)) { int window_x, window_y; int viewport_x, viewport_y; int viewport_width, viewport_height; int screen_width, screen_height; if (!workspace) workspace = matewnck_screen_get_workspace (screen, 0); matewnck_window_get_geometry (priv->window, &window_x, &window_y, NULL, NULL); viewport_x = matewnck_workspace_get_viewport_x (workspace); viewport_y = matewnck_workspace_get_viewport_y (workspace); window_x += viewport_x; window_y += viewport_y; viewport_width = matewnck_workspace_get_width (workspace); viewport_height = matewnck_workspace_get_height (workspace); screen_width = matewnck_screen_get_width (screen); screen_height = matewnck_screen_get_height (screen); if (window_x >= screen_width) gtk_widget_show (priv->left_item); else gtk_widget_hide (priv->left_item); if (window_x < viewport_width - screen_width) gtk_widget_show (priv->right_item); else gtk_widget_hide (priv->right_item); if (window_y >= screen_height) gtk_widget_show (priv->up_item); else gtk_widget_hide (priv->up_item); if (window_y < viewport_height - screen_height) gtk_widget_show (priv->down_item); else gtk_widget_hide (priv->down_item); } else if (!viewport_mode && workspace && !matewnck_window_is_pinned (priv->window)) { if (matewnck_workspace_get_neighbor (workspace, MATEWNCK_MOTION_LEFT)) gtk_widget_show (priv->left_item); else gtk_widget_hide (priv->left_item); if (matewnck_workspace_get_neighbor (workspace, MATEWNCK_MOTION_RIGHT)) gtk_widget_show (priv->right_item); else gtk_widget_hide (priv->right_item); if (matewnck_workspace_get_neighbor (workspace, MATEWNCK_MOTION_UP)) gtk_widget_show (priv->up_item); else gtk_widget_hide (priv->up_item); if (matewnck_workspace_get_neighbor (workspace, MATEWNCK_MOTION_DOWN)) gtk_widget_show (priv->down_item); else gtk_widget_hide (priv->down_item); } else { gtk_widget_hide (priv->left_item); gtk_widget_hide (priv->right_item); gtk_widget_hide (priv->up_item); gtk_widget_hide (priv->down_item); } if (viewport_mode) { int viewport_width, viewport_height; int screen_width, screen_height; viewport_width = matewnck_workspace_get_width (workspace); viewport_height = matewnck_workspace_get_height (workspace); screen_width = matewnck_screen_get_width (screen); screen_height = matewnck_screen_get_height (screen); gtk_widget_show (priv->workspace_separator); gtk_widget_show (priv->pin_item); gtk_widget_show (priv->unpin_item); if (viewport_width >= 2 * screen_width || viewport_height >= 2 * screen_height) { gtk_widget_show (priv->workspace_item); refill_submenu_viewport (menu); } else { gtk_widget_hide (priv->workspace_item); gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item)))); } } else if (matewnck_screen_get_workspace_count (screen) > 1) { gtk_widget_show (priv->workspace_separator); gtk_widget_show (priv->pin_item); gtk_widget_show (priv->unpin_item); gtk_widget_show (priv->workspace_item); refill_submenu_workspace (menu); } else { gtk_widget_hide (priv->workspace_separator); gtk_widget_hide (priv->pin_item); gtk_widget_hide (priv->unpin_item); gtk_widget_hide (priv->workspace_item); gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item)))); } gtk_menu_reposition (GTK_MENU (menu)); return FALSE; }
static void item_activated_callback (GtkWidget *menu_item, gpointer data) { MatewnckActionMenu *menu; MatewnckWindow *window; WindowAction action = GPOINTER_TO_INT (data); MatewnckScreen *screen; gboolean viewport_mode; menu = get_action_menu (menu_item); if (menu == NULL) return; window = menu->priv->window; screen = matewnck_window_get_screen (window); viewport_mode = matewnck_screen_get_workspace_count (screen) == 1 && matewnck_workspace_is_virtual (matewnck_screen_get_workspace (screen, 0)); switch (action) { case CLOSE: /* In an activate callback, so gtk_get_current_event_time() suffices */ matewnck_window_close (window, gtk_get_current_event_time ()); break; case MINIMIZE: if (matewnck_window_is_minimized (window)) matewnck_window_unminimize (window, gtk_get_current_event_time ()); else matewnck_window_minimize (window); break; case MAXIMIZE: if (matewnck_window_is_maximized (window)) matewnck_window_unmaximize (window); else matewnck_window_maximize (window); break; case ABOVE: if (matewnck_window_is_above (window)) matewnck_window_unmake_above (window); else matewnck_window_make_above (window); break; case MOVE: matewnck_window_keyboard_move (window); break; case RESIZE: matewnck_window_keyboard_size (window); break; case PIN: if (!viewport_mode) matewnck_window_pin (window); else matewnck_window_stick (window); break; case UNPIN: if (!viewport_mode) matewnck_window_unpin (window); else matewnck_window_unstick (window); break; case LEFT: if (!viewport_mode) { MatewnckWorkspace *workspace; workspace = matewnck_workspace_get_neighbor (matewnck_window_get_workspace (window), MATEWNCK_MOTION_LEFT); matewnck_window_move_to_workspace (window, workspace); } else { int width, xw, yw, ww, hw; width = matewnck_screen_get_width (screen); matewnck_window_get_geometry (window, &xw, &yw, &ww, &hw); matewnck_window_unstick (window); matewnck_window_set_geometry (window, 0, MATEWNCK_WINDOW_CHANGE_X | MATEWNCK_WINDOW_CHANGE_Y, xw - width, yw, ww, hw); } break; case RIGHT: if (!viewport_mode) { MatewnckWorkspace *workspace; workspace = matewnck_workspace_get_neighbor (matewnck_window_get_workspace (window), MATEWNCK_MOTION_RIGHT); matewnck_window_move_to_workspace (window, workspace); } else { int width, xw, yw, ww, hw; width = matewnck_screen_get_width (screen); matewnck_window_get_geometry (window, &xw, &yw, &ww, &hw); matewnck_window_unstick (window); matewnck_window_set_geometry (window, 0, MATEWNCK_WINDOW_CHANGE_X | MATEWNCK_WINDOW_CHANGE_Y, xw + width, yw, ww, hw); } break; case UP: if (!viewport_mode) { MatewnckWorkspace *workspace; workspace = matewnck_workspace_get_neighbor (matewnck_window_get_workspace (window), MATEWNCK_MOTION_UP); matewnck_window_move_to_workspace (window, workspace); } else { int height, xw, yw, ww, hw; height = matewnck_screen_get_height (screen); matewnck_window_get_geometry (window, &xw, &yw, &ww, &hw); matewnck_window_unstick (window); matewnck_window_set_geometry (window, 0, MATEWNCK_WINDOW_CHANGE_X | MATEWNCK_WINDOW_CHANGE_Y, xw, yw - height, ww, hw); } break; case DOWN: if (!viewport_mode) { MatewnckWorkspace *workspace; workspace = matewnck_workspace_get_neighbor (matewnck_window_get_workspace (window), MATEWNCK_MOTION_DOWN); matewnck_window_move_to_workspace (window, workspace); } else { int height, xw, yw, ww, hw; height = matewnck_screen_get_height (screen); matewnck_window_get_geometry (window, &xw, &yw, &ww, &hw); matewnck_window_unstick (window); matewnck_window_set_geometry (window, 0, MATEWNCK_WINDOW_CHANGE_X | MATEWNCK_WINDOW_CHANGE_Y, xw, yw + height, ww, hw); } break; case MOVE_TO_WORKSPACE: if (!viewport_mode) { int workspace_index; MatewnckWorkspace *workspace; workspace_index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "workspace")); workspace = matewnck_screen_get_workspace (screen, workspace_index); matewnck_window_move_to_workspace (window, workspace); } else { MatewnckWorkspace *workspace; int new_viewport_x, new_viewport_y; int width, height; int xw, yw, ww, hw; int viewport_x, viewport_y; new_viewport_x = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (menu_item), "viewport_x")); new_viewport_y = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (menu_item), "viewport_y")); workspace = matewnck_screen_get_workspace (screen, 0); width = matewnck_screen_get_width (screen); height = matewnck_screen_get_height (screen); matewnck_window_get_geometry (window, &xw, &yw, &ww, &hw); viewport_x = matewnck_workspace_get_viewport_x (workspace); viewport_y = matewnck_workspace_get_viewport_y (workspace); matewnck_window_unstick (window); matewnck_window_set_geometry (window, 0, MATEWNCK_WINDOW_CHANGE_X | MATEWNCK_WINDOW_CHANGE_Y, xw + new_viewport_x - viewport_x, yw + new_viewport_y - viewport_y, ww, hw); } break; default: g_assert_not_reached (); } }
static void setup_dialog(GtkBuilder* builder, PagerData* pager) { gboolean value; GtkTreeViewColumn* column; GtkCellRenderer* cell; int nr_ws, i; pager->workspaces_frame = WID("workspaces_frame"); pager->workspace_names_label = WID("workspace_names_label"); pager->workspace_names_scroll = WID("workspace_names_scroll"); pager->display_workspaces_toggle = WID("workspace_name_toggle"); setup_sensitivity(pager, builder, "workspace_name_toggle", NULL, NULL, "display_workspace_names" /* key */); pager->all_workspaces_radio = WID("all_workspaces_radio"); pager->current_only_radio = WID("current_only_radio"); setup_sensitivity(pager, builder, "all_workspaces_radio", "current_only_radio", "label_row_col", "display_all_workspaces" /* key */); pager->num_rows_spin = WID("num_rows_spin"); pager->label_row_col = WID("label_row_col"); setup_sensitivity(pager, builder, "num_rows_spin", NULL, NULL, "num_rows" /* key */); pager->num_workspaces_spin = WID("num_workspaces_spin"); setup_sensitivity(pager, builder, "num_workspaces_spin", NULL, NULL, NUM_WORKSPACES /* key */); pager->workspaces_tree = WID("workspaces_tree_view"); setup_sensitivity(pager, builder, "workspaces_tree_view", NULL, NULL, WORKSPACE_NAME /* key */); /* Display workspace names: */ g_signal_connect(G_OBJECT(pager->display_workspaces_toggle), "toggled", (GCallback) display_workspace_names_toggled, pager); if (pager->display_mode == MATEWNCK_PAGER_DISPLAY_NAME) { value = TRUE; } else { value = FALSE; } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->display_workspaces_toggle), value); /* Display all workspaces: */ g_signal_connect(G_OBJECT(pager->all_workspaces_radio), "toggled", (GCallback) all_workspaces_toggled, pager); if (pager->display_all) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->all_workspaces_radio), TRUE); if (!g_object_get_data(G_OBJECT(pager->num_rows_spin), NEVER_SENSITIVE)) { gtk_widget_set_sensitive(pager->num_rows_spin, TRUE); } } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->current_only_radio), TRUE); gtk_widget_set_sensitive(pager->num_rows_spin, FALSE); } /* Num rows: */ g_signal_connect(G_OBJECT(pager->num_rows_spin), "value_changed", (GCallback) num_rows_value_changed, pager); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_rows_spin), pager->n_rows); gtk_label_set_text(GTK_LABEL(pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns")); g_signal_connect(pager->properties_dialog, "destroy", G_CALLBACK(properties_dialog_destroyed), pager); g_signal_connect(pager->properties_dialog, "delete_event", G_CALLBACK(delete_event), pager); g_signal_connect(pager->properties_dialog, "response", G_CALLBACK(response_cb), pager); g_signal_connect(WID("done_button"), "clicked", (GCallback) close_dialog, pager); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_workspaces_spin), matewnck_screen_get_workspace_count(pager->screen)); g_signal_connect(G_OBJECT(pager->num_workspaces_spin), "value_changed", (GCallback) num_workspaces_value_changed, pager); wncklet_connect_while_alive(pager->screen, "workspace_created", G_CALLBACK(workspace_created), pager, pager->properties_dialog); wncklet_connect_while_alive(pager->screen, "workspace_destroyed", G_CALLBACK(workspace_destroyed), pager, pager->properties_dialog); g_signal_connect(G_OBJECT(pager->workspaces_tree), "focus_out_event", (GCallback) workspaces_tree_focused_out, pager); pager->workspaces_store = gtk_list_store_new(1, G_TYPE_STRING, NULL); update_workspaces_model(pager); gtk_tree_view_set_model(GTK_TREE_VIEW(pager->workspaces_tree), GTK_TREE_MODEL(pager->workspaces_store)); g_object_unref(pager->workspaces_store); cell = g_object_new(GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes("workspace", cell, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(pager->workspaces_tree), column); g_signal_connect(cell, "edited", (GCallback) workspace_name_edited, pager); nr_ws = matewnck_screen_get_workspace_count(pager->screen); for (i = 0; i < nr_ws; i++) { wncklet_connect_while_alive(G_OBJECT(matewnck_screen_get_workspace(pager->screen, i)), "name_changed", G_CALLBACK(workspace_renamed), pager, pager->properties_dialog); } update_properties_for_wm(pager); }
static gboolean applet_scroll(MatePanelApplet* applet, GdkEventScroll* event, PagerData* pager) { GdkScrollDirection absolute_direction; int index; int n_workspaces; int n_columns; int in_last_row; if (event->type != GDK_SCROLL) return FALSE; index = matewnck_workspace_get_number(matewnck_screen_get_active_workspace(pager->screen)); n_workspaces = matewnck_screen_get_workspace_count(pager->screen); n_columns = n_workspaces / pager->n_rows; if (n_workspaces % pager->n_rows != 0) n_columns++; in_last_row = n_workspaces % n_columns; absolute_direction = event->direction; if (gtk_widget_get_direction(GTK_WIDGET(applet)) == GTK_TEXT_DIR_RTL) { switch (event->direction) { case GDK_SCROLL_DOWN: case GDK_SCROLL_UP: break; case GDK_SCROLL_RIGHT: absolute_direction = GDK_SCROLL_LEFT; break; case GDK_SCROLL_LEFT: absolute_direction = GDK_SCROLL_RIGHT; break; } } switch (absolute_direction) { case GDK_SCROLL_DOWN: if (index + n_columns < n_workspaces) { index += n_columns; } else if ((index < n_workspaces - 1 && index + in_last_row != n_workspaces - 1) || (index == n_workspaces - 1 && in_last_row != 0)) { index = (index % n_columns) + 1; } break; case GDK_SCROLL_RIGHT: if (index < n_workspaces - 1) index++; break; case GDK_SCROLL_UP: if (index - n_columns >= 0) { index -= n_columns; } else if (index > 0) { index = ((pager->n_rows - 1) * n_columns) + (index % n_columns) - 1; } if (index >= n_workspaces) index -= n_columns; break; case GDK_SCROLL_LEFT: if (index > 0) index--; break; default: g_assert_not_reached(); break; } matewnck_workspace_activate(matewnck_screen_get_workspace(pager->screen, index), event->time); return TRUE; }