void handle_title_button_event (WnckWindow *win, int action, decor_event *gtkwd_event) { switch (action) { case CLICK_ACTION_SHADE: if (wnck_window_is_shaded (win)) wnck_window_unshade (win); else wnck_window_shade (win); break; case CLICK_ACTION_MAXIMIZE: if (wnck_window_is_maximized (win)) wnck_window_unmaximize (win); else wnck_window_maximize (win); break; case CLICK_ACTION_MINIMIZE: if (!wnck_window_is_minimized (win)) wnck_window_minimize (win); break; case CLICK_ACTION_RAISE: restack_window (win, Above); break; case CLICK_ACTION_LOWER: restack_window (win, Below); break; case CLICK_ACTION_MENU: action_menu_map (win, gtkwd_event->button, gtkwd_event->time); break; } }
void window_activate(WnckWindow *window) { XEvent xev; Window xwindow; g_return_if_fail (WNCK_IS_WINDOW (window)); if (wnck_window_is_minimized(window)) { return; } xwindow = wnck_window_get_xid(window); xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = TRUE; xev.xclient.display = main_dpy; xev.xclient.window = xwindow; xev.xclient.message_type = XInternAtom(main_dpy, "_NET_ACTIVE_WINDOW",FALSE); xev.xclient.format = 32; xev.xclient.data.l[0] = 2; /* WNCK_CLIENT_TYPE_PAGER */ xev.xclient.data.l[1] = 0; xev.xclient.data.l[2] = 0; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; XSendEvent (main_dpy, DefaultRootWindow(main_dpy), FALSE, SubstructureRedirectMask | SubstructureNotifyMask, &xev); }
void Application::init() { b2Vec2 gravity(0.0f, 10.0f); mWorld = QSharedPointer<b2World>(new b2World(gravity)); mWorld->SetAllowSleeping(false); // Get windowing system WnckScreen *screen; WnckWindow *active_window; WnckWorkspace *active_workspace; GList *window_l; screen = wnck_screen_get_default (); wnck_screen_force_update (screen); active_window = wnck_screen_get_active_window (screen); active_workspace = wnck_screen_get_active_workspace (screen); for(window_l = wnck_screen_get_windows (screen); window_l != NULL; window_l = window_l->next) { WnckWindow *window = WNCK_WINDOW (window_l->data); if(wnck_window_is_on_workspace(window, active_workspace) && !wnck_window_is_minimized(window) && wnck_window_get_window_type(window) == WNCK_WINDOW_NORMAL) { mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(window, mWorld))); } } mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(100, 100, 100, 100, mWorld))); }
/** * ww_filter_user_windows * @windows: List of %WnckWindow<!-- -->s to filter * @current_workspace: Only use windows on this workspace. %NULL indicates * that all windows should be used * * Extract the user controlled visible windows from a %GList of * %WnckWindows. * * Return value: A newly allocated list containing only windows that are * not minimized, shaded, or wnck_window_skip_task_list() on the current * workspace. */ GList* ww_filter_user_windows (GList * windows, WnckWorkspace *current_workspace) { GList *next; GList *result; WnckWindow *win; WnckWorkspace *win_ws; result = NULL; for (next = windows; next; next = next->next) { win = WNCK_WINDOW(next->data); if (!wnck_window_is_skip_tasklist (win) && !wnck_window_is_minimized (win) && !wnck_window_is_maximized (win) && !wnck_window_is_shaded (win)) { win_ws = wnck_window_get_workspace (win); if (current_workspace == NULL || (win_ws == current_workspace && wnck_window_is_in_viewport(win, current_workspace)) || win_ws == NULL) result = g_list_append (result, win); } } return result; }
static void wnck_selector_set_window_icon (WnckSelector *selector, GtkWidget *image, WnckWindow *window, gboolean use_icon_size) { GdkPixbuf *pixbuf, *freeme, *freeme2; int width, height; int icon_size = -1; pixbuf = NULL; freeme = NULL; freeme2 = NULL; if (window) pixbuf = wnck_window_get_mini_icon (window); if (!pixbuf) pixbuf = wnck_selector_get_default_window_icon (); if (!use_icon_size && selector->priv->size > 1) icon_size = selector->priv->size; if (icon_size == -1) gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, NULL, &icon_size); width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); if (icon_size != -1 && (width > icon_size || height > icon_size)) { double scale; scale = ((double) icon_size) / MAX (width, height); pixbuf = gdk_pixbuf_scale_simple (pixbuf, width * scale, height * scale, GDK_INTERP_BILINEAR); freeme = pixbuf; } if (window && wnck_window_is_minimized (window)) { pixbuf = wnck_selector_dimm_icon (pixbuf); freeme2 = pixbuf; } gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); if (freeme) g_object_unref (freeme); if (freeme2) g_object_unref (freeme2); }
/* Returns the highest maximized window */ static WnckWindow *getUpperMaximized (WTApplet *wtapplet) { if (!wtapplet->prefs->only_maximized) return wtapplet->activewindow; GList *windows = wnck_screen_get_windows_stacked(wtapplet->activescreen); WnckWindow *returnwindow = NULL; while (windows && windows->data) { if (wnck_window_is_maximized(windows->data)) { // if(wnck_window_is_on_workspace(windows->data, wtapplet->activeworkspace)) if (!wnck_window_is_minimized(windows->data)) if (wnck_window_is_in_viewport(windows->data, wtapplet->activeworkspace)) returnwindow = windows->data; } windows = windows->next; } // start tracking the new umaxed window if (wtapplet->umaxedwindow) { if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_state)) g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_state); if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_name)) g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_name); if (g_signal_handler_is_connected(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_icon)) g_signal_handler_disconnect(G_OBJECT(wtapplet->umaxedwindow), wtapplet->umaxed_handler_icon); } if (returnwindow) { // maxed window was found wtapplet->umaxed_handler_state = g_signal_connect(G_OBJECT(returnwindow), "state-changed", G_CALLBACK (umaxed_window_state_changed), wtapplet); wtapplet->umaxed_handler_name = g_signal_connect(G_OBJECT(returnwindow), "name-changed", G_CALLBACK (umaxed_window_nameicon_changed), wtapplet); wtapplet->umaxed_handler_icon = g_signal_connect(G_OBJECT(returnwindow), "icon-changed", G_CALLBACK (umaxed_window_nameicon_changed), wtapplet); //return returnwindow; } else { // maxed window was not found returnwindow = wtapplet->rootwindow; //return wtapplet->rootwindow; } return returnwindow; // WARNING: if this function returns NULL, applet won't detect clicks! }
/* Triggers when umaxedwindow's state changes */ static void on_umaxed_window_state_changed (WnckWindow *window, WnckWindowState changed_mask, WnckWindowState new_state, WckUtils *win) { /* WARNING : only if window is unmaximized to prevent growing loop !!!*/ if (!wnck_window_is_maximized(window) || wnck_window_is_minimized(window) || changed_mask & (WNCK_WINDOW_STATE_ABOVE)) { track_controled_window (win); } else { on_wck_state_changed(win->controlwindow, win->data); } }
/* Trigger when a specific window's state changes */ static void track_changed_max_state (WnckWindow *window, WnckWindowState changed_mask, WnckWindowState new_state, WckUtils *win) { /* track the window max state only if it isn't the control window */ if (window != win->controlwindow) { if (window && !wnck_window_is_minimized(window) && wnck_window_is_maximized(window)) { track_controled_window (win); } } }
/* Returns the highest maximized window */ static WnckWindow *get_upper_maximized (WckUtils *win) { WnckWindow *umaxedwindow = NULL; GList *windows = wnck_screen_get_windows_stacked(win->activescreen); while (windows && windows->data) { if (!win->activeworkspace || wnck_window_is_in_viewport(windows->data, win->activeworkspace)) if (wnck_window_is_maximized(windows->data) && !wnck_window_is_minimized(windows->data)) { umaxedwindow = windows->data; } windows = windows->next; } /* NULL if no maximized window found */ return umaxedwindow; }
static void wibuti_watcher_find_window(WibutiWatcher *self) { WnckWorkspace *activeworkspace = wnck_screen_get_active_workspace(self->screen); WnckWindow *new_active = wnck_screen_get_active_window(self->screen); WnckWindow *new_tracked = NULL; // stop tracking the old active window if (G_IS_OBJECT(self->active)) { if (g_signal_handler_is_connected(G_OBJECT(self->active), self->handler_active_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->active), self->handler_active_state_changed); } } if (self->only_maximized) { // find upper maximized window GList *windows = wnck_screen_get_windows_stacked(self->screen); while (windows && windows->data) { if (!self->only_maximized || wnck_window_is_maximized(windows->data)) if (!wnck_window_is_minimized(windows->data) && !wnck_window_is_skip_pager(windows->data)) if (wnck_window_is_in_viewport(windows->data, activeworkspace)) new_tracked = windows->data; windows = windows->next; } // start tracking the new active window if (new_active) { self->handler_active_state_changed = g_signal_connect(G_OBJECT(new_active), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } } else { new_tracked = new_active; } // stop tracking the old window if (G_IS_OBJECT(self->tracked)) { #ifdef WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_name_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_name_changed); } if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_icon_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_icon_changed); } #endif // WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_tracked_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_tracked_state_changed); } } // start tracking the new window if (new_tracked) { #ifdef WIBUTI_WITH_TITLE self->handler_name_changed = g_signal_connect(G_OBJECT(new_tracked), "name-changed", G_CALLBACK(wibuti_watcher_name_changed_cb), self); self->handler_icon_changed = g_signal_connect(G_OBJECT(new_tracked), "icon-changed", G_CALLBACK(wibuti_watcher_icon_changed_cb), self); #endif // WIBUTI_WITH_TITLE self->handler_tracked_state_changed = g_signal_connect(G_OBJECT(new_tracked), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } self->tracked = new_tracked; self->active = new_active; }
/* track the new controled window according to preferences */ static void track_controled_window (WckUtils *win) { WnckWindow *previous_umax = NULL; WnckWindow *previous_control = NULL; previous_control = win->controlwindow; if (win->only_maximized) { previous_umax = win->umaxwindow; win->umaxwindow = get_upper_maximized(win); win->controlwindow = win->umaxwindow; } else if (win->activewindow && (!win->activeworkspace || wnck_window_is_in_viewport(win->activewindow, win->activeworkspace)) && !wnck_window_is_minimized(win->activewindow) && !wnck_window_is_sticky(win->activewindow)) { win->controlwindow = win->activewindow; } if (!win->umaxwindow || (win->umaxwindow != previous_umax)) { wck_signal_handler_disconnect (G_OBJECT(previous_umax), win->msh); wck_signal_handler_disconnect (G_OBJECT(previous_umax), win->mwh); } if (win->only_maximized) { if (win->umaxwindow && (win->umaxwindow != previous_umax)) { /* track the new upper maximized window state */ win->msh = g_signal_connect(G_OBJECT(win->umaxwindow), "state-changed", G_CALLBACK (on_umaxed_window_state_changed), win); win->mwh = g_signal_connect(G_OBJECT (win->umaxwindow), "workspace-changed", G_CALLBACK (umax_window_workspace_changed), win); } else if (win->controlwindow == previous_control) { /* track previous upper maximized window state on desktop */ win->umaxwindow = previous_umax; if (win->umaxwindow) { win->msh = g_signal_connect(G_OBJECT(win->umaxwindow), "state-changed", G_CALLBACK (track_changed_max_state), win); } } } if (!win->controlwindow) win->controlwindow = get_root_window(win->activescreen); if (win->controlwindow != previous_control) on_control_window_changed(win->controlwindow, previous_control, win->data); else on_wck_state_changed(win->controlwindow, win->data); }
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 (); } }
void tile(int workspace_id) { GList *item; int i = 0; int x = 0; int y = 0; int height = 0; int width = 0; int left_count = workspace_get_left_count(workspace_id); int right_count = 0; int space_x = 0; int space_y = 0; int space_width = 0; int space_height = 0; /* I may have used a new temporary list containing only tileable windows (ie not minimized), but wnck_window_is_minimized is cheap and less error prone than alloc/free */ GList *tiled_windows = workspace_windows(workspace_id); int windows_count = workspace_get_tileable_count(workspace_id); get_workspace_geometry(workspace_id, &space_x, &space_y, &space_width, &space_height); /* distribute windows in both columns, while left one is not full */ if (windows_count < 2 * left_count) { left_count = (windows_count + 1) / 2; } right_count = windows_count - left_count; int frontier = space_width * workspace_get_left_width(workspace_id) / 100 + configuration.width_offset; for (item = g_list_first(tiled_windows); item != NULL; item = g_list_next(item)) { WnckWindow *window = (WnckWindow *)item->data; if (wnck_window_is_minimized(window)) { continue; } if (i < left_count) { x = space_x; y = space_y + (space_height / left_count) * i; height = space_height / left_count; width = frontier; } else { x = space_x + frontier; y = space_y + (space_height / right_count) * (i - left_count); height = space_height / right_count; width = space_width - frontier; } XMoveResizeWindow(main_dpy, wnck_window_get_xid (window), x + 1, y + 1, width - 2, height - 2); i++; } }
static gboolean on_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data) { SSWorkspace *workspace; int screen_width, screen_height; double width_ratio, height_ratio; int x, y, w, h; int viewport_x; GList *i; SSWindow *active_window; WnckWindow *wnck_window; int state; GdkRectangle r; workspace = (SSWorkspace *) data; screen_width = workspace->screen->screen_width; screen_height = workspace->screen->screen_height; active_window = workspace->screen->active_window; x = widget->allocation.x; y = widget->allocation.y; w = widget->allocation.width; h = widget->allocation.height; state = (workspace == workspace->screen->active_workspace) ? GTK_STATE_SELECTED : GTK_STATE_NORMAL; gdk_draw_rectangle (widget->window, widget->style->dark_gc[state], TRUE, 1, 1, w-2, h-2); gdk_draw_rectangle (widget->window, widget->style->base_gc[state], FALSE, 0, 0, w-1, h-1); width_ratio = (double) w / (double) screen_width; height_ratio = (double) h / (double) screen_height; viewport_x = 0; if (window_manager_uses_viewports) { viewport_x = wnck_workspace_get_viewport_x (workspace->wnck_workspace); } for (i = workspace->screen->wnck_windows_in_stacking_order; i; i = i->next) { wnck_window = (WnckWindow *) i->data; if (wnck_window_get_workspace (wnck_window) != workspace->wnck_workspace) { continue; } if (wnck_window_is_minimized (wnck_window)) { continue; } state = GTK_STATE_ACTIVE; if ((active_window != NULL) && ((wnck_window_get_xid (wnck_window) == wnck_window_get_xid (active_window->wnck_window)))) { state = GTK_STATE_SELECTED; } wnck_window_get_geometry (wnck_window, &r.x, &r.y, &r.width, &r.height); if (window_manager_uses_viewports) { r.x += viewport_x - (workspace->viewport * workspace->screen->screen_width); } r.x = 0.5 + r.x * width_ratio; r.y = 0.5 + r.y * height_ratio; r.width = 0.5 + r.width * width_ratio; r.height = 0.5 + r.height * height_ratio; if (r.width < 3) { r.width = 3; } if (r.height < 3) { r.height = 3; } gdk_draw_rectangle (widget->window, widget->style->bg_gc[state], TRUE, r.x+1, r.y+1, r.width-2, r.height-2); gdk_draw_rectangle (widget->window, widget->style->fg_gc[state], FALSE, r.x, r.y, r.width-1, r.height-1); } on_expose_event_draw_text (widget, workspace); return FALSE; }