Newer
Older
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, or (at your option)
any later version.
Olivier Fourdan
committed
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.
Olivier Fourdan
committed
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., 675 Mass Ave, Cambridge, MA 02139, USA.
Olivier Fourdan
committed
xfwm4 - (c) 2002-2004 Olivier Fourdan
Olivier Fourdan
committed
#include <config.h>
#include <X11/Xatom.h>
#include <glib.h>
#include <gtk/gtk.h>
#ifdef HAVE_RANDR
#include <X11/extensions/Xrandr.h>
#endif
#include <libxfce4util/libxfce4util.h>
#include <libxfcegui4/libxfcegui4.h>
Olivier Fourdan
committed
#include "transients.h"
#include "focus.h"
#include "netwm.h"
#include "startup_notification.h"
#include "events.h"
Olivier Fourdan
committed
#define WIN_IS_BUTTON(win) ((win == MYWINDOW_XWINDOW(c->buttons[HIDE_BUTTON])) || \
(win == MYWINDOW_XWINDOW(c->buttons[CLOSE_BUTTON])) || \
(win == MYWINDOW_XWINDOW(c->buttons[MAXIMIZE_BUTTON])) || \
(win == MYWINDOW_XWINDOW(c->buttons[SHADE_BUTTON])) || \
(win == MYWINDOW_XWINDOW(c->buttons[STICK_BUTTON])))
#define DBL_CLICK_GRAB (ButtonMotionMask | \
PointerMotionMask | \
ButtonPressMask | \
ButtonReleaseMask)
#define MODIFIER_MASK (ShiftMask | \
ControlMask | \
AltMask | \
MetaMask | \
SuperMask | \
HyperMask)
extern gboolean xfwm4_quit;
extern gboolean xfwm4_reload;
static guint raise_timeout = 0;
static GdkAtom atom_rcfiles = GDK_NONE;
Olivier Fourdan
committed
static int edge_scroll_x = 0;
static void handleEvent (DisplayInfo *display_info, XEvent * ev);
static void menu_callback (Menu * menu, MenuOp op, Window client_xwindow,
gpointer menu_data, gpointer item_data);
static gboolean show_popup_cb (GtkWidget * widget, GdkEventButton * ev,
static gboolean client_event_cb (GtkWidget * widget, GdkEventClient * ev, gpointer data);
Olivier Fourdan
committed
XFWM_BUTTON_UNDEFINED = 0,
XFWM_BUTTON_DRAG = 1,
XFWM_BUTTON_CLICK = 2,
XFWM_BUTTON_CLICK_AND_DRAG = 3,
XFWM_BUTTON_DOUBLE_CLICK = 4
}
XfwmButtonClickType;
typeOfClick (DisplayInfo *display_info, Window w, XEvent * ev, gboolean allow_double_click)
Olivier Fourdan
committed
{
Olivier Fourdan
committed
int xcurrent, ycurrent, x, y, total;
Olivier Fourdan
committed
int g = GrabSuccess;
Olivier Fourdan
committed
int clicks;
Time t0;
Olivier Fourdan
committed
g_return_val_if_fail (display_info != NULL, XFWM_BUTTON_UNDEFINED);
g_return_val_if_fail (ev != NULL, XFWM_BUTTON_UNDEFINED);
g_return_val_if_fail (w != None, XFWM_BUTTON_UNDEFINED);
XFlush (display_info->dpy);
g = XGrabPointer (display_info->dpy, w, FALSE, DBL_CLICK_GRAB, GrabModeAsync,
GrabModeAsync, None, None, ev->xbutton.time);
if (g != GrabSuccess)
Olivier Fourdan
committed
{
TRACE ("grab failed in typeOfClick");
gdk_beep ();
return XFWM_BUTTON_UNDEFINED;
Olivier Fourdan
committed
}
Olivier Fourdan
committed
Olivier Fourdan
committed
x = xcurrent = ev->xbutton.x_root;
y = ycurrent = ev->xbutton.y_root;
t0 = GDK_CURRENT_TIME;
Olivier Fourdan
committed
total = 0;
clicks = 1;
Olivier Fourdan
committed
while ((ABS (x - xcurrent) < 2) && (ABS (y - ycurrent) < 2)
&& (total < display_info->dbl_click_time)
&& ((GDK_CURRENT_TIME - t0) < display_info->dbl_click_time))
{
g_usleep (10000);
total += 10;
if (XCheckMaskEvent (display_info->dpy, FocusChangeMask, ev))
if (XCheckMaskEvent (display_info->dpy, ButtonReleaseMask | ButtonPressMask, ev))
{
if (ev->xbutton.button == button)
{
clicks++;
}
}
if ((XfwmButtonClickType) clicks == XFWM_BUTTON_DOUBLE_CLICK
|| (!allow_double_click
&& (XfwmButtonClickType) clicks == XFWM_BUTTON_CLICK))
{
break;
}
if (XCheckMaskEvent (display_info->dpy, ButtonMotionMask | PointerMotionMask, ev))
{
xcurrent = ev->xmotion.x_root;
ycurrent = ev->xmotion.y_root;
}
XUngrabPointer (display_info->dpy, ev->xbutton.time);
XFlush (display_info->dpy);
Olivier Fourdan
committed
return (XfwmButtonClickType) clicks;
}
clear_timeout (void)
if (raise_timeout)
g_source_remove (raise_timeout);
raise_timeout = 0;
raise_cb (gpointer data)
Olivier Fourdan
committed
Client *c = NULL;
TRACE ("entering raise_cb");
clear_timeout ();
c = clientGetFocus ();
if (c)
if (raise_timeout)
g_source_remove (raise_timeout);
raise_timeout = g_timeout_add_full (0, screen_info->params->raise_delay, (GtkFunction) raise_cb, NULL, NULL);
moveRequest (Client * c, XEvent * ev)
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MOVE
&& !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)))
clientMove (c, ev);
resizeRequest (Client * c, int corner, XEvent * ev)
clientSetFocus (c->screen_info, c, GDK_CURRENT_TIME, NO_FOCUS_FLAG);
if (FLAG_TEST_ALL (c->xfwm_flags,
XFWM_FLAG_HAS_RESIZE | XFWM_FLAG_IS_RESIZABLE))
clientResize (c, corner, ev);
else if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MOVE
&& !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)))
clientMove (c, ev);
spawn_shortcut (ScreenInfo *screen_info, int i)
{
GError *error = NULL;
if ((i >= NB_KEY_SHORTCUTS) || (!screen_info->params->shortcut_exec[i])
|| !strlen (screen_info->params->shortcut_exec[i]))
if (!xfce_gdk_spawn_command_line_on_screen (screen_info->gscr, screen_info->params->shortcut_exec[i], &error))
if (error)
{
g_warning ("%s: %s", g_get_prgname (), error->message);
g_error_free (error);
}
handleMotionNotify (DisplayInfo *display_info, XMotionEvent * ev)
Olivier Fourdan
committed
{
int msx, msy, max;
TRACE ("entering handleMotionNotify");
if (display_info->nb_screens > 1)
{
/* Wrap workspace/wrap windows is disabled with multiscreen */
return;
}
/* Get the screen structure from the root of the event */
screen_info = myDisplayGetScreenFromRoot (display_info, ev->root);
if (!screen_info)
{
return;
}
if (screen_info->workspace_count && screen_info->params->wrap_workspaces
&& screen_info->params->wrap_resistance)
{
msx = ev->x_root;
msy = ev->y_root;
max = gdk_screen_get_width (screen_info->gscr) - 1;
if ((msx == 0) || (msx == max))
{
edge_scroll_x++;
}
else
{
edge_scroll_x = 0;
}
if (edge_scroll_x > screen_info->params->wrap_resistance)
{
edge_scroll_x = 0;
if (msx == 0)
{
XWarpPointer (display_info->dpy, None, screen_info->xroot, 0, 0, 0, 0, max - 10, msy);
workspaceSwitch (screen_info, screen_info->current_ws - 1, NULL);
}
else if (msx == max)
{
XWarpPointer (display_info->dpy, None, screen_info->xroot, 0, 0, 0, 0, 10, msy);
workspaceSwitch (screen_info, screen_info->current_ws + 1, NULL);
while (XCheckWindowEvent(display_info->dpy, ev->window, PointerMotionMask, (XEvent *) ev))
; /* Skip event */
Olivier Fourdan
committed
}
}
static int
getKeyPressed (ScreenInfo *screen_info, XKeyEvent * ev)
state = ev->state & MODIFIER_MASK;
for (key = 0; key < KEY_COUNT; key++)
{
if ((screen_info->params->keys[key].keycode == ev->keycode)
&& (screen_info->params->keys[key].modifier == state))
{
break;
}
static void
handleKeyPress (DisplayInfo *display_info, XKeyEvent * ev)
{
ScreenInfo *screen_info = NULL;
Client *c = NULL;
int key;
TRACE ("entering handleKeyEvent");
c = clientGetFocus ();
key = getKeyPressed (screen_info, ev);
switch (key)
{
case KEY_MOVE_UP:
case KEY_MOVE_DOWN:
case KEY_MOVE_LEFT:
case KEY_MOVE_RIGHT:
moveRequest (c, (XEvent *) ev);
break;
case KEY_RESIZE_UP:
case KEY_RESIZE_DOWN:
case KEY_RESIZE_LEFT:
case KEY_RESIZE_RIGHT:
if (FLAG_TEST_ALL (c->xfwm_flags,
XFWM_FLAG_HAS_RESIZE | XFWM_FLAG_IS_RESIZABLE))
{
clientResize (c, CORNER_BOTTOM_RIGHT, (XEvent *) ev);
}
break;
case KEY_CYCLE_WINDOWS:
clientCycle (c, (XEvent *) ev);
break;
case KEY_CLOSE_WINDOW:
clientClose (c);
break;
case KEY_HIDE_WINDOW:
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER) && CLIENT_CAN_HIDE_WINDOW (c))
{
clientHide (c, c->win_workspace, TRUE);
}
break;
case KEY_MAXIMIZE_WINDOW:
clientToggleMaximized (c, WIN_STATE_MAXIMIZED);
break;
case KEY_MAXIMIZE_VERT:
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_VERT);
break;
case KEY_MAXIMIZE_HORIZ:
clientToggleMaximized (c, WIN_STATE_MAXIMIZED_HORIZ);
break;
case KEY_SHADE_WINDOW:
clientToggleShaded (c);
break;
case KEY_STICK_WINDOW:
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER) && CLIENT_CAN_STICK_WINDOW(c))
{
clientToggleSticky (c, TRUE);
frameDraw (c, FALSE, FALSE);
Olivier Fourdan
committed
}
case KEY_TOGGLE_FULLSCREEN:
clientToggleFullscreen (c);
break;
case KEY_MOVE_NEXT_WORKSPACE:
workspaceSwitch (screen_info, screen_info->current_ws + 1, c);
break;
case KEY_MOVE_PREV_WORKSPACE:
workspaceSwitch (screen_info, screen_info->current_ws - 1, c);
Olivier Fourdan
committed
case KEY_MOVE_UP_WORKSPACE:
workspaceMove (screen_info, -1, 0, c);
break;
case KEY_MOVE_DOWN_WORKSPACE:
workspaceMove (screen_info, 1, 0, c);
break;
case KEY_MOVE_LEFT_WORKSPACE:
workspaceMove (screen_info, 0, -1, c);
break;
case KEY_MOVE_RIGHT_WORKSPACE:
workspaceMove (screen_info, 0, 1, c);
break;
case KEY_MOVE_WORKSPACE_1:
case KEY_MOVE_WORKSPACE_2:
case KEY_MOVE_WORKSPACE_3:
case KEY_MOVE_WORKSPACE_4:
case KEY_MOVE_WORKSPACE_5:
case KEY_MOVE_WORKSPACE_6:
case KEY_MOVE_WORKSPACE_7:
case KEY_MOVE_WORKSPACE_8:
case KEY_MOVE_WORKSPACE_9:
workspaceSwitch (screen_info, key - KEY_MOVE_WORKSPACE_1, c);
break;
default:
break;
}
Olivier Fourdan
committed
}
else
{
screen_info = myDisplayGetScreenFromRoot (display_info, ev->root);
if (!screen_info)
{
return;
}
key = getKeyPressed (screen_info, ev);
switch (key)
{
case KEY_CYCLE_WINDOWS:
clientCycle (screen_info->clients->prev, (XEvent *) ev);
}
break;
default:
break;
}
Olivier Fourdan
committed
}
/*
Here we know that "screen_info" is defined, otherwise, we would
already have returned...
*/
Olivier Fourdan
committed
switch (key)
{
case KEY_NEXT_WORKSPACE:
workspaceSwitch (screen_info, screen_info->current_ws + 1, NULL);
break;
case KEY_PREV_WORKSPACE:
workspaceSwitch (screen_info, screen_info->current_ws - 1, NULL);
Olivier Fourdan
committed
case KEY_UP_WORKSPACE:
workspaceMove(screen_info, -1, 0, NULL);
break;
case KEY_DOWN_WORKSPACE:
workspaceMove(screen_info, 1, 0, NULL);
break;
case KEY_LEFT_WORKSPACE:
workspaceMove(screen_info, 0, -1, NULL);
break;
case KEY_RIGHT_WORKSPACE:
workspaceMove(screen_info, 0, 1, NULL);
break;
case KEY_ADD_WORKSPACE:
workspaceSetCount (screen_info, screen_info->workspace_count + 1);
break;
case KEY_DEL_WORKSPACE:
workspaceSetCount (screen_info, screen_info->workspace_count - 1);
break;
case KEY_WORKSPACE_1:
case KEY_WORKSPACE_2:
case KEY_WORKSPACE_3:
case KEY_WORKSPACE_4:
case KEY_WORKSPACE_5:
case KEY_WORKSPACE_6:
case KEY_WORKSPACE_7:
case KEY_WORKSPACE_8:
case KEY_WORKSPACE_9:
workspaceSwitch (screen_info, key - KEY_WORKSPACE_1, NULL);
break;
case KEY_SHORTCUT_1:
case KEY_SHORTCUT_2:
case KEY_SHORTCUT_3:
case KEY_SHORTCUT_4:
case KEY_SHORTCUT_5:
case KEY_SHORTCUT_6:
case KEY_SHORTCUT_7:
case KEY_SHORTCUT_8:
case KEY_SHORTCUT_9:
case KEY_SHORTCUT_10:
spawn_shortcut (screen_info, key - KEY_SHORTCUT_1);
break;
default:
break;
/* User has clicked on an edge or corner.
* Button 1 : Raise and resize
* Button 2 : Move
* Button 3 : Resize
*/
edgeButton (Client * c, int part, XButtonEvent * ev)
if (ev->button == Button2)
XfwmButtonClickType tclick;
ScreenInfo *screen_info = c->screen_info;
DisplayInfo *display_info = screen_info->display_info;
Olivier Fourdan
committed
tclick = typeOfClick (display_info, c->frame, (XEvent *) ev, FALSE);
Olivier Fourdan
committed
if (tclick == XFWM_BUTTON_CLICK)
{
clientLower (c);
}
else
{
moveRequest (c, (XEvent *) ev);
}
if (ev->button == Button1)
{
clientRaise (c);
}
if ((ev->button == Button1) || (ev->button == Button3))
{
resizeRequest (c, part, (XEvent *) ev);
}
button1Action (Client * c, XButtonEvent * ev)
ScreenInfo *screen_info = NULL;
DisplayInfo *display_info = NULL;
XfwmButtonClickType tclick;
g_return_if_fail (c != NULL);
g_return_if_fail (ev != NULL);
screen_info = c->screen_info;
display_info = screen_info->display_info;
clientSetFocus (screen_info, c, ev->time, NO_FOCUS_FLAG);
clientRaise (c);
tclick = typeOfClick (display_info, c->frame, ©_event, TRUE);
if ((tclick == XFWM_BUTTON_DRAG)
|| (tclick == XFWM_BUTTON_CLICK_AND_DRAG))
moveRequest (c, (XEvent *) ev);
else if (tclick == XFWM_BUTTON_DOUBLE_CLICK)
switch (screen_info->params->double_click_action)
{
case ACTION_MAXIMIZE:
clientToggleMaximized (c, WIN_STATE_MAXIMIZED);
break;
case ACTION_SHADE:
clientToggleShaded (c);
break;
case ACTION_HIDE:
if (CLIENT_CAN_HIDE_WINDOW (c))
{
clientHide (c, c->win_workspace, TRUE);
}
titleButton (Client * c, int state, XButtonEvent * ev)
ScreenInfo *screen_info = NULL;
DisplayInfo *display_info = NULL;
g_return_if_fail (c != NULL);
g_return_if_fail (ev != NULL);
/* Get Screen data from the client itself */
screen_info = c->screen_info;
display_info = screen_info->display_info;
if (ev->button == Button1)
{
button1Action (c, ev);
}
else if (ev->button == Button2)
{
}
else if (ev->button == Button3)
{
/*
We need to copy the event to keep the original event untouched
for gtk to handle it (in case we open up the menu)
*/
XfwmButtonClickType tclick;
memcpy(©_event, ev, sizeof(XEvent));
tclick = typeOfClick (display_info, c->frame, ©_event, FALSE);
if (tclick == XFWM_BUTTON_DRAG)
{
moveRequest (c, (XEvent *) ev);
}
else
{
clientSetFocus (screen_info, c, ev->time, NO_FOCUS_FLAG);
if (screen_info->params->raise_on_click)
{
clientRaise (c);
}
ev->window = ev->root;
g_signal_handler_disconnect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)), screen_info->button_handler_id);
screen_info->button_handler_id = g_signal_connect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)),
"button_press_event", GTK_SIGNAL_FUNC (show_popup_cb), (gpointer) c);
/* Let GTK handle this for us. */
}
}
else if (ev->button == Button4)
{
/* Mouse wheel scroll up */
if (!FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
{
clientShade (c);
}
else if (ev->button == Button5)
/* Mouse wheel scroll down */
if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
{
clientUnshade (c);
}
rootScrollButton (DisplayInfo *display_info, XButtonEvent * ev)
{
static Time lastscroll = (Time) 0;
if ((ev->time - lastscroll) < 100) /* ms */
/* Too many events in too little time, drop this event... */
return;
}
lastscroll = ev->time;
/* Get the screen structure from the root of the event */
screen_info = myDisplayGetScreenFromRoot (display_info, ev->root);
if (!screen_info)
{
return;
}
if (ev->button == Button4)
{
workspaceSwitch (screen_info, screen_info->current_ws - 1, NULL);
}
else if (ev->button == Button5)
{
workspaceSwitch (screen_info, screen_info->current_ws + 1, NULL);
}
}
handleButtonPress (DisplayInfo *display_info, XButtonEvent * ev)
Olivier Fourdan
committed
Client *c = NULL;
int state, replay = FALSE;
TRACE ("entering handleButtonPress");
clear_timeout ();
c = myDisplayGetClientFromWindow (display_info, ev->window, ANY);
state = ev->state & MODIFIER_MASK;
win = ev->subwindow;
if ((ev->button == Button1) && (state == AltMask) && (screen_info->params->easy_click))
{
button1Action (c, ev);
}
else if ((ev->button == Button2) && (state == AltMask) && (screen_info->params->easy_click))
else if ((ev->button == Button3) && (state == AltMask) && (screen_info->params->easy_click))
if ((ev->x < c->width / 2) && (ev->y < c->height / 2))
{
edgeButton (c, CORNER_TOP_LEFT, ev);
}
else if ((ev->x < c->width / 2) && (ev->y > c->height / 2))
{
edgeButton (c, CORNER_BOTTOM_LEFT, ev);
}
else if ((ev->x > c->width / 2) && (ev->y < c->height / 2))
{
edgeButton (c, CORNER_TOP_RIGHT, ev);
}
else
{
edgeButton (c, CORNER_BOTTOM_RIGHT, ev);
}
}
else if (WIN_IS_BUTTON (win))
{
if (ev->button <= Button3)
{
clientSetFocus (screen_info, c, ev->time, NO_FOCUS_FLAG);
if (screen_info->params->raise_on_click)
{
clientRaise (c);
}
clientButtonPress (c, win, ev);
}
}
else if (win == MYWINDOW_XWINDOW (c->title))
{
titleButton (c, state, ev);
}
else if (win == MYWINDOW_XWINDOW (c->buttons[MENU_BUTTON]))
{
if (ev->button == Button1)
{
/*
We need to copy the event to keep the original event untouched
for gtk to handle it (in case we open up the menu)
*/
XfwmButtonClickType tclick;
tclick = typeOfClick (display_info, c->frame, ©_event, TRUE);
if (tclick == XFWM_BUTTON_DOUBLE_CLICK)
{
clientClose (c);
}
else
{
clientSetFocus (screen_info, c, ev->time, NO_FOCUS_FLAG);
if (screen_info->params->raise_on_click)
{
clientRaise (c);
}
ev->window = ev->root;
g_signal_handler_disconnect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)), screen_info->button_handler_id);
screen_info->button_handler_id = g_signal_connect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)),
"button_press_event", GTK_SIGNAL_FUNC (show_popup_cb), (gpointer) c);
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
/* Let GTK handle this for us. */
}
}
}
else if ((win == MYWINDOW_XWINDOW (c->corners[CORNER_TOP_LEFT]))
&& (state == 0))
{
edgeButton (c, CORNER_TOP_LEFT, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->corners[CORNER_TOP_RIGHT]))
&& (state == 0))
{
edgeButton (c, CORNER_TOP_RIGHT, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_LEFT]))
&& (state == 0))
{
edgeButton (c, CORNER_BOTTOM_LEFT, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->corners[CORNER_BOTTOM_RIGHT]))
&& (state == 0))
{
edgeButton (c, CORNER_BOTTOM_RIGHT, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->sides[SIDE_BOTTOM]))
&& (state == 0))
{
edgeButton (c, 4 + SIDE_BOTTOM, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->sides[SIDE_LEFT]))
&& (state == 0))
{
edgeButton (c, 4 + SIDE_LEFT, ev);
}
else if ((win == MYWINDOW_XWINDOW (c->sides[SIDE_RIGHT]))
&& (state == 0))
{
edgeButton (c, 4 + SIDE_RIGHT, ev);
}
else
{
if (ev->button == Button1)
{
Olivier Fourdan
committed
if (ev->window == c->window)
{
Olivier Fourdan
committed
}
clientSetFocus (screen_info, c, ev->time, NO_FOCUS_FLAG);
if ((screen_info->params->raise_on_click)
|| !FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER))
{
clientRaise (c);
}
}
if (ev->window == c->window)
{
replay = TRUE;
}
}
if (replay)
{
XAllowEvents (display_info->dpy, ReplayPointer, ev->time);
XAllowEvents (display_info->dpy, SyncPointer, ev->time);
return;
}
/*
The event did not occur in one of our known good client...
Get the screen structure from the root of the event.
*/
screen_info = myDisplayGetScreenFromRoot (display_info, ev->root);
if (!screen_info)
{
return;
if ((ev->window == screen_info->xroot) && (screen_info->params->scroll_workspaces)
&& ((ev->button == Button4) || (ev->button == Button5)))
Olivier Fourdan
committed
}
XUngrabPointer (display_info->dpy, GDK_CURRENT_TIME);
XSendEvent (display_info->dpy, screen_info->gnome_win, FALSE, SubstructureNotifyMask, (XEvent *) ev);
handleButtonRelease (DisplayInfo *display_info, XButtonEvent * ev)
TRACE ("entering handleButtonRelease");
/* Get the screen structure from the root of the event */
screen_info = myDisplayGetScreenFromRoot (display_info, ev->root);
if (!screen_info)
{
return;
}
XSendEvent (display_info->dpy, screen_info->gnome_win, FALSE, SubstructureNotifyMask, (XEvent *) ev);
handleDestroyNotify (DisplayInfo *display_info, XDestroyWindowEvent * ev)
Olivier Fourdan
committed
Client *c = NULL;
TRACE ("entering handleDestroyNotify");
TRACE ("DestroyNotify on window (0x%lx)", ev->window);
screen_info = myDisplayGetScreenFromSystray (display_info, ev->window);
if (screen_info)
/* systray window is gone */
screen_info->systray = None;
c = myDisplayGetClientFromWindow (display_info, ev->window, WINDOW);
TRACE ("DestroyNotify for \"%s\" (0x%lx)", c->name, c->window);
clientUnframe (c, FALSE);
}
}
handleMapRequest (DisplayInfo *display_info, XMapRequestEvent * ev)
Olivier Fourdan
committed
Client *c = NULL;
TRACE ("entering handleMapRequest");
TRACE ("MapRequest on window (0x%lx)", ev->window);
if (ev->window == None)
TRACE ("Mapping None ???");
return;
c = myDisplayGetClientFromWindow (display_info, ev->window, WINDOW);
ScreenInfo *screen_info = c->screen_info;
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MAP_PENDING))
{
TRACE ("Ignoring MapRequest on window (0x%lx)", ev->window);
return;
}
clientShow (c, TRUE);
if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY) ||
(c->win_workspace == screen_info->current_ws))
clientFrame (display_info, ev->window, FALSE);
handleMapNotify (DisplayInfo *display_info, XMapEvent * ev)
Olivier Fourdan
committed
Client *c = NULL;
TRACE ("MapNotify on window (0x%lx)", ev->window);
c = myDisplayGetClientFromWindow (display_info, ev->window, WINDOW);
if (c)
{
TRACE ("MapNotify for \"%s\" (0x%lx)", c->name, c->window);
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MAP_PENDING))
FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_MAP_PENDING);
handleUnmapNotify (DisplayInfo *display_info, XUnmapEvent * ev)
Client *c = NULL;
TRACE ("entering handleUnmapNotify");
TRACE ("UnmapNotify on window (0x%lx)", ev->window);