2001-05-30 11:36:31 -04:00
|
|
|
/* Metacity X screen handler */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright (C) 2001 Havoc Pennington
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
|
|
* License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
* 02111-1307, USA.
|
|
|
|
*/
|
2001-05-31 02:42:58 -04:00
|
|
|
|
2001-12-09 17:41:12 -05:00
|
|
|
#include <config.h>
|
2001-05-30 11:36:31 -04:00
|
|
|
#include "screen.h"
|
|
|
|
#include "util.h"
|
2001-05-30 23:30:58 -04:00
|
|
|
#include "errors.h"
|
2001-05-31 02:42:58 -04:00
|
|
|
#include "window.h"
|
2001-06-03 14:33:59 -04:00
|
|
|
#include "frame.h"
|
2001-12-09 22:55:26 -05:00
|
|
|
#include "prefs.h"
|
2001-06-06 00:47:37 -04:00
|
|
|
#include "workspace.h"
|
|
|
|
#include "keybindings.h"
|
2001-06-10 14:46:46 -04:00
|
|
|
#include "stack.h"
|
2001-05-31 23:00:01 -04:00
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
#include <X11/Xatom.h>
|
2001-05-31 23:00:01 -04:00
|
|
|
#include <locale.h>
|
|
|
|
#include <string.h>
|
2001-05-30 11:36:31 -04:00
|
|
|
|
2001-06-02 21:33:27 -04:00
|
|
|
static char* get_screen_name (MetaDisplay *display,
|
|
|
|
int number);
|
|
|
|
|
2001-12-09 22:55:26 -05:00
|
|
|
static void update_num_workspaces (MetaScreen *screen);
|
|
|
|
static void prefs_changed_callback (MetaPreference pref,
|
|
|
|
gpointer data);
|
2001-06-02 21:33:27 -04:00
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
static int
|
|
|
|
set_wm_check_hint (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
unsigned long data[1];
|
|
|
|
|
2001-06-10 15:23:28 -04:00
|
|
|
g_return_val_if_fail (screen->display->leader_window != None, 0);
|
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
data[0] = screen->display->leader_window;
|
|
|
|
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->xroot,
|
|
|
|
screen->display->atom_net_supporting_wm_check,
|
|
|
|
XA_WINDOW,
|
|
|
|
32, PropModeReplace, (guchar*) data, 1);
|
2001-06-23 01:49:35 -04:00
|
|
|
|
2001-08-03 09:56:39 -04:00
|
|
|
/* Legacy GNOME hint (uses cardinal, dunno why) */
|
|
|
|
|
|
|
|
/* legacy hint window should have property containing self */
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->display->leader_window,
|
2001-06-23 01:49:35 -04:00
|
|
|
screen->display->atom_win_supporting_wm_check,
|
2001-06-23 02:54:28 -04:00
|
|
|
XA_CARDINAL,
|
2001-06-23 01:49:35 -04:00
|
|
|
32, PropModeReplace, (guchar*) data, 1);
|
|
|
|
|
2001-08-03 09:56:39 -04:00
|
|
|
/* do this after setting up window fully, to avoid races
|
|
|
|
* with clients listening to property notify on root.
|
|
|
|
*/
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->xroot,
|
|
|
|
screen->display->atom_win_supporting_wm_check,
|
|
|
|
XA_CARDINAL,
|
|
|
|
32, PropModeReplace, (guchar*) data, 1);
|
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
return Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
set_supported_hint (MetaScreen *screen)
|
|
|
|
{
|
2001-08-29 00:16:30 -04:00
|
|
|
#define N_SUPPORTED 23
|
2001-06-23 01:49:35 -04:00
|
|
|
#define N_WIN_SUPPORTED 1
|
2001-06-09 23:17:15 -04:00
|
|
|
Atom atoms[N_SUPPORTED];
|
2001-06-10 15:23:28 -04:00
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
atoms[0] = screen->display->atom_net_wm_name;
|
|
|
|
atoms[1] = screen->display->atom_net_close_window;
|
|
|
|
atoms[2] = screen->display->atom_net_wm_state;
|
|
|
|
atoms[3] = screen->display->atom_net_wm_state_shaded;
|
|
|
|
atoms[4] = screen->display->atom_net_wm_state_maximized_vert;
|
|
|
|
atoms[5] = screen->display->atom_net_wm_state_maximized_horz;
|
|
|
|
atoms[6] = screen->display->atom_net_wm_desktop;
|
|
|
|
atoms[7] = screen->display->atom_net_number_of_desktops;
|
|
|
|
atoms[8] = screen->display->atom_net_current_desktop;
|
|
|
|
atoms[9] = screen->display->atom_net_wm_window_type;
|
|
|
|
atoms[10] = screen->display->atom_net_wm_window_type_desktop;
|
|
|
|
atoms[11] = screen->display->atom_net_wm_window_type_dock;
|
|
|
|
atoms[12] = screen->display->atom_net_wm_window_type_toolbar;
|
|
|
|
atoms[13] = screen->display->atom_net_wm_window_type_menu;
|
|
|
|
atoms[14] = screen->display->atom_net_wm_window_type_dialog;
|
|
|
|
atoms[15] = screen->display->atom_net_wm_window_type_normal;
|
|
|
|
atoms[16] = screen->display->atom_net_wm_state_modal;
|
2001-06-10 15:23:28 -04:00
|
|
|
atoms[17] = screen->display->atom_net_client_list;
|
|
|
|
atoms[18] = screen->display->atom_net_client_list_stacking;
|
2001-06-11 01:47:51 -04:00
|
|
|
atoms[19] = screen->display->atom_net_wm_state_skip_taskbar;
|
|
|
|
atoms[20] = screen->display->atom_net_wm_state_skip_pager;
|
2001-08-19 21:42:44 -04:00
|
|
|
atoms[21] = screen->display->atom_net_wm_icon;
|
2001-08-29 00:16:30 -04:00
|
|
|
atoms[22] = screen->display->atom_net_wm_moveresize;
|
2001-06-09 23:17:15 -04:00
|
|
|
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->xroot,
|
2001-08-29 00:16:30 -04:00
|
|
|
screen->display->atom_net_supported,
|
2001-06-09 23:17:15 -04:00
|
|
|
XA_ATOM,
|
|
|
|
32, PropModeReplace, (guchar*) atoms, N_SUPPORTED);
|
|
|
|
|
2001-06-23 01:49:35 -04:00
|
|
|
/* Set legacy GNOME hints */
|
|
|
|
atoms[0] = screen->display->atom_win_layer;
|
|
|
|
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->xroot,
|
|
|
|
screen->display->atom_win_protocols,
|
|
|
|
XA_ATOM,
|
|
|
|
32, PropModeReplace, (guchar*) atoms, N_WIN_SUPPORTED);
|
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
return Success;
|
|
|
|
#undef N_SUPPORTED
|
|
|
|
}
|
|
|
|
|
2001-08-19 21:42:44 -04:00
|
|
|
static int
|
|
|
|
set_wm_icon_size_hint (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
#define N_VALS 6
|
|
|
|
gulong vals[N_VALS];
|
|
|
|
|
|
|
|
/* min width, min height, max w, max h, width inc, height inc */
|
|
|
|
vals[0] = META_ICON_WIDTH;
|
|
|
|
vals[1] = META_ICON_HEIGHT;
|
|
|
|
vals[2] = META_ICON_WIDTH;
|
|
|
|
vals[3] = META_ICON_HEIGHT;
|
|
|
|
vals[4] = 0;
|
|
|
|
vals[5] = 0;
|
|
|
|
|
|
|
|
XChangeProperty (screen->display->xdisplay, screen->xroot,
|
|
|
|
screen->display->atom_wm_icon_size,
|
|
|
|
XA_CARDINAL,
|
|
|
|
32, PropModeReplace, (guchar*) vals, N_VALS);
|
|
|
|
|
|
|
|
return Success;
|
|
|
|
#undef N_VALS
|
|
|
|
}
|
|
|
|
|
2001-05-30 11:36:31 -04:00
|
|
|
MetaScreen*
|
|
|
|
meta_screen_new (MetaDisplay *display,
|
|
|
|
int number)
|
|
|
|
{
|
|
|
|
MetaScreen *screen;
|
2001-05-30 23:30:58 -04:00
|
|
|
Window xroot;
|
|
|
|
Display *xdisplay;
|
2001-05-31 02:42:58 -04:00
|
|
|
|
2001-05-30 23:30:58 -04:00
|
|
|
/* Only display->name, display->xdisplay, and display->error_traps
|
|
|
|
* can really be used in this function, since normally screens are
|
|
|
|
* created from the MetaDisplay constructor
|
|
|
|
*/
|
|
|
|
|
|
|
|
xdisplay = display->xdisplay;
|
|
|
|
|
|
|
|
meta_verbose ("Trying screen %d on display '%s'\n",
|
|
|
|
number, display->name);
|
|
|
|
|
|
|
|
xroot = RootWindow (xdisplay, number);
|
|
|
|
|
|
|
|
/* FVWM checks for None here, I don't know if this
|
|
|
|
* ever actually happens
|
|
|
|
*/
|
|
|
|
if (xroot == None)
|
|
|
|
{
|
|
|
|
meta_warning (_("Screen %d on display '%s' is invalid\n"),
|
|
|
|
number, display->name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Select our root window events */
|
|
|
|
meta_error_trap_push (display);
|
|
|
|
XSelectInput (xdisplay,
|
|
|
|
xroot,
|
|
|
|
SubstructureRedirectMask | SubstructureNotifyMask |
|
|
|
|
ColormapChangeMask | PropertyChangeMask |
|
|
|
|
LeaveWindowMask | EnterWindowMask |
|
|
|
|
ButtonPressMask | ButtonReleaseMask);
|
|
|
|
if (meta_error_trap_pop (display) != Success)
|
|
|
|
{
|
|
|
|
meta_warning (_("Screen %d on display '%s' already has a window manager\n"),
|
|
|
|
number, display->name);
|
|
|
|
return NULL;
|
|
|
|
}
|
2001-05-30 11:36:31 -04:00
|
|
|
|
|
|
|
screen = g_new (MetaScreen, 1);
|
|
|
|
|
2001-05-31 02:42:58 -04:00
|
|
|
screen->display = display;
|
2001-05-30 11:36:31 -04:00
|
|
|
screen->number = number;
|
2001-06-02 21:33:27 -04:00
|
|
|
screen->screen_name = get_screen_name (display, number);
|
2001-05-30 23:30:58 -04:00
|
|
|
screen->xscreen = ScreenOfDisplay (xdisplay, number);
|
2001-06-18 02:11:53 -04:00
|
|
|
screen->xroot = xroot;
|
2001-07-04 00:33:31 -04:00
|
|
|
screen->width = WidthOfScreen (screen->xscreen);
|
|
|
|
screen->height = HeightOfScreen (screen->xscreen);
|
2001-07-25 23:14:45 -04:00
|
|
|
screen->current_cursor = -1; /* invalid/unset */
|
2001-09-08 23:44:42 -04:00
|
|
|
screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
|
|
|
|
screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
|
2001-07-25 23:14:45 -04:00
|
|
|
|
|
|
|
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
|
2001-07-04 00:33:31 -04:00
|
|
|
|
2001-06-10 15:23:28 -04:00
|
|
|
if (display->leader_window == None)
|
|
|
|
display->leader_window = XCreateSimpleWindow (display->xdisplay,
|
|
|
|
screen->xroot,
|
|
|
|
-100, -100, 1, 1, 0, 0, 0);
|
2001-08-19 21:42:44 -04:00
|
|
|
|
|
|
|
set_wm_icon_size_hint (screen);
|
2001-06-10 15:23:28 -04:00
|
|
|
|
2001-06-09 23:17:15 -04:00
|
|
|
set_supported_hint (screen);
|
|
|
|
|
|
|
|
set_wm_check_hint (screen);
|
|
|
|
|
2001-06-06 00:47:37 -04:00
|
|
|
/* Screens must have at least one workspace at all times,
|
|
|
|
* so create that required workspace.
|
|
|
|
*/
|
|
|
|
screen->active_workspace = meta_workspace_new (screen);
|
2001-06-06 22:42:24 -04:00
|
|
|
/* FIXME, for now there are always 6 workspaces... */
|
|
|
|
meta_workspace_new (screen);
|
|
|
|
meta_workspace_new (screen);
|
|
|
|
meta_workspace_new (screen);
|
|
|
|
meta_workspace_new (screen);
|
2001-06-06 00:47:37 -04:00
|
|
|
meta_workspace_new (screen);
|
2001-06-03 17:39:57 -04:00
|
|
|
|
2001-06-06 00:47:37 -04:00
|
|
|
meta_screen_grab_keys (screen);
|
2001-06-17 23:24:25 -04:00
|
|
|
|
2001-06-18 02:11:53 -04:00
|
|
|
screen->ui = meta_ui_new (screen->display->xdisplay,
|
2001-06-17 23:24:25 -04:00
|
|
|
screen->xscreen);
|
2001-06-10 14:46:46 -04:00
|
|
|
|
2001-08-19 14:09:10 -04:00
|
|
|
screen->tab_popup = NULL;
|
|
|
|
|
2001-06-10 14:46:46 -04:00
|
|
|
screen->stack = meta_stack_new (screen);
|
2001-12-09 22:55:26 -05:00
|
|
|
|
|
|
|
meta_prefs_add_listener (prefs_changed_callback, screen);
|
2001-05-31 23:00:01 -04:00
|
|
|
|
2001-06-02 21:33:27 -04:00
|
|
|
meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
|
|
|
|
screen->number, screen->screen_name, screen->xroot);
|
2001-05-30 11:36:31 -04:00
|
|
|
|
|
|
|
return screen;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_free (MetaScreen *screen)
|
2001-12-09 22:55:26 -05:00
|
|
|
{
|
|
|
|
meta_prefs_remove_listener (prefs_changed_callback, screen);
|
|
|
|
|
2001-06-06 00:47:37 -04:00
|
|
|
meta_screen_ungrab_keys (screen);
|
2001-08-19 14:09:10 -04:00
|
|
|
|
2001-06-18 02:11:53 -04:00
|
|
|
meta_ui_free (screen->ui);
|
2001-06-03 17:39:57 -04:00
|
|
|
|
2001-06-10 14:46:46 -04:00
|
|
|
meta_stack_free (screen->stack);
|
|
|
|
|
2001-06-02 21:33:27 -04:00
|
|
|
g_free (screen->screen_name);
|
2001-05-30 11:36:31 -04:00
|
|
|
g_free (screen);
|
|
|
|
}
|
|
|
|
|
2001-05-31 02:42:58 -04:00
|
|
|
void
|
|
|
|
meta_screen_manage_all_windows (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
Window ignored1, ignored2;
|
|
|
|
Window *children;
|
|
|
|
unsigned int n_children;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Must grab server to avoid obvious race condition */
|
|
|
|
meta_display_grab (screen->display);
|
|
|
|
|
|
|
|
meta_error_trap_push (screen->display);
|
|
|
|
|
|
|
|
XQueryTree (screen->display->xdisplay,
|
|
|
|
screen->xroot,
|
|
|
|
&ignored1, &ignored2, &children, &n_children);
|
2001-05-30 11:36:31 -04:00
|
|
|
|
2001-05-31 02:42:58 -04:00
|
|
|
if (meta_error_trap_pop (screen->display))
|
|
|
|
{
|
|
|
|
meta_display_ungrab (screen->display);
|
|
|
|
return;
|
|
|
|
}
|
2001-06-10 23:24:20 -04:00
|
|
|
|
|
|
|
meta_stack_freeze (screen->stack);
|
2001-05-31 02:42:58 -04:00
|
|
|
i = 0;
|
|
|
|
while (i < n_children)
|
|
|
|
{
|
2001-06-11 01:47:51 -04:00
|
|
|
meta_window_new (screen->display, children[i], TRUE);
|
2001-05-31 02:42:58 -04:00
|
|
|
|
|
|
|
++i;
|
|
|
|
}
|
2001-06-10 23:24:20 -04:00
|
|
|
meta_stack_thaw (screen->stack);
|
2001-05-31 02:42:58 -04:00
|
|
|
|
|
|
|
meta_display_ungrab (screen->display);
|
|
|
|
|
|
|
|
if (children)
|
|
|
|
XFree (children);
|
|
|
|
}
|
2001-05-31 23:00:01 -04:00
|
|
|
|
|
|
|
MetaScreen*
|
|
|
|
meta_screen_for_x_screen (Screen *xscreen)
|
|
|
|
{
|
|
|
|
MetaDisplay *display;
|
|
|
|
|
|
|
|
display = meta_display_for_x_display (DisplayOfScreen (xscreen));
|
|
|
|
|
|
|
|
if (display == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return meta_display_screen_for_x_screen (display, xscreen);
|
|
|
|
}
|
2001-06-02 21:33:27 -04:00
|
|
|
|
2001-12-09 22:55:26 -05:00
|
|
|
static void
|
|
|
|
prefs_changed_callback (MetaPreference pref,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
MetaScreen *screen = data;
|
|
|
|
|
|
|
|
if (pref == META_PREF_NUM_WORKSPACES)
|
|
|
|
{
|
|
|
|
update_num_workspaces (screen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-02 21:33:27 -04:00
|
|
|
static char*
|
|
|
|
get_screen_name (MetaDisplay *display,
|
|
|
|
int number)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char *dname;
|
|
|
|
char *scr;
|
|
|
|
|
|
|
|
/* DisplayString gives us a sort of canonical display,
|
|
|
|
* vs. the user-entered name from XDisplayName()
|
|
|
|
*/
|
|
|
|
dname = g_strdup (DisplayString (display->xdisplay));
|
|
|
|
|
|
|
|
/* Change display name to specify this screen.
|
|
|
|
*/
|
|
|
|
p = strrchr (dname, ':');
|
|
|
|
if (p)
|
|
|
|
{
|
|
|
|
p = strchr (p, '.');
|
|
|
|
if (p)
|
|
|
|
*p = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
scr = g_strdup_printf ("%s.%d", dname, number);
|
|
|
|
|
|
|
|
g_free (dname);
|
|
|
|
|
|
|
|
return scr;
|
|
|
|
}
|
2001-06-03 14:33:59 -04:00
|
|
|
|
|
|
|
static gint
|
|
|
|
ptrcmp (gconstpointer a, gconstpointer b)
|
|
|
|
{
|
|
|
|
if (a < b)
|
|
|
|
return -1;
|
|
|
|
else if (a > b)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
listify_func (gpointer key, gpointer value, gpointer data)
|
|
|
|
{
|
|
|
|
GSList **listp;
|
|
|
|
|
|
|
|
listp = data;
|
|
|
|
|
|
|
|
*listp = g_slist_prepend (*listp, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_foreach_window (MetaScreen *screen,
|
|
|
|
MetaScreenWindowFunc func,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
GSList *winlist;
|
|
|
|
GSList *tmp;
|
|
|
|
|
|
|
|
/* If we end up doing this often, just keeping a list
|
|
|
|
* of windows might be sensible.
|
|
|
|
*/
|
|
|
|
|
|
|
|
winlist = NULL;
|
|
|
|
g_hash_table_foreach (screen->display->window_ids,
|
|
|
|
listify_func,
|
|
|
|
&winlist);
|
|
|
|
|
|
|
|
winlist = g_slist_sort (winlist, ptrcmp);
|
|
|
|
|
|
|
|
tmp = winlist;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
/* If the next node doesn't contain this window
|
|
|
|
* a second time, delete the window.
|
|
|
|
*/
|
|
|
|
if (tmp->next == NULL ||
|
|
|
|
(tmp->next && tmp->next->data != tmp->data))
|
|
|
|
{
|
|
|
|
MetaWindow *window = tmp->data;
|
|
|
|
|
|
|
|
if (window->screen == screen)
|
|
|
|
(* func) (screen, window, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = tmp->data;
|
|
|
|
}
|
|
|
|
g_slist_free (winlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
|
|
|
|
{
|
|
|
|
if (window->frame)
|
|
|
|
meta_frame_queue_draw (window->frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_queue_frame_redraws (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
meta_screen_foreach_window (screen, queue_draw, NULL);
|
|
|
|
}
|
2001-06-06 00:47:37 -04:00
|
|
|
|
2001-06-19 23:01:26 -04:00
|
|
|
static void
|
|
|
|
queue_resize (MetaScreen *screen, MetaWindow *window, gpointer data)
|
|
|
|
{
|
|
|
|
meta_window_queue_move_resize (window);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_queue_window_resizes (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
meta_screen_foreach_window (screen, queue_resize, NULL);
|
|
|
|
}
|
2001-06-06 00:47:37 -04:00
|
|
|
|
2001-06-09 01:14:43 -04:00
|
|
|
int
|
|
|
|
meta_screen_get_n_workspaces (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
GList *tmp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
tmp = screen->display->workspaces;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWorkspace *w = tmp->data;
|
|
|
|
|
|
|
|
if (w->screen == screen)
|
|
|
|
++i;
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return i;
|
2001-12-09 22:55:26 -05:00
|
|
|
}
|
2001-06-09 01:14:43 -04:00
|
|
|
|
2001-12-09 22:55:26 -05:00
|
|
|
static void
|
|
|
|
update_num_workspaces (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
int new_num;
|
|
|
|
GList *tmp;
|
|
|
|
int i;
|
|
|
|
GList *extras;
|
|
|
|
MetaWorkspace *last_remaining;
|
|
|
|
gboolean need_change_space;
|
|
|
|
|
|
|
|
new_num = meta_prefs_get_num_workspaces ();
|
|
|
|
|
|
|
|
g_assert (new_num > 0);
|
|
|
|
|
|
|
|
last_remaining = NULL;
|
|
|
|
extras = NULL;
|
|
|
|
i = 0;
|
|
|
|
tmp = screen->display->workspaces;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWorkspace *w = tmp->data;
|
|
|
|
|
|
|
|
if (w->screen == screen)
|
|
|
|
{
|
|
|
|
++i;
|
|
|
|
|
|
|
|
if (i > new_num)
|
|
|
|
extras = g_list_prepend (extras, w);
|
|
|
|
else
|
|
|
|
last_remaining = w;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert (last_remaining);
|
|
|
|
|
|
|
|
/* Get rid of the extra workspaces by moving all their windows
|
|
|
|
* to last_remaining, then activating last_remaining if
|
|
|
|
* one of the removed workspaces was active. This will be a bit
|
|
|
|
* wacky if the config tool for changing number of workspaces
|
|
|
|
* is on a removed workspace ;-)
|
|
|
|
*/
|
|
|
|
need_change_space = FALSE;
|
|
|
|
tmp = extras;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWorkspace *w = tmp->data;
|
|
|
|
|
|
|
|
meta_workspace_relocate_windows (w, last_remaining);
|
|
|
|
|
|
|
|
if (w == screen->active_workspace)
|
|
|
|
need_change_space = TRUE;
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_change_space)
|
|
|
|
meta_workspace_activate (last_remaining);
|
|
|
|
|
|
|
|
/* Should now be safe to free the workspaces */
|
|
|
|
tmp = extras;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWorkspace *w = tmp->data;
|
|
|
|
|
|
|
|
g_assert (w->windows == NULL);
|
|
|
|
meta_workspace_free (w);
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_list_free (extras);
|
|
|
|
|
|
|
|
/* Add missing workspaces. FIXME This will keep setting the
|
|
|
|
* number-of-workspaces root window property on each workspace
|
|
|
|
* creation, kind of a lame thing
|
|
|
|
*/
|
|
|
|
while (i < new_num)
|
|
|
|
{
|
|
|
|
meta_workspace_new (screen);
|
|
|
|
++i;
|
|
|
|
}
|
2001-06-09 01:14:43 -04:00
|
|
|
}
|
2001-07-25 23:14:45 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_set_cursor (MetaScreen *screen,
|
|
|
|
MetaCursor cursor)
|
|
|
|
{
|
|
|
|
Cursor xcursor;
|
|
|
|
|
|
|
|
if (cursor == screen->current_cursor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
screen->current_cursor = cursor;
|
|
|
|
|
|
|
|
xcursor = meta_display_create_x_cursor (screen->display, cursor);
|
|
|
|
XDefineCursor (screen->display->xdisplay, screen->xroot, xcursor);
|
|
|
|
XFreeCursor (screen->display->xdisplay, xcursor);
|
|
|
|
}
|
2001-08-19 14:09:10 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
meta_screen_ensure_tab_popup (MetaScreen *screen)
|
|
|
|
{
|
|
|
|
MetaTabEntry *entries;
|
|
|
|
GSList *tab_list;
|
|
|
|
GSList *tmp;
|
|
|
|
int len;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (screen->tab_popup)
|
|
|
|
return;
|
|
|
|
|
2001-08-28 23:37:03 -04:00
|
|
|
tab_list = meta_stack_get_tab_list (screen->stack,
|
|
|
|
screen->active_workspace);
|
2001-08-19 14:09:10 -04:00
|
|
|
len = g_slist_length (tab_list);
|
|
|
|
|
|
|
|
entries = g_new (MetaTabEntry, len + 1);
|
|
|
|
entries[len].xwindow = None;
|
|
|
|
entries[len].title = NULL;
|
|
|
|
entries[len].icon = NULL;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
tmp = tab_list;
|
|
|
|
while (i < len)
|
|
|
|
{
|
|
|
|
MetaWindow *window;
|
2001-08-29 00:53:48 -04:00
|
|
|
MetaRectangle r;
|
|
|
|
|
2001-08-19 14:09:10 -04:00
|
|
|
window = tmp->data;
|
|
|
|
|
|
|
|
entries[i].xwindow = window->xwindow;
|
|
|
|
entries[i].title = window->title;
|
|
|
|
entries[i].icon = window->icon;
|
2001-08-29 00:53:48 -04:00
|
|
|
meta_window_get_outer_rect (window, &r);
|
|
|
|
entries[i].x = r.x;
|
|
|
|
entries[i].y = r.y;
|
|
|
|
entries[i].width = r.width;
|
|
|
|
entries[i].height = r.height;
|
2001-08-30 00:01:38 -04:00
|
|
|
|
|
|
|
/* Find inside of highlight rectangle to be used
|
|
|
|
* when window is outlined for tabbing.
|
|
|
|
* This should be the size of the east/west frame,
|
|
|
|
* and the size of the south frame, on those sides.
|
|
|
|
* on the top it should be the size of the south frame
|
|
|
|
* edge.
|
|
|
|
*/
|
|
|
|
if (window->frame)
|
|
|
|
{
|
|
|
|
int south = window->frame->rect.height - window->frame->child_y -
|
|
|
|
window->rect.height;
|
|
|
|
int east = window->frame->child_x;
|
|
|
|
entries[i].inner_x = east;
|
|
|
|
entries[i].inner_y = south;
|
|
|
|
entries[i].inner_width = window->rect.width;
|
|
|
|
entries[i].inner_height = window->frame->rect.height - south * 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Use an arbitrary border size */
|
|
|
|
#define OUTLINE_WIDTH 5
|
|
|
|
entries[i].inner_x = OUTLINE_WIDTH;
|
|
|
|
entries[i].inner_y = OUTLINE_WIDTH;
|
|
|
|
entries[i].inner_width = window->rect.width - OUTLINE_WIDTH * 2;
|
|
|
|
entries[i].inner_height = window->rect.height - OUTLINE_WIDTH * 2;
|
|
|
|
}
|
2001-08-19 14:09:10 -04:00
|
|
|
|
|
|
|
++i;
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
screen->tab_popup = meta_ui_tab_popup_new (entries);
|
|
|
|
g_free (entries);
|
|
|
|
|
|
|
|
/* don't show tab popup, since proper window isn't selected yet */
|
|
|
|
}
|