mutter/src/core/window-x11.c

1149 lines
37 KiB
C
Raw Normal View History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2001 Havoc Pennington, Anders Carlsson
* Copyright (C) 2002, 2003 Red Hat, Inc.
* Copyright (C) 2003 Rob Adams
* Copyright (C) 2004-2006 Elijah Newren
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "window-x11.h"
#include <string.h>
#include <X11/Xatom.h>
#include <X11/Xlibint.h> /* For display->resource_mask */
#ifdef HAVE_SHAPE
#include <X11/extensions/shape.h>
#endif
#include <meta/common.h>
#include <meta/errors.h>
#include <meta/prefs.h>
#include "window-private.h"
#include "window-props.h"
#include "xprops.h"
void
meta_window_x11_set_net_wm_state (MetaWindow *window)
{
int i;
unsigned long data[13];
i = 0;
if (window->shaded)
{
data[i] = window->display->atom__NET_WM_STATE_SHADED;
++i;
}
if (window->wm_state_modal)
{
data[i] = window->display->atom__NET_WM_STATE_MODAL;
++i;
}
if (window->skip_pager)
{
data[i] = window->display->atom__NET_WM_STATE_SKIP_PAGER;
++i;
}
if (window->skip_taskbar)
{
data[i] = window->display->atom__NET_WM_STATE_SKIP_TASKBAR;
++i;
}
if (window->maximized_horizontally)
{
data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_HORZ;
++i;
}
if (window->maximized_vertically)
{
data[i] = window->display->atom__NET_WM_STATE_MAXIMIZED_VERT;
++i;
}
if (window->fullscreen)
{
data[i] = window->display->atom__NET_WM_STATE_FULLSCREEN;
++i;
}
if (!meta_window_showing_on_its_workspace (window) || window->shaded)
{
data[i] = window->display->atom__NET_WM_STATE_HIDDEN;
++i;
}
if (window->wm_state_above)
{
data[i] = window->display->atom__NET_WM_STATE_ABOVE;
++i;
}
if (window->wm_state_below)
{
data[i] = window->display->atom__NET_WM_STATE_BELOW;
++i;
}
if (window->wm_state_demands_attention)
{
data[i] = window->display->atom__NET_WM_STATE_DEMANDS_ATTENTION;
++i;
}
if (window->on_all_workspaces_requested)
{
data[i] = window->display->atom__NET_WM_STATE_STICKY;
++i;
}
if (meta_window_appears_focused (window))
{
data[i] = window->display->atom__NET_WM_STATE_FOCUSED;
++i;
}
meta_verbose ("Setting _NET_WM_STATE with %d atoms\n", i);
meta_error_trap_push (window->display);
XChangeProperty (window->display->xdisplay, window->xwindow,
window->display->atom__NET_WM_STATE,
XA_ATOM,
32, PropModeReplace, (guchar*) data, i);
meta_error_trap_pop (window->display);
if (window->fullscreen)
{
data[0] = meta_screen_monitor_index_to_xinerama_index (window->screen,
window->fullscreen_monitors[0]);
data[1] = meta_screen_monitor_index_to_xinerama_index (window->screen,
window->fullscreen_monitors[1]);
data[2] = meta_screen_monitor_index_to_xinerama_index (window->screen,
window->fullscreen_monitors[2]);
data[3] = meta_screen_monitor_index_to_xinerama_index (window->screen,
window->fullscreen_monitors[3]);
meta_verbose ("Setting _NET_WM_FULLSCREEN_MONITORS\n");
meta_error_trap_push (window->display);
XChangeProperty (window->display->xdisplay,
window->xwindow,
window->display->atom__NET_WM_FULLSCREEN_MONITORS,
XA_CARDINAL, 32, PropModeReplace,
(guchar*) data, 4);
meta_error_trap_pop (window->display);
}
}
void
meta_window_x11_update_net_wm_type (MetaWindow *window)
{
int n_atoms;
Atom *atoms;
int i;
window->type_atom = None;
n_atoms = 0;
atoms = NULL;
meta_prop_get_atom_list (window->display, window->xwindow,
window->display->atom__NET_WM_WINDOW_TYPE,
&atoms, &n_atoms);
i = 0;
while (i < n_atoms)
{
/* We break as soon as we find one we recognize,
* supposed to prefer those near the front of the list
*/
if (atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DOCK ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_MENU ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
atoms[i] ==
window->display->atom__NET_WM_WINDOW_TYPE_DROPDOWN_MENU ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_POPUP_MENU ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLTIP ||
atoms[i] ==
window->display->atom__NET_WM_WINDOW_TYPE_NOTIFICATION ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_COMBO ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DND ||
atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
{
window->type_atom = atoms[i];
break;
}
++i;
}
meta_XFree (atoms);
if (meta_is_verbose ())
{
char *str;
str = NULL;
if (window->type_atom != None)
{
meta_error_trap_push (window->display);
str = XGetAtomName (window->display->xdisplay, window->type_atom);
meta_error_trap_pop (window->display);
}
meta_verbose ("Window %s type atom %s\n", window->desc,
str ? str : "(none)");
if (str)
meta_XFree (str);
}
meta_window_recalc_window_type (window);
}
void
meta_window_x11_update_role (MetaWindow *window)
{
char *str;
g_return_if_fail (!window->override_redirect);
if (window->role)
g_free (window->role);
window->role = NULL;
if (meta_prop_get_latin1_string (window->display, window->xwindow,
window->display->atom_WM_WINDOW_ROLE,
&str))
{
window->role = g_strdup (str);
meta_XFree (str);
}
meta_verbose ("Updated role of %s to '%s'\n",
window->desc, window->role ? window->role : "null");
}
static void
meta_window_set_opaque_region (MetaWindow *window,
cairo_region_t *region)
{
g_clear_pointer (&window->opaque_region, cairo_region_destroy);
if (region != NULL)
window->opaque_region = cairo_region_reference (region);
if (window->display->compositor)
meta_compositor_window_shape_changed (window->display->compositor, window);
}
void
meta_window_x11_update_opaque_region (MetaWindow *window)
{
cairo_region_t *opaque_region = NULL;
gulong *region = NULL;
int nitems;
if (meta_prop_get_cardinal_list (window->display,
window->xwindow,
window->display->atom__NET_WM_OPAQUE_REGION,
&region, &nitems))
{
cairo_rectangle_int_t *rects;
int i, rect_index, nrects;
if (nitems % 4 != 0)
{
meta_verbose ("_NET_WM_OPAQUE_REGION does not have a list of 4-tuples.");
goto out;
}
/* empty region */
if (nitems == 0)
goto out;
nrects = nitems / 4;
rects = g_new (cairo_rectangle_int_t, nrects);
rect_index = 0;
i = 0;
while (i < nitems)
{
cairo_rectangle_int_t *rect = &rects[rect_index];
rect->x = region[i++];
rect->y = region[i++];
rect->width = region[i++];
rect->height = region[i++];
rect_index++;
}
opaque_region = cairo_region_create_rectangles (rects, nrects);
g_free (rects);
}
out:
meta_XFree (region);
meta_window_set_opaque_region (window, opaque_region);
cairo_region_destroy (opaque_region);
}
static cairo_region_t *
region_create_from_x_rectangles (const XRectangle *rects,
int n_rects)
{
int i;
cairo_rectangle_int_t *cairo_rects = g_newa (cairo_rectangle_int_t, n_rects);
for (i = 0; i < n_rects; i ++)
{
cairo_rects[i].x = rects[i].x;
cairo_rects[i].y = rects[i].y;
cairo_rects[i].width = rects[i].width;
cairo_rects[i].height = rects[i].height;
}
return cairo_region_create_rectangles (cairo_rects, n_rects);
}
static void
meta_window_set_input_region (MetaWindow *window,
cairo_region_t *region)
{
g_clear_pointer (&window->input_region, cairo_region_destroy);
if (region != NULL)
window->input_region = cairo_region_reference (region);
if (window->display->compositor)
meta_compositor_window_shape_changed (window->display->compositor, window);
}
void
meta_window_x11_update_input_region (MetaWindow *window)
{
cairo_region_t *region = NULL;
#ifdef HAVE_SHAPE
if (META_DISPLAY_HAS_SHAPE (window->display))
{
/* Translate the set of XShape rectangles that we
* get from the X server to a cairo_region. */
XRectangle *rects = NULL;
int n_rects, ordering;
int x_bounding, y_bounding, x_clip, y_clip;
unsigned w_bounding, h_bounding, w_clip, h_clip;
int bounding_shaped, clip_shaped;
meta_error_trap_push (window->display);
XShapeQueryExtents (window->display->xdisplay, window->xwindow,
&bounding_shaped, &x_bounding, &y_bounding,
&w_bounding, &h_bounding,
&clip_shaped, &x_clip, &y_clip,
&w_clip, &h_clip);
rects = XShapeGetRectangles (window->display->xdisplay,
window->xwindow,
ShapeInput,
&n_rects,
&ordering);
meta_error_trap_pop (window->display);
/* XXX: The x shape extension doesn't provide a way to only test if an
* input shape has been specified, so we have to query and throw away the
* rectangles. */
if (rects)
{
if (n_rects > 1 ||
(n_rects == 1 &&
(rects[0].x != x_bounding ||
rects[1].y != y_bounding ||
rects[2].width != w_bounding ||
rects[3].height != h_bounding)))
region = region_create_from_x_rectangles (rects, n_rects);
XFree (rects);
}
}
#endif /* HAVE_SHAPE */
if (region != NULL)
{
cairo_rectangle_int_t client_area;
client_area.x = 0;
client_area.y = 0;
client_area.width = window->rect.width;
client_area.height = window->rect.height;
/* The shape we get back from the client may have coordinates
* outside of the frame. The X SHAPE Extension requires that
* the overall shape the client provides never exceeds the
* "bounding rectangle" of the window -- the shape that the
* window would have gotten if it was unshaped. In our case,
* this is simply the client area.
*/
cairo_region_intersect_rectangle (region, &client_area);
}
meta_window_set_input_region (window, region);
cairo_region_destroy (region);
}
static void
meta_window_set_shape_region (MetaWindow *window,
cairo_region_t *region)
{
g_clear_pointer (&window->shape_region, cairo_region_destroy);
if (region != NULL)
window->shape_region = cairo_region_reference (region);
if (window->display->compositor)
meta_compositor_window_shape_changed (window->display->compositor, window);
}
void
meta_window_x11_update_shape_region (MetaWindow *window)
{
cairo_region_t *region = NULL;
#ifdef HAVE_SHAPE
if (META_DISPLAY_HAS_SHAPE (window->display))
{
/* Translate the set of XShape rectangles that we
* get from the X server to a cairo_region. */
XRectangle *rects = NULL;
int n_rects, ordering;
int x_bounding, y_bounding, x_clip, y_clip;
unsigned w_bounding, h_bounding, w_clip, h_clip;
int bounding_shaped, clip_shaped;
meta_error_trap_push (window->display);
XShapeQueryExtents (window->display->xdisplay, window->xwindow,
&bounding_shaped, &x_bounding, &y_bounding,
&w_bounding, &h_bounding,
&clip_shaped, &x_clip, &y_clip,
&w_clip, &h_clip);
if (bounding_shaped)
{
rects = XShapeGetRectangles (window->display->xdisplay,
window->xwindow,
ShapeBounding,
&n_rects,
&ordering);
}
meta_error_trap_pop (window->display);
if (rects)
{
region = region_create_from_x_rectangles (rects, n_rects);
XFree (rects);
}
}
#endif /* HAVE_SHAPE */
if (region != NULL)
{
cairo_rectangle_int_t client_area;
client_area.x = 0;
client_area.y = 0;
client_area.width = window->rect.width;
client_area.height = window->rect.height;
/* The shape we get back from the client may have coordinates
* outside of the frame. The X SHAPE Extension requires that
* the overall shape the client provides never exceeds the
* "bounding rectangle" of the window -- the shape that the
* window would have gotten if it was unshaped. In our case,
* this is simply the client area.
*/
cairo_region_intersect_rectangle (region, &client_area);
}
meta_window_set_shape_region (window, region);
cairo_region_destroy (region);
}
/* Generally meta_window_same_application() is a better idea
* of "sameness", since it handles the case where multiple apps
* want to look like the same app or the same app wants to look
* like multiple apps, but in the case of workarounds for legacy
* applications (which likely aren't setting the group properly
* anyways), it may be desirable to check this as well.
*/
static gboolean
meta_window_same_client (MetaWindow *window,
MetaWindow *other_window)
{
int resource_mask = window->display->xdisplay->resource_mask;
return ((window->xwindow & ~resource_mask) ==
(other_window->xwindow & ~resource_mask));
}
gboolean
meta_window_x11_configure_request (MetaWindow *window,
XEvent *event)
{
/* Note that x, y is the corner of the window border,
* and width, height is the size of the window inside
* its border, but that we always deny border requests
* and give windows a border of 0. But we save the
* requested border here.
*/
if (event->xconfigurerequest.value_mask & CWBorderWidth)
window->border_width = event->xconfigurerequest.border_width;
meta_window_move_resize_request(window,
event->xconfigurerequest.value_mask,
window->size_hints.win_gravity,
event->xconfigurerequest.x,
event->xconfigurerequest.y,
event->xconfigurerequest.width,
event->xconfigurerequest.height);
/* Handle stacking. We only handle raises/lowers, mostly because
* stack.c really can't deal with anything else. I guess we'll fix
* that if a client turns up that really requires it. Only a very
* few clients even require the raise/lower (and in fact all client
* attempts to deal with stacking order are essentially broken,
* since they have no idea what other clients are involved or how
* the stack looks).
*
* I'm pretty sure no interesting client uses TopIf, BottomIf, or
* Opposite anyway, so the only possible missing thing is
* Above/Below with a sibling set. For now we just pretend there's
* never a sibling set and always do the full raise/lower instead of
* the raise-just-above/below-sibling.
*/
if (event->xconfigurerequest.value_mask & CWStackMode)
{
MetaWindow *active_window;
active_window = window->display->focus_window;
if (meta_prefs_get_disable_workarounds ())
{
meta_topic (META_DEBUG_STACK,
"%s sent an xconfigure stacking request; this is "
"broken behavior and the request is being ignored.\n",
window->desc);
}
else if (active_window &&
!meta_window_same_application (window, active_window) &&
!meta_window_same_client (window, active_window) &&
XSERVER_TIME_IS_BEFORE (window->net_wm_user_time,
active_window->net_wm_user_time))
{
meta_topic (META_DEBUG_STACK,
"Ignoring xconfigure stacking request from %s (with "
"user_time %u); currently active application is %s (with "
"user_time %u).\n",
window->desc,
window->net_wm_user_time,
active_window->desc,
active_window->net_wm_user_time);
if (event->xconfigurerequest.detail == Above)
meta_window_set_demands_attention(window);
}
else
{
switch (event->xconfigurerequest.detail)
{
case Above:
meta_window_raise (window);
break;
case Below:
meta_window_lower (window);
break;
case TopIf:
case BottomIf:
case Opposite:
break;
}
}
}
return TRUE;
}
static gboolean
process_property_notify (MetaWindow *window,
XPropertyEvent *event)
{
Window xid = window->xwindow;
if (meta_is_verbose ()) /* avoid looking up the name if we don't have to */
{
char *property_name = XGetAtomName (window->display->xdisplay,
event->atom);
meta_verbose ("Property notify on %s for %s\n",
window->desc, property_name);
XFree (property_name);
}
if (event->atom == window->display->atom__NET_WM_USER_TIME &&
window->user_time_window)
{
xid = window->user_time_window;
}
meta_window_reload_property_from_xwindow (window, xid, event->atom, FALSE);
return TRUE;
}
gboolean
meta_window_x11_property_notify (MetaWindow *window,
XEvent *event)
{
return process_property_notify (window, &event->xproperty);
}
#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
#define _NET_WM_MOVERESIZE_SIZE_TOP 1
#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
#define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
#define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
#define _NET_WM_MOVERESIZE_SIZE_LEFT 7
#define _NET_WM_MOVERESIZE_MOVE 8
#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9
#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10
#define _NET_WM_MOVERESIZE_CANCEL 11
static int
query_pressed_buttons (MetaWindow *window)
{
double x, y, query_root_x, query_root_y;
Window root, child;
XIButtonState buttons;
XIModifierState mods;
XIGroupState group;
int button = 0;
meta_error_trap_push (window->display);
XIQueryPointer (window->display->xdisplay,
META_VIRTUAL_CORE_POINTER_ID,
window->xwindow,
&root, &child,
&query_root_x, &query_root_y,
&x, &y,
&buttons, &mods, &group);
if (meta_error_trap_pop_with_return (window->display) != Success)
goto out;
if (XIMaskIsSet (buttons.mask, Button1))
button |= 1 << 1;
if (XIMaskIsSet (buttons.mask, Button2))
button |= 1 << 2;
if (XIMaskIsSet (buttons.mask, Button3))
button |= 1 << 3;
free (buttons.mask);
out:
return button;
}
gboolean
meta_window_x11_client_message (MetaWindow *window,
XEvent *event)
{
MetaDisplay *display;
display = window->display;
if (window->override_redirect)
{
/* Don't warn here: we could warn on any of the messages below,
* but we might also receive other client messages that are
* part of protocols we don't know anything about. So, silently
* ignoring is simplest.
*/
return FALSE;
}
if (event->xclient.message_type ==
display->atom__NET_CLOSE_WINDOW)
{
guint32 timestamp;
if (event->xclient.data.l[0] != 0)
timestamp = event->xclient.data.l[0];
else
{
meta_warning ("Receiving a NET_CLOSE_WINDOW message for %s without "
"a timestamp! This means some buggy (outdated) "
"application is on the loose!\n",
window->desc);
timestamp = meta_display_get_current_time (window->display);
}
meta_window_delete (window, timestamp);
return TRUE;
}
else if (event->xclient.message_type ==
display->atom__NET_WM_DESKTOP)
{
int space;
MetaWorkspace *workspace;
space = event->xclient.data.l[0];
meta_verbose ("Request to move %s to workspace %d\n",
window->desc, space);
workspace =
meta_screen_get_workspace_by_index (window->screen,
space);
if (workspace)
{
if (window->on_all_workspaces_requested)
meta_window_unstick (window);
meta_window_change_workspace (window, workspace);
}
else if (space == (int) 0xFFFFFFFF)
{
meta_window_stick (window);
}
else
{
meta_verbose ("No such workspace %d for screen\n", space);
}
meta_verbose ("Window %s now on_all_workspaces = %d\n",
window->desc, window->on_all_workspaces);
return TRUE;
}
else if (event->xclient.message_type ==
display->atom__NET_WM_STATE)
{
gulong action;
Atom first;
Atom second;
action = event->xclient.data.l[0];
first = event->xclient.data.l[1];
second = event->xclient.data.l[2];
if (meta_is_verbose ())
{
char *str1;
char *str2;
meta_error_trap_push_with_return (display);
str1 = XGetAtomName (display->xdisplay, first);
if (meta_error_trap_pop_with_return (display) != Success)
str1 = NULL;
meta_error_trap_push_with_return (display);
str2 = XGetAtomName (display->xdisplay, second);
if (meta_error_trap_pop_with_return (display) != Success)
str2 = NULL;
meta_verbose ("Request to change _NET_WM_STATE action %lu atom1: %s atom2: %s\n",
action,
str1 ? str1 : "(unknown)",
str2 ? str2 : "(unknown)");
meta_XFree (str1);
meta_XFree (str2);
}
if (first == display->atom__NET_WM_STATE_SHADED ||
second == display->atom__NET_WM_STATE_SHADED)
{
gboolean shade;
guint32 timestamp;
/* Stupid protocol has no timestamp; of course, shading
* sucks anyway so who really cares that we're forced to do
* a roundtrip here?
*/
timestamp = meta_display_get_current_time_roundtrip (window->display);
shade = (action == _NET_WM_STATE_ADD ||
(action == _NET_WM_STATE_TOGGLE && !window->shaded));
if (shade && window->has_shade_func)
meta_window_shade (window, timestamp);
else
meta_window_unshade (window, timestamp);
}
if (first == display->atom__NET_WM_STATE_FULLSCREEN ||
second == display->atom__NET_WM_STATE_FULLSCREEN)
{
gboolean make_fullscreen;
make_fullscreen = (action == _NET_WM_STATE_ADD ||
(action == _NET_WM_STATE_TOGGLE && !window->fullscreen));
if (make_fullscreen && window->has_fullscreen_func)
meta_window_make_fullscreen (window);
else
meta_window_unmake_fullscreen (window);
}
if (first == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
second == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
first == display->atom__NET_WM_STATE_MAXIMIZED_VERT ||
second == display->atom__NET_WM_STATE_MAXIMIZED_VERT)
{
gboolean max;
MetaMaximizeFlags directions = 0;
max = (action == _NET_WM_STATE_ADD ||
(action == _NET_WM_STATE_TOGGLE &&
!window->maximized_horizontally));
if (first == display->atom__NET_WM_STATE_MAXIMIZED_HORZ ||
second == display->atom__NET_WM_STATE_MAXIMIZED_HORZ)
directions |= META_MAXIMIZE_HORIZONTAL;
if (first == display->atom__NET_WM_STATE_MAXIMIZED_VERT ||
second == display->atom__NET_WM_STATE_MAXIMIZED_VERT)
directions |= META_MAXIMIZE_VERTICAL;
if (max && window->has_maximize_func)
{
if (meta_prefs_get_raise_on_click ())
meta_window_raise (window);
meta_window_maximize (window, directions);
}
else
{
if (meta_prefs_get_raise_on_click ())
meta_window_raise (window);
meta_window_unmaximize (window, directions);
}
}
if (first == display->atom__NET_WM_STATE_MODAL ||
second == display->atom__NET_WM_STATE_MODAL)
{
window->wm_state_modal =
(action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->wm_state_modal);
meta_window_recalc_window_type (window);
meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
}
if (first == display->atom__NET_WM_STATE_SKIP_PAGER ||
second == display->atom__NET_WM_STATE_SKIP_PAGER)
{
window->wm_state_skip_pager =
(action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->skip_pager);
meta_window_recalc_features (window);
meta_window_x11_set_net_wm_state (window);
}
if (first == display->atom__NET_WM_STATE_SKIP_TASKBAR ||
second == display->atom__NET_WM_STATE_SKIP_TASKBAR)
{
window->wm_state_skip_taskbar =
(action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->skip_taskbar);
meta_window_recalc_features (window);
meta_window_x11_set_net_wm_state (window);
}
if (first == display->atom__NET_WM_STATE_ABOVE ||
second == display->atom__NET_WM_STATE_ABOVE)
{
if ((action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->wm_state_demands_attention))
meta_window_make_above (window);
else
meta_window_unmake_above (window);
}
if (first == display->atom__NET_WM_STATE_BELOW ||
second == display->atom__NET_WM_STATE_BELOW)
{
window->wm_state_below =
(action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->wm_state_below);
meta_window_update_layer (window);
meta_window_x11_set_net_wm_state (window);
}
if (first == display->atom__NET_WM_STATE_DEMANDS_ATTENTION ||
second == display->atom__NET_WM_STATE_DEMANDS_ATTENTION)
{
if ((action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->wm_state_demands_attention))
meta_window_set_demands_attention (window);
else
meta_window_unset_demands_attention (window);
}
if (first == display->atom__NET_WM_STATE_STICKY ||
second == display->atom__NET_WM_STATE_STICKY)
{
if ((action == _NET_WM_STATE_ADD) ||
(action == _NET_WM_STATE_TOGGLE && !window->on_all_workspaces_requested))
meta_window_stick (window);
else
meta_window_unstick (window);
}
return TRUE;
}
else if (event->xclient.message_type ==
display->atom_WM_CHANGE_STATE)
{
meta_verbose ("WM_CHANGE_STATE client message, state: %ld\n",
event->xclient.data.l[0]);
if (event->xclient.data.l[0] == IconicState &&
window->has_minimize_func)
meta_window_minimize (window);
return TRUE;
}
else if (event->xclient.message_type ==
display->atom__NET_WM_MOVERESIZE)
{
int x_root;
int y_root;
int action;
MetaGrabOp op;
int button;
guint32 timestamp;
/* _NET_WM_MOVERESIZE messages are almost certainly going to come from
* clients when users click on the fake "frame" that the client has,
* thus we should also treat such messages as though it were a
* "frame action".
*/
gboolean const frame_action = TRUE;
x_root = event->xclient.data.l[0];
y_root = event->xclient.data.l[1];
action = event->xclient.data.l[2];
button = event->xclient.data.l[3];
/* FIXME: What a braindead protocol; no timestamp?!? */
timestamp = meta_display_get_current_time_roundtrip (display);
meta_topic (META_DEBUG_WINDOW_OPS,
"Received _NET_WM_MOVERESIZE message on %s, %d,%d action = %d, button %d\n",
window->desc,
x_root, y_root, action, button);
op = META_GRAB_OP_NONE;
switch (action)
{
case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
op = META_GRAB_OP_RESIZING_NW;
break;
case _NET_WM_MOVERESIZE_SIZE_TOP:
op = META_GRAB_OP_RESIZING_N;
break;
case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
op = META_GRAB_OP_RESIZING_NE;
break;
case _NET_WM_MOVERESIZE_SIZE_RIGHT:
op = META_GRAB_OP_RESIZING_E;
break;
case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
op = META_GRAB_OP_RESIZING_SE;
break;
case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
op = META_GRAB_OP_RESIZING_S;
break;
case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
op = META_GRAB_OP_RESIZING_SW;
break;
case _NET_WM_MOVERESIZE_SIZE_LEFT:
op = META_GRAB_OP_RESIZING_W;
break;
case _NET_WM_MOVERESIZE_MOVE:
op = META_GRAB_OP_MOVING;
break;
case _NET_WM_MOVERESIZE_SIZE_KEYBOARD:
op = META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN;
break;
case _NET_WM_MOVERESIZE_MOVE_KEYBOARD:
op = META_GRAB_OP_KEYBOARD_MOVING;
break;
case _NET_WM_MOVERESIZE_CANCEL:
/* handled below */
break;
default:
break;
}
if (action == _NET_WM_MOVERESIZE_CANCEL)
{
meta_display_end_grab_op (window->display, timestamp);
}
else if (op != META_GRAB_OP_NONE &&
((window->has_move_func && op == META_GRAB_OP_KEYBOARD_MOVING) ||
(window->has_resize_func && op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN)))
{
meta_window_begin_grab_op (window, op, frame_action, timestamp);
}
else if (op != META_GRAB_OP_NONE &&
((window->has_move_func && op == META_GRAB_OP_MOVING) ||
(window->has_resize_func &&
(op != META_GRAB_OP_MOVING &&
op != META_GRAB_OP_KEYBOARD_MOVING))))
{
int button_mask;
meta_topic (META_DEBUG_WINDOW_OPS,
"Beginning move/resize with button = %d\n", button);
meta_display_begin_grab_op (window->display,
window->screen,
window,
op,
FALSE,
frame_action,
button, 0,
timestamp,
x_root,
y_root);
button_mask = query_pressed_buttons (window);
if (button == 0)
{
/*
* the button SHOULD already be included in the message
*/
if ((button_mask & (1 << 1)) != 0)
button = 1;
else if ((button_mask & (1 << 2)) != 0)
button = 2;
else if ((button_mask & (1 << 3)) != 0)
button = 3;
if (button != 0)
window->display->grab_button = button;
else
meta_display_end_grab_op (window->display,
timestamp);
}
else
{
/* There is a potential race here. If the user presses and
* releases their mouse button very fast, it's possible for
* both the ButtonPress and ButtonRelease to be sent to the
* client before it can get a chance to send _NET_WM_MOVERESIZE
* to us. When that happens, we'll become stuck in a grab
* state, as we haven't received a ButtonRelease to cancel the
* grab.
*
* We can solve this by querying after we take the explicit
* pointer grab -- if the button isn't pressed, we cancel the
* drag immediately.
*/
if ((button_mask & (1 << button)) == 0)
meta_display_end_grab_op (window->display, timestamp);
}
}
return TRUE;
}
else if (event->xclient.message_type ==
display->atom__NET_MOVERESIZE_WINDOW)
{
int gravity;
guint value_mask;
gravity = (event->xclient.data.l[0] & 0xff);
value_mask = (event->xclient.data.l[0] & 0xf00) >> 8;
/* source = (event->xclient.data.l[0] & 0xf000) >> 12; */
if (gravity == 0)
gravity = window->size_hints.win_gravity;
meta_window_move_resize_request(window,
value_mask,
gravity,
event->xclient.data.l[1], /* x */
event->xclient.data.l[2], /* y */
event->xclient.data.l[3], /* width */
event->xclient.data.l[4]); /* height */
}
else if (event->xclient.message_type ==
display->atom__NET_ACTIVE_WINDOW)
{
MetaClientType source_indication;
guint32 timestamp;
meta_verbose ("_NET_ACTIVE_WINDOW request for window '%s', activating\n",
window->desc);
source_indication = event->xclient.data.l[0];
timestamp = event->xclient.data.l[1];
if (source_indication > META_CLIENT_TYPE_MAX_RECOGNIZED)
source_indication = META_CLIENT_TYPE_UNKNOWN;
if (timestamp == 0)
{
/* Client using older EWMH _NET_ACTIVE_WINDOW without a timestamp */
meta_warning ("Buggy client sent a _NET_ACTIVE_WINDOW message with a "
"timestamp of 0 for %s\n",
window->desc);
timestamp = meta_display_get_current_time (display);
}
meta_window_activate_full (window, timestamp, source_indication, NULL);
return TRUE;
}
else if (event->xclient.message_type ==
display->atom__NET_WM_FULLSCREEN_MONITORS)
{
gulong top, bottom, left, right;
meta_verbose ("_NET_WM_FULLSCREEN_MONITORS request for window '%s'\n",
window->desc);
top = meta_screen_xinerama_index_to_monitor_index (window->screen,
event->xclient.data.l[0]);
bottom = meta_screen_xinerama_index_to_monitor_index (window->screen,
event->xclient.data.l[1]);
left = meta_screen_xinerama_index_to_monitor_index (window->screen,
event->xclient.data.l[2]);
right = meta_screen_xinerama_index_to_monitor_index (window->screen,
event->xclient.data.l[3]);
/* source_indication = event->xclient.data.l[4]; */
meta_window_update_fullscreen_monitors (window, top, bottom, left, right);
}
return FALSE;
}