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;
}
