void init_wnck (WckUtils *win, gboolean only_maximized, gpointer data)
{
/* save data */
win->data = data;
/* get window proprieties */
win->activescreen = wnck_screen_get_default();
win->activeworkspace = wnck_screen_get_active_workspace(win->activescreen);
if (!win->activeworkspace)
win->activeworkspace = wnck_screen_get_workspace(win->activescreen, 0);
win->activewindow = wnck_screen_get_active_window(win->activescreen);
win->umaxwindow = NULL;
win->controlwindow = NULL;
win->only_maximized = only_maximized;
/* Global window tracking */
g_signal_connect(win->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), win);
if (win->only_maximized)
{
win->sch = g_signal_connect(win->activescreen, "window-closed", G_CALLBACK (on_window_closed), win);
win->soh = g_signal_connect(win->activescreen, "window-opened", G_CALLBACK (on_window_opened), win);
}
win->svh = g_signal_connect(win->activescreen, "viewports-changed", G_CALLBACK (on_viewports_changed), win);
win->swh = g_signal_connect(win->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), win);
/* Get controled window */
track_controled_window (win);
if (!win->controlwindow)
on_control_window_changed (NULL, NULL, win->data);
}
static void
workspace_name_edited (GtkCellRendererText *cell_renderer_text,
const gchar *path,
const gchar *new_text,
PagerData *pager)
{
const gint *indices;
WnckWorkspace *workspace;
GtkTreePath *p;
p = gtk_tree_path_new_from_string (path);
indices = gtk_tree_path_get_indices (p);
workspace = wnck_screen_get_workspace (pager->screen,
indices[0]);
if (workspace != NULL) {
gchar* temp_name = g_strdup(new_text);
wnck_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
wnck_selector_add_workspace (WnckSelector *selector,
WnckScreen *screen,
int workspace_n)
{
WnckWorkspace *workspace;
GtkWidget *item;
GtkWidget *label;
workspace = wnck_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-updated",
G_CALLBACK (wnck_selector_workspace_label_style_updated),
workspace);
wncklet_connect_while_alive (workspace, "name_changed",
G_CALLBACK (wnck_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), "wnck-selector-workspace-n",
GINT_TO_POINTER (workspace_n + 1));
}
int c_center(lua_State *lua)
{
int top = lua_gettop(lua);
int workspace_width, workspace_height, window_width, window_height;
int xoffset, yoffset;
WnckScreen *screen;
WnckWorkspace *workspace;
if (top != 0) {
luaL_error(lua, "center: %s", no_indata_expected_error);
return 0;
}
WnckWindow *window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
wnck_window_get_geometry(window, NULL, NULL, &window_width, &window_height);
screen = wnck_window_get_screen(window);
workspace = wnck_screen_get_active_workspace(screen);
if (workspace == NULL) {
workspace = wnck_screen_get_workspace(screen,0);
}
if (workspace == NULL) {
g_printerr(_("Could not get workspace"));
lua_pushboolean(lua, FALSE);
return 1;
}
workspace_width = wnck_workspace_get_width(workspace);
workspace_height = wnck_workspace_get_height(workspace);
xoffset = (workspace_width - window_width) / 2;
yoffset = (workspace_height - window_height) / 2;
devilspie2_error_trap_push();
XMoveWindow (gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
xoffset, yoffset);
if (devilspie2_error_trap_pop()) {
g_printerr("center: %s", failed_string);
lua_pushboolean(lua, FALSE);
return 1;
}
lua_pushboolean(lua, TRUE);
return 1;
}
// -----------------------------------------------------------------------------
void g_window_workspace(GtkWidget* pWidget, int space)
{
DEBUGLOGB;
#if !_USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(pWidget));
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
Window xwindow = GDK_WINDOW_XWINDOW(gtk_widget_get_window(pWidget));
#endif
_wncki_change_workspace(xscreen, xwindow, space);
#else // !_USEWKSPACE
WnckScreen* screen = wnck_screen_get_default();
if( screen )
{
DEBUGLOGS("got default screen");
wnck_screen_force_update(screen);
DEBUGLOGP("sticky is off and workspace is %d\n", space);
WnckWindow* window = wnck_window_get(gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget)));
if( window && !wnck_window_is_pinned(window) )
{
DEBUGLOGS("got non-pinned window");
WnckWorkspace* trgtWrk = wnck_screen_get_workspace (screen, space);
WnckWorkspace* actvWrk = wnck_screen_get_active_workspace(screen);
if( trgtWrk && actvWrk && trgtWrk != actvWrk )
{
DEBUGLOGS("got target workspace is diff from current so moving window to target");
wnck_window_move_to_workspace(window, trgtWrk);
}
}
#ifdef _DEBUGLOG
else
{
DEBUGLOGP("WnckWindow for clock window is%svalid\n", window ? " " : " NOT ");
guint xw1 = GDK_WINDOW_XWINDOW (gtk_widget_get_window(pWidget));
guint xw2 = gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget));
DEBUGLOGP("X11 XID1 for clock window is %d\n", (int)xw1);
DEBUGLOGP("X11 XID2 for clock window is %d\n", (int)xw2);
}
#endif
}
#endif // !_USEWKSPACE
DEBUGLOGE;
}
/* FIXME: this will not work with wm using large desktops and viewports
to implement their workspaces.*/
bool WorkspacesInfo::changeCurrent(int newWorkspace)
{
WnckScreen *screen = wnck_screen_get_default();
WnckWorkspace *workspace = wnck_screen_get_workspace(screen, newWorkspace);
if (workspace == NULL) {
UQ_WARNING << "Requested activation workspace" << newWorkspace << " but it does not exist.";
return false;
}
if (newWorkspace == current()) {
return true;
}
/* This function will ask the WM to change workspace. However we have no way to know
if it succeeds or fails. To know that we can only wait to be notified of the workspace
to actually change, or decide we waited too much and proceed anyway */
wnck_workspace_activate(workspace, CurrentTime);
return SignalWaiter().waitForSignal(this, SIGNAL(currentChanged(int)), 50);
}
/**
* Makes a workspace the active one
*/
int c_change_workspace(lua_State *lua)
{
int top = lua_gettop(lua);
GTimeVal timestamp;
if (top != 1) {
luaL_error(lua,"change_workspace: %s", one_indata_expected_error);
return 0;
}
int type = lua_type(lua, 1);
if (type!=LUA_TNUMBER) {
luaL_error(lua,"change_workspace: %s", number_expected_as_indata_error);
return 0;
}
int number = lua_tonumber(lua, 1);
WnckWindow *window = get_current_window();
if (window) {
WnckScreen *screen;
WnckWorkspace *workspace;
screen = wnck_window_get_screen(window);
workspace = wnck_screen_get_workspace(screen, number-1);
if (!workspace) {
g_warning(_("Workspace number %d does not exist!"), number);
}
g_get_current_time(×tamp);
if (!devilspie2_emulate) {
wnck_workspace_activate(workspace, timestamp.tv_sec);
}
}
lua_pushboolean(lua, TRUE);
return 1;
}
static void
update_workspaces_model (PagerData *pager)
{
int nr_ws, i;
WnckWorkspace *workspace;
GtkTreeIter iter;
nr_ws = wnck_screen_get_workspace_count (pager->screen);
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 = wnck_screen_get_workspace (pager->screen, i);
gtk_list_store_append (pager->workspaces_store, &iter);
gtk_list_store_set (pager->workspaces_store,
&iter,
0, wnck_workspace_get_name (workspace),
-1);
}
}
static void
refill_submenu_viewport (WnckActionMenu *menu)
{
GtkWidget *submenu;
GList *children;
GList *l;
WnckScreen *screen;
WnckWorkspace *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 = wnck_window_get_screen (menu->priv->window);
workspace = wnck_screen_get_workspace (screen, 0);
wnck_window_get_geometry (menu->priv->window,
&window_x, &window_y, NULL, NULL);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
window_x += viewport_x;
window_y += viewport_y;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_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 (WnckWindow *window,
int index)
{
const char *name;
int number;
name = wnck_workspace_get_name (wnck_screen_get_workspace (wnck_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 (WnckActionMenu *menu)
{
WnckActionMenuPrivate *priv;
WnckWindowActions actions;
WnckScreen *screen;
WnckWorkspace *workspace;
gboolean viewport_mode;
gboolean move_workspace_sensitive;
priv = menu->priv;
priv->idle_handler = 0;
actions = wnck_window_get_actions (priv->window);
screen = wnck_window_get_screen (priv->window);
viewport_mode = wnck_screen_get_workspace_count (screen) == 1 &&
wnck_workspace_is_virtual (wnck_screen_get_workspace (screen,
0));
move_workspace_sensitive = viewport_mode ||
(actions & WNCK_WINDOW_ACTION_CHANGE_WORKSPACE) != 0;
if (wnck_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 & WNCK_WINDOW_ACTION_UNMINIMIZE) != 0);
}
else
{
set_item_text (priv->minimize_item, _("Mi_nimize"));
set_item_stock (priv->minimize_item, WNCK_STOCK_MINIMIZE);
gtk_widget_set_sensitive (priv->minimize_item,
(actions & WNCK_WINDOW_ACTION_MINIMIZE) != 0);
}
if (wnck_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 & WNCK_WINDOW_ACTION_UNMAXIMIZE) != 0);
}
else
{
set_item_text (priv->maximize_item, _("Ma_ximize"));
set_item_stock (priv->maximize_item, WNCK_STOCK_MAXIMIZE);
gtk_widget_set_sensitive (priv->maximize_item,
(actions & WNCK_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),
wnck_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 & WNCK_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 && wnck_window_is_sticky (priv->window)) ||
(!viewport_mode && wnck_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 & WNCK_WINDOW_ACTION_CLOSE) != 0);
gtk_widget_set_sensitive (priv->move_item,
(actions & WNCK_WINDOW_ACTION_MOVE) != 0);
gtk_widget_set_sensitive (priv->resize_item,
(actions & WNCK_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 = wnck_window_get_workspace (priv->window);
if (viewport_mode && !wnck_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 = wnck_screen_get_workspace (screen, 0);
wnck_window_get_geometry (priv->window, &window_x, &window_y, NULL, NULL);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
window_x += viewport_x;
window_y += viewport_y;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_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 && !wnck_window_is_pinned (priv->window))
{
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_LEFT))
gtk_widget_show (priv->left_item);
else
gtk_widget_hide (priv->left_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_RIGHT))
gtk_widget_show (priv->right_item);
else
gtk_widget_hide (priv->right_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_UP))
gtk_widget_show (priv->up_item);
else
gtk_widget_hide (priv->up_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_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 = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_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 (wnck_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)
{
WnckActionMenu *menu;
WnckWindow *window;
WindowAction action = GPOINTER_TO_INT (data);
WnckScreen *screen;
gboolean viewport_mode;
menu = get_action_menu (menu_item);
if (menu == NULL)
return;
window = menu->priv->window;
screen = wnck_window_get_screen (window);
viewport_mode = wnck_screen_get_workspace_count (screen) == 1 &&
wnck_workspace_is_virtual (wnck_screen_get_workspace (screen,
0));
switch (action)
{
case CLOSE:
/* In an activate callback, so gtk_get_current_event_time() suffices */
wnck_window_close (window,
gtk_get_current_event_time ());
break;
case MINIMIZE:
if (wnck_window_is_minimized (window))
wnck_window_unminimize (window,
gtk_get_current_event_time ());
else
wnck_window_minimize (window);
break;
case MAXIMIZE:
if (wnck_window_is_maximized (window))
wnck_window_unmaximize (window);
else
wnck_window_maximize (window);
break;
case ABOVE:
if (wnck_window_is_above (window))
wnck_window_unmake_above (window);
else
wnck_window_make_above (window);
break;
case MOVE:
wnck_window_keyboard_move (window);
break;
case RESIZE:
wnck_window_keyboard_size (window);
break;
case PIN:
if (!viewport_mode)
wnck_window_pin (window);
else
wnck_window_stick (window);
break;
case UNPIN:
if (!viewport_mode)
wnck_window_unpin (window);
else
wnck_window_unstick (window);
break;
case LEFT:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_LEFT);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int width, xw, yw, ww, hw;
width = wnck_screen_get_width (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw - width, yw,
ww, hw);
}
break;
case RIGHT:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_RIGHT);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int width, xw, yw, ww, hw;
width = wnck_screen_get_width (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw + width, yw,
ww, hw);
}
break;
case UP:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_UP);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int height, xw, yw, ww, hw;
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw, yw - height,
ww, hw);
}
break;
case DOWN:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_DOWN);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int height, xw, yw, ww, hw;
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw, yw + height,
ww, hw);
}
break;
case MOVE_TO_WORKSPACE:
if (!viewport_mode)
{
int workspace_index;
WnckWorkspace *workspace;
workspace_index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item),
"workspace"));
workspace = wnck_screen_get_workspace (screen, workspace_index);
wnck_window_move_to_workspace (window, workspace);
}
else
{
WnckWorkspace *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 = wnck_screen_get_workspace (screen, 0);
width = wnck_screen_get_width (screen);
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_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");
pager->workspaces_tree = WID ("workspaces_tree_view");
/* Display workspace names: */
g_signal_connect (G_OBJECT (pager->display_workspaces_toggle), "toggled",
(GCallback) display_workspace_names_toggled, pager);
if (pager->display_mode == WNCK_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),
wnck_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 = wnck_screen_get_workspace_count (pager->screen);
for (i = 0; i < nr_ws; i++) {
wncklet_connect_while_alive (
G_OBJECT (wnck_screen_get_workspace (pager->screen, i)),
"name_changed",
G_CALLBACK(workspace_renamed),
pager,
pager->properties_dialog);
}
update_properties_for_wm (pager);
}
/**
* wnck_workspace_get_neighbor:
* @space: a #WnckWorkspace.
* @direction: direction in which to search the neighbor.
*
* Gets the neighbor #WnckWorkspace of @space in the @direction direction.
*
* Return value: (transfer none): the neighbor #WnckWorkspace of @space in the
* @direction direction, or %NULL if no such neighbor #WnckWorkspace exists.
* The returned #WnckWorkspace is owned by libwnck and must not be referenced
* or unreferenced.
*
* Since: 2.20
**/
WnckWorkspace*
wnck_workspace_get_neighbor (WnckWorkspace *space,
WnckMotionDirection direction)
{
_WnckLayoutOrientation orientation;
_WnckLayoutCorner corner;
int n_rows;
int n_cols;
int row;
int col;
int add;
int index;
g_return_val_if_fail (WNCK_IS_WORKSPACE (space), NULL);
_wnck_screen_get_workspace_layout (space->priv->screen,
&orientation, &n_rows, &n_cols, &corner);
row = wnck_workspace_get_layout_row (space);
col = wnck_workspace_get_layout_column (space);
index = space->priv->number;
switch (direction)
{
case WNCK_MOTION_LEFT:
if (col == 0)
return NULL;
if (orientation == WNCK_LAYOUT_ORIENTATION_HORIZONTAL)
add = 1;
else
add = n_rows;
if (corner == WNCK_LAYOUT_CORNER_TOPRIGHT ||
corner == WNCK_LAYOUT_CORNER_BOTTOMRIGHT)
index += add;
else
index -= add;
break;
case WNCK_MOTION_RIGHT:
if (col == n_cols - 1)
return NULL;
if (orientation == WNCK_LAYOUT_ORIENTATION_HORIZONTAL)
add = 1;
else
add = n_rows;
if (corner == WNCK_LAYOUT_CORNER_TOPRIGHT ||
corner == WNCK_LAYOUT_CORNER_BOTTOMRIGHT)
index -= add;
else
index += add;
break;
case WNCK_MOTION_UP:
if (row == 0)
return NULL;
if (orientation == WNCK_LAYOUT_ORIENTATION_HORIZONTAL)
add = n_cols;
else
add = 1;
if (corner == WNCK_LAYOUT_CORNER_BOTTOMLEFT ||
corner == WNCK_LAYOUT_CORNER_BOTTOMRIGHT)
index += add;
else
index -= add;
break;
case WNCK_MOTION_DOWN:
if (row == n_rows - 1)
return NULL;
if (orientation == WNCK_LAYOUT_ORIENTATION_HORIZONTAL)
add = n_cols;
else
add = 1;
if (corner == WNCK_LAYOUT_CORNER_BOTTOMLEFT ||
corner == WNCK_LAYOUT_CORNER_BOTTOMRIGHT)
index -= add;
else
index += add;
break;
}
if (index == space->priv->number)
return NULL;
return wnck_screen_get_workspace (space->priv->screen, index);
}
static gboolean
applet_scroll (PanelApplet *applet,
GdkEventScroll *event,
PagerData *pager)
{
WnckScreen *screen;
int index;
int n_workspaces;
int n_columns;
int in_last_row;
if (event->type != GDK_SCROLL)
return FALSE;
screen = wncklet_get_screen (GTK_WIDGET (applet));
index = wnck_workspace_get_number (wnck_screen_get_active_workspace (screen));
n_workspaces = wnck_screen_get_workspace_count (screen);
n_columns = n_workspaces / pager->n_rows;
if (n_workspaces % pager->n_rows != 0)
n_columns++;
in_last_row = n_workspaces % n_columns;
switch (event->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;
}
wnck_workspace_activate (wnck_screen_get_workspace (screen, index),
event->time);
return TRUE;
}
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 = wnck_workspace_get_number(wnck_screen_get_active_workspace(pager->screen));
n_workspaces = wnck_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 (pager->wrap_workspaces && index == n_workspaces - 1)
{
index = 0;
}
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++;
}
else if (pager->wrap_workspaces)
{
index = 0;
}
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;
}
else if (pager->wrap_workspaces)
{
index = n_workspaces - 1;
}
if (index >= n_workspaces)
index -= n_columns;
break;
case GDK_SCROLL_LEFT:
if (index > 0)
{
index--;
}
else if (pager->wrap_workspaces)
{
index = n_workspaces - 1;
}
break;
default:
g_assert_not_reached();
break;
}
wnck_workspace_activate(wnck_screen_get_workspace(pager->screen, index), event->time);
return TRUE;
}
