mutter/src/screen.c

403 lines
10 KiB
C
Raw Normal View History

2001-05-30 15:36:31 +00: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 06:42:58 +00:00
2001-05-30 15:36:31 +00:00
#include "screen.h"
#include "util.h"
2001-05-31 03:30:58 +00:00
#include "errors.h"
2001-05-31 06:42:58 +00:00
#include "window.h"
2001-06-03 18:33:59 +00:00
#include "frame.h"
2001-06-06 04:47:37 +00:00
#include "workspace.h"
#include "keybindings.h"
2001-06-10 18:46:46 +00:00
#include "stack.h"
2001-06-01 03:00:01 +00:00
2001-06-02 04:14:18 +00:00
#include <X11/cursorfont.h>
2001-06-10 03:17:15 +00:00
#include <X11/Xatom.h>
2001-06-01 03:00:01 +00:00
#include <locale.h>
#include <string.h>
2001-05-30 15:36:31 +00:00
2001-06-03 01:33:27 +00:00
static char* get_screen_name (MetaDisplay *display,
int number);
2001-06-10 03:17:15 +00:00
static int
set_wm_check_hint (MetaScreen *screen)
{
unsigned long data[1];
2001-06-10 19:23:28 +00:00
g_return_val_if_fail (screen->display->leader_window != None, 0);
2001-06-10 03:17:15 +00: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 05:49:35 +00:00
/* Legacy GNOME hint */
XChangeProperty (screen->display->xdisplay, screen->xroot,
screen->display->atom_win_supporting_wm_check,
2001-06-23 06:54:28 +00:00
XA_CARDINAL,
2001-06-23 05:49:35 +00:00
32, PropModeReplace, (guchar*) data, 1);
2001-06-10 03:17:15 +00:00
return Success;
}
static int
set_supported_hint (MetaScreen *screen)
{
2001-06-11 05:47:51 +00:00
#define N_SUPPORTED 21
2001-06-23 05:49:35 +00:00
#define N_WIN_SUPPORTED 1
2001-06-10 03:17:15 +00:00
Atom atoms[N_SUPPORTED];
2001-06-10 19:23:28 +00:00
2001-06-10 03:17:15 +00: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 19:23:28 +00:00
atoms[17] = screen->display->atom_net_client_list;
atoms[18] = screen->display->atom_net_client_list_stacking;
2001-06-11 05:47:51 +00:00
atoms[19] = screen->display->atom_net_wm_state_skip_taskbar;
atoms[20] = screen->display->atom_net_wm_state_skip_pager;
2001-06-10 03:17:15 +00:00
XChangeProperty (screen->display->xdisplay, screen->xroot,
screen->display->atom_net_wm_supported,
XA_ATOM,
32, PropModeReplace, (guchar*) atoms, N_SUPPORTED);
2001-06-23 05:49:35 +00: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-10 03:17:15 +00:00
return Success;
#undef N_SUPPORTED
}
2001-05-30 15:36:31 +00:00
MetaScreen*
meta_screen_new (MetaDisplay *display,
int number)
{
MetaScreen *screen;
2001-05-31 03:30:58 +00:00
Window xroot;
Display *xdisplay;
2001-05-31 06:42:58 +00:00
Cursor cursor;
2001-05-31 03:30:58 +00: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-31 06:42:58 +00:00
cursor = XCreateFontCursor (display->xdisplay, XC_left_ptr);
XDefineCursor (display->xdisplay, xroot, cursor);
XFreeCursor (display->xdisplay, cursor);
2001-05-30 15:36:31 +00:00
screen = g_new (MetaScreen, 1);
2001-05-31 06:42:58 +00:00
screen->display = display;
2001-05-30 15:36:31 +00:00
screen->number = number;
2001-06-03 01:33:27 +00:00
screen->screen_name = get_screen_name (display, number);
2001-05-31 03:30:58 +00:00
screen->xscreen = ScreenOfDisplay (xdisplay, number);
2001-06-18 06:11:53 +00:00
screen->xroot = xroot;
2001-07-04 04:33:31 +00:00
screen->width = WidthOfScreen (screen->xscreen);
screen->height = HeightOfScreen (screen->xscreen);
2001-06-10 19:23:28 +00:00
if (display->leader_window == None)
display->leader_window = XCreateSimpleWindow (display->xdisplay,
screen->xroot,
-100, -100, 1, 1, 0, 0, 0);
2001-06-10 03:17:15 +00:00
set_supported_hint (screen);
set_wm_check_hint (screen);
2001-06-06 04:47:37 +00: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-07 02:42:24 +00: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 04:47:37 +00:00
meta_workspace_new (screen);
2001-06-03 21:39:57 +00:00
2001-06-06 04:47:37 +00:00
meta_screen_grab_keys (screen);
2001-06-18 03:24:25 +00:00
2001-06-18 06:11:53 +00:00
screen->ui = meta_ui_new (screen->display->xdisplay,
2001-06-18 03:24:25 +00:00
screen->xscreen);
2001-06-10 18:46:46 +00:00
screen->stack = meta_stack_new (screen);
2001-06-01 03:00:01 +00:00
2001-06-03 01:33:27 +00:00
meta_verbose ("Added screen %d ('%s') root 0x%lx\n",
screen->number, screen->screen_name, screen->xroot);
2001-05-30 15:36:31 +00:00
return screen;
}
void
meta_screen_free (MetaScreen *screen)
2001-06-10 18:46:46 +00:00
{
2001-06-06 04:47:37 +00:00
meta_screen_ungrab_keys (screen);
2001-06-18 06:11:53 +00:00
meta_ui_free (screen->ui);
2001-06-03 21:39:57 +00:00
2001-06-10 18:46:46 +00:00
meta_stack_free (screen->stack);
2001-06-03 01:33:27 +00:00
g_free (screen->screen_name);
2001-05-30 15:36:31 +00:00
g_free (screen);
}
2001-05-31 06:42:58 +00: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 15:36:31 +00:00
2001-05-31 06:42:58 +00:00
if (meta_error_trap_pop (screen->display))
{
meta_display_ungrab (screen->display);
return;
}
2001-06-11 03:24:20 +00:00
meta_stack_freeze (screen->stack);
2001-05-31 06:42:58 +00:00
i = 0;
while (i < n_children)
{
2001-06-11 05:47:51 +00:00
meta_window_new (screen->display, children[i], TRUE);
2001-05-31 06:42:58 +00:00
++i;
}
2001-06-11 03:24:20 +00:00
meta_stack_thaw (screen->stack);
2001-05-31 06:42:58 +00:00
meta_display_ungrab (screen->display);
if (children)
XFree (children);
}
2001-06-01 03:00:01 +00: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-03 01:33:27 +00: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 18:33:59 +00: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 04:47:37 +00:00
2001-06-20 03:01:26 +00: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 04:47:37 +00:00
2001-06-09 05:14:43 +00: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;
}