Newer
Older
Olivier Fourdan
committed
TRACE ("root has received a GNOME_PANEL_DESKTOP_AREA notify");
getGnomeDesktopMargins (display_info, screen_info->xroot, screen_info->gnome_margins);
else if (ev->atom == display_info->atoms[NET_DESKTOP_LAYOUT])
Olivier Fourdan
committed
{
Olivier Fourdan
committed
TRACE ("root has received a NET_DESKTOP_LAYOUT notify");
getDesktopLayout(display_info, screen_info->xroot, screen_info->workspace_count, &screen_info->desktop_layout);
Olivier Fourdan
committed
placeSidewalks(screen_info, screen_info->params->wrap_workspaces);
Olivier Fourdan
committed
}
return status;
static eventFilterStatus
handleClientMessage (DisplayInfo *display_info, XClientMessageEvent * ev)
eventFilterStatus status;
ScreenInfo *screen_info;
Client *c;
gboolean is_transient;
TRACE ("entering handleClientMessage");
status = EVENT_FILTER_PASS;
c = myDisplayGetClientFromWindow (display_info, ev->window, SEARCH_WINDOW);
if (c)
{
status = EVENT_FILTER_REMOVE;
if ((ev->message_type == display_info->atoms[WM_CHANGE_STATE]) && (ev->format == 32) && (ev->data.l[0] == IconicState))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a WM_CHANGE_STATE event", c->name, c->window);
Olivier Fourdan
committed
if (!FLAG_TEST (c->flags, CLIENT_FLAG_ICONIFIED))
{
clientHide (c, c->win_workspace, TRUE);
}
}
else if ((ev->message_type == display_info->atoms[WIN_STATE]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a WIN_STATE event", c->name, c->window);
clientUpdateWinState (c, ev);
}
else if ((ev->message_type == display_info->atoms[WIN_LAYER]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a WIN_LAYER event", c->name, c->window);
if ((ev->data.l[0] != c->win_layer) && !is_transient)
{
clientSetLayer (c, ev->data.l[0]);
}
}
else if ((ev->message_type == display_info->atoms[WIN_WORKSPACE]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a WIN_WORKSPACE event", c->name, c->window);
if ((ev->data.l[0] != c->win_workspace) && !is_transient)
{
clientSetWorkspace (c, ev->data.l[0], TRUE);
}
}
else if ((ev->message_type == display_info->atoms[NET_WM_DESKTOP]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_WM_DESKTOP event", c->name, c->window);
{
if (ev->data.l[0] == ALL_WORKSPACES)
{
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_STICK) && !FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
{
clientStick (c, TRUE);
}
}
else
{
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_STICK) && FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
{
clientUnstick (c, TRUE);
}
if (ev->data.l[0] != c->win_workspace)
{
clientSetWorkspace (c, ev->data.l[0], TRUE);
}
}
}
}
else if ((ev->message_type == display_info->atoms[NET_CLOSE_WINDOW]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_CLOSE_WINDOW event", c->name, c->window);
clientClose (c);
}
else if ((ev->message_type == display_info->atoms[NET_WM_STATE]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_WM_STATE event", c->name, c->window);
clientUpdateNetState (c, ev);
}
else if ((ev->message_type == display_info->atoms[NET_WM_MOVERESIZE]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_WM_MOVERESIZE event", c->name, c->window);
else if ((ev->message_type == display_info->atoms[NET_ACTIVE_WINDOW]) && (ev->format == 32))
Olivier Fourdan
committed
gboolean source_is_application;
Time ev_time;
ev_time = myDisplayGetTime (display_info, (Time) ev->data.l[1]);
source_is_application = (ev->data.l[0] == 1);
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_ACTIVE_WINDOW event", c->name, c->window);
Olivier Fourdan
committed
if (source_is_application)
Olivier Fourdan
committed
Time current = myDisplayGetLastUserTime (display_info);
TRACE ("Time of event received is %u, current XServer time is %u", (unsigned int) ev_time, (unsigned int) current);
Olivier Fourdan
committed
if ((screen_info->params->prevent_focus_stealing) && TIMESTAMP_IS_BEFORE(ev_time, current))
TRACE ("Setting WM_STATE_DEMANDS_ATTENTION flag on \"%s\" (0x%lx)", c->name, c->window);
FLAG_SET (c->flags, CLIENT_FLAG_DEMANDS_ATTENTION);
clientSetNetState (c);
}
else
{
Olivier Fourdan
committed
clientActivate (c, ev_time);
Olivier Fourdan
committed
/* The request is either from a pager or an older client, use the most accurate timestamp */
Olivier Fourdan
committed
clientActivate (c, getXServerTime (display_info));
else if (ev->message_type == display_info->atoms[NET_REQUEST_FRAME_EXTENTS])
Olivier Fourdan
committed
{
Olivier Fourdan
committed
TRACE ("client \"%s\" (0x%lx) has received a NET_REQUEST_FRAME_EXTENTS event", c->name, c->window);
setNetFrameExtents (display_info, c->window, frameTop (c), frameLeft (c),
frameRight (c), frameBottom (c));
Olivier Fourdan
committed
}
screen_info = myDisplayGetScreenFromWindow (display_info, ev->window);
if (!screen_info)
{
return status;
status = EVENT_FILTER_REMOVE;
if (((ev->message_type == display_info->atoms[WIN_WORKSPACE]) ||
(ev->message_type == display_info->atoms[NET_CURRENT_DESKTOP])) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("root has received a win_workspace or a NET_CURRENT_DESKTOP event %li", ev->data.l[0]);
if ((ev->data.l[0] >= 0) && (ev->data.l[0] < screen_info->workspace_count) &&
Olivier Fourdan
committed
(ev->data.l[0] != screen_info->current_ws))
workspaceSwitch (screen_info, ev->data.l[0], NULL, TRUE,
Olivier Fourdan
committed
myDisplayGetTime (display_info, (Time) ev->data.l[1]));
else if (((ev->message_type == display_info->atoms[WIN_WORKSPACE_COUNT]) ||
(ev->message_type == display_info->atoms[NET_NUMBER_OF_DESKTOPS])) && (ev->format == 32))
{
TRACE ("root has received a win_workspace_count event");
if (ev->data.l[0] != screen_info->workspace_count)
workspaceSetCount (screen_info, ev->data.l[0]);
getDesktopLayout(display_info, screen_info->xroot, screen_info->workspace_count, &screen_info->desktop_layout);
else if ((ev->message_type == display_info->atoms[NET_SHOWING_DESKTOP]) && (ev->format == 32))
Olivier Fourdan
committed
TRACE ("root has received a NET_SHOWING_DESKTOP event");
Olivier Fourdan
committed
screen_info->show_desktop = (ev->data.l[0] != 0);
clientToggleShowDesktop (screen_info);
setHint (display_info, screen_info->xroot, NET_SHOWING_DESKTOP, ev->data.l[0]);
else if (ev->message_type == display_info->atoms[NET_REQUEST_FRAME_EXTENTS])
Olivier Fourdan
committed
{
Olivier Fourdan
committed
TRACE ("window (0x%lx) has received a NET_REQUEST_FRAME_EXTENTS event", ev->window);
Olivier Fourdan
committed
/* Size estimate from the decoration extents */
setNetFrameExtents (display_info, ev->window,
Olivier Fourdan
committed
frameDecorationTop (screen_info),
frameDecorationLeft (screen_info),
frameDecorationRight (screen_info),
frameDecorationBottom (screen_info));
}
Olivier Fourdan
committed
else if ((ev->message_type == display_info->atoms[MANAGER]) && (ev->format == 32))
Olivier Fourdan
committed
{
Olivier Fourdan
committed
Atom selection;
Olivier Fourdan
committed
TRACE ("window (0x%lx) has received a MANAGER event", ev->window);
selection = (Atom) ev->data.l[1];
Olivier Fourdan
committed
#ifdef ENABLE_KDE_SYSTRAY_PROXY
if (selection == screen_info->net_system_tray_selection)
{
TRACE ("root has received a NET_SYSTEM_TRAY_MANAGER selection event");
screen_info->systray = getSystrayWindow (display_info, screen_info->net_system_tray_selection);
}
else
#endif
if (myScreenCheckWMAtom (screen_info, selection))
{
TRACE ("root has received a WM_Sn selection event");
display_info->quit = TRUE;
}
Olivier Fourdan
committed
}
else if (ev->message_type == display_info->atoms[WM_PROTOCOLS])
{
if (ev->data.l[0] == display_info->atoms[NET_WM_PING])
{
TRACE ("root has received a NET_WM_PING (pong) event\n");
clientReceiveNetWMPong (screen_info, (Time) ev->data.l[1]);
}
}
TRACE ("unidentified client message for window 0x%lx", ev->window);
return status;
Olivier Fourdan
committed
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
static eventFilterStatus
handleSelectionClear (DisplayInfo *display_info, XSelectionClearEvent * ev)
{
eventFilterStatus status;
ScreenInfo *screen_info;
TRACE ("entering handleSelectionClear");
status = EVENT_FILTER_PASS;
screen_info = myDisplayGetScreenFromWindow (display_info, ev->window);
if (screen_info)
{
if (myScreenCheckWMAtom (screen_info, ev->selection))
{
TRACE ("root has received a WM_Sn selection event");
display_info->quit = TRUE;
status = EVENT_FILTER_REMOVE;
}
}
return status;
}
static eventFilterStatus
handleShape (DisplayInfo *display_info, XShapeEvent * ev)
Olivier Fourdan
committed
gboolean update;
TRACE ("entering handleShape");
c = myDisplayGetClientFromWindow (display_info, ev->window, SEARCH_WINDOW);
Olivier Fourdan
committed
update = FALSE;
if (ev->kind == ShapeBounding)
{
if ((ev->shaped) && !FLAG_TEST (c->flags, CLIENT_FLAG_HAS_SHAPE))
{
FLAG_SET (c->flags, CLIENT_FLAG_HAS_SHAPE);
Olivier Fourdan
committed
clientGetMWMHints (c, TRUE);
update = TRUE;
}
else if (!(ev->shaped) && FLAG_TEST (c->flags, CLIENT_FLAG_HAS_SHAPE))
{
FLAG_UNSET (c->flags, CLIENT_FLAG_HAS_SHAPE);
Olivier Fourdan
committed
clientGetMWMHints (c, TRUE);
update = TRUE;
Olivier Fourdan
committed
if (!update)
{
Olivier Fourdan
committed
}
return EVENT_FILTER_REMOVE;
static eventFilterStatus
handleColormapNotify (DisplayInfo *display_info, XColormapEvent * ev)
Olivier Fourdan
committed
TRACE ("entering handleColormapNotify");
Olivier Fourdan
committed
c = myDisplayGetClientFromWindow (display_info, ev->window, SEARCH_WINDOW);
if ((c) && (ev->window == c->window) && (ev->new))
if (c == clientGetFocus ())
{
clientInstallColormaps (c);
}
return EVENT_FILTER_REMOVE;
return EVENT_FILTER_PASS;
static eventFilterStatus
handleMappingNotify (DisplayInfo *display_info, XMappingEvent * ev)
{
TRACE ("entering handleMappingNotify");
/* Refreshes the stored modifier and keymap information */
XRefreshKeyboardMapping (ev);
/* Update internal modifiers masks if necessary */
if (ev->request == MappingModifier)
{
TRACE ("handleMappingNotify: modifiers mapping has changed");
initModifiers (display_info->dpy);
}
/* Regrab all keys if the notify is for keyboard (ie not pointer) */
if (ev->request != MappingPointer)
{
TRACE ("handleMappingNotify: Reload settings");
reloadSettings (display_info, UPDATE_BUTTON_GRABS);
return EVENT_FILTER_PASS;
static eventFilterStatus
handleXSyncAlarmNotify (DisplayInfo *display_info, XSyncAlarmNotifyEvent * ev)
{
Client *c;
TRACE ("entering handleXSyncAlarmNotify");
Olivier Fourdan
committed
if (!display_info->have_xsync)
{
return EVENT_FILTER_REMOVE;
Olivier Fourdan
committed
}
c = myDisplayGetClientFromXSyncAlarm (display_info, ev->alarm);
if (c)
{
c->xsync_waiting = FALSE;
c->xsync_value = ev->counter_value;
Olivier Fourdan
committed
clientXSyncClearTimeout (c);
return EVENT_FILTER_REMOVE;
static eventFilterStatus
handleEvent (DisplayInfo *display_info, XEvent * ev)
eventFilterStatus status;
status = EVENT_FILTER_PASS;
TRACE ("entering handleEvent");
myDisplayUpdateCurrentTime (display_info, ev);
sn_process_event (ev);
case MotionNotify:
status = handleMotionNotify (display_info, (XMotionEvent *) ev);
break;
case KeyPress:
status = handleKeyPress (display_info, (XKeyEvent *) ev);
Olivier Fourdan
committed
break;
case KeyRelease:
status = handleKeyRelease (display_info, (XKeyEvent *) ev);
break;
case ButtonPress:
status = handleButtonPress (display_info, (XButtonEvent *) ev);
break;
case ButtonRelease:
status = handleButtonRelease (display_info, (XButtonEvent *) ev);
break;
case DestroyNotify:
status = handleDestroyNotify (display_info, (XDestroyWindowEvent *) ev);
break;
case UnmapNotify:
status = handleUnmapNotify (display_info, (XUnmapEvent *) ev);
break;
case MapRequest:
status = handleMapRequest (display_info, (XMapRequestEvent *) ev);
status = handleMapNotify (display_info, (XMapEvent *) ev);
status = handleConfigureNotify (display_info, (XConfigureEvent *) ev);
case ConfigureRequest:
status = handleConfigureRequest (display_info, (XConfigureRequestEvent *) ev);
break;
case EnterNotify:
status = handleEnterNotify (display_info, (XCrossingEvent *) ev);
break;
case LeaveNotify:
status = handleLeaveNotify (display_info, (XCrossingEvent *) ev);
break;
case FocusIn:
status = handleFocusIn (display_info, (XFocusChangeEvent *) ev);
break;
case FocusOut:
status = handleFocusOut (display_info, (XFocusChangeEvent *) ev);
break;
case PropertyNotify:
status = handlePropertyNotify (display_info, (XPropertyEvent *) ev);
break;
case ClientMessage:
status = handleClientMessage (display_info, (XClientMessageEvent *) ev);
Olivier Fourdan
committed
case SelectionClear:
status = handleSelectionClear (display_info, (XSelectionClearEvent *) ev);
break;
case ColormapNotify:
handleColormapNotify (display_info, (XColormapEvent *) ev);
status = handleMappingNotify (display_info, (XMappingEvent *) ev);
if ((display_info->have_shape) && (ev->type == display_info->shape_event_base))
status = handleShape (display_info, (XShapeEvent *) ev);
#ifdef HAVE_XSYNC
if ((display_info->have_xsync) && (ev->type == (display_info->xsync_event_base + XSyncAlarmNotify)))
{
status = handleXSyncAlarmNotify (display_info, (XSyncAlarmNotifyEvent *) ev);
if (!gdk_events_pending () && !XPending (display_info->dpy))
Olivier Fourdan
committed
if (display_info->reload)
Olivier Fourdan
committed
display_info->reload = FALSE;
Olivier Fourdan
committed
else if (display_info->quit)
{
gtk_main_quit ();
}
Olivier Fourdan
committed
compositorHandleEvent (display_info, ev);
return status;
xfwm4_event_filter (XEvent * xevent, gpointer data)
eventFilterStatus status;
DisplayInfo *display_info;
display_info = (DisplayInfo *) data;
TRACE ("entering xfwm4_event_filter");
status = handleEvent (display_info, xevent);
TRACE ("leaving xfwm4_event_filter");
return EVENT_FILTER_STOP | status;
/* GTK specific stuff */
menu_callback (Menu * menu, MenuOp op, Window xid, gpointer menu_data, gpointer item_data)
Olivier Fourdan
committed
TRACE ("entering menu_callback");
if ((menu_data != NULL) && (xid != None))
ScreenInfo *screen_info = (ScreenInfo *) menu_data;
c = myScreenGetClientFromWindow (screen_info, xid, SEARCH_WINDOW);
}
if (c)
{
c->button_status[MENU_BUTTON] = BUTTON_STATE_NORMAL;
switch (op)
case MENU_OP_QUIT:
gtk_main_quit ();
break;
case MENU_OP_MAXIMIZE:
case MENU_OP_UNMAXIMIZE:
if (CLIENT_CAN_MAXIMIZE_WINDOW (c))
{
clientToggleMaximized (c, WIN_STATE_MAXIMIZED, TRUE);
}
break;
case MENU_OP_MINIMIZE:
if (CLIENT_CAN_HIDE_WINDOW (c))
{
clientHide (c, c->win_workspace, TRUE);
}
break;
Olivier Fourdan
committed
case MENU_OP_MOVE:
clientMove (c, NULL);
break;
case MENU_OP_RESIZE:
clientResize (c, CORNER_BOTTOM_RIGHT, NULL);
break;
case MENU_OP_MINIMIZE_ALL:
clientHideAll (c, c->win_workspace);
break;
case MENU_OP_UNMINIMIZE:
clientShow (c, TRUE);
Olivier Fourdan
committed
clientClearAllShowDesktop (c->screen_info);
break;
case MENU_OP_SHADE:
case MENU_OP_UNSHADE:
clientToggleShaded (c);
break;
case MENU_OP_STICK:
case MENU_OP_UNSTICK:
clientToggleSticky (c, TRUE);
break;
case MENU_OP_WORKSPACES:
clientSetWorkspace (c, GPOINTER_TO_INT (item_data), TRUE);
break;
case MENU_OP_DELETE:
clientClose (c);
break;
case MENU_OP_CONTEXT_HELP:
clientEnterContextMenuState (c);
break;
case MENU_OP_ABOVE:
Olivier Fourdan
committed
clientToggleLayerAbove (c);
break;
case MENU_OP_NORMAL:
Olivier Fourdan
committed
clientSetLayerNormal (c);
break;
case MENU_OP_BELOW:
clientToggleLayerBelow (c);
break;
case MENU_OP_FULLSCREEN:
case MENU_OP_UNFULLSCREEN:
clientToggleFullscreen (c);
break;
default:
break;
else
gdk_beep ();
}
menu_free (menu);
void
initMenuEventWin (void)
{
}
Olivier Fourdan
committed
static void
show_window_menu (Client *c, gint px, gint py, guint button, guint32 time)
ScreenInfo *screen_info;
DisplayInfo *display_info;
Olivier Fourdan
committed
Menu *menu;
MenuOp ops;
MenuOp insensitive;
Olivier Fourdan
committed
gint x, y;
Olivier Fourdan
committed
TRACE ("entering show_window_menu");
Olivier Fourdan
committed
if ((button != Button1) && (button != Button3))
{
return;
}
if (!c || !FLAG_TEST_ALL (c->xfwm_flags, XFWM_FLAG_HAS_BORDER | XFWM_FLAG_VISIBLE))
Olivier Fourdan
committed
return;
}
Olivier Fourdan
committed
screen_info = c->screen_info;
display_info = screen_info->display_info;
Olivier Fourdan
committed
x = px;
y = py;
c->button_status[MENU_BUTTON] = BUTTON_STATE_PRESSED;
Olivier Fourdan
committed
y = (gdouble) c->y;
Olivier Fourdan
committed
ops = MENU_OP_DELETE | MENU_OP_MINIMIZE_ALL | MENU_OP_WORKSPACES | MENU_OP_MOVE | MENU_OP_RESIZE;
Olivier Fourdan
committed
insensitive = 0;
Olivier Fourdan
committed
if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
{
ops |= MENU_OP_UNMAXIMIZE;
}
else
{
ops |= MENU_OP_MAXIMIZE;
}
Olivier Fourdan
committed
if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MOVE))
{
insensitive |= MENU_OP_MOVE;
}
Olivier Fourdan
committed
if (FLAG_TEST (c->flags, CLIENT_FLAG_ICONIFIED))
{
ops |= MENU_OP_UNMINIMIZE;
}
else
{
ops |= MENU_OP_MINIMIZE;
}
Olivier Fourdan
committed
if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
{
ops |= MENU_OP_UNSHADE;
}
else
{
ops |= MENU_OP_SHADE;
}
Olivier Fourdan
committed
if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
{
ops |= MENU_OP_UNSTICK;
}
else
{
ops |= MENU_OP_STICK;
}
Olivier Fourdan
committed
if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_CLOSE))
Olivier Fourdan
committed
{
Olivier Fourdan
committed
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
insensitive |= MENU_OP_DELETE;
}
if (!CLIENT_CAN_STICK_WINDOW(c))
{
insensitive |= MENU_OP_STICK | MENU_OP_UNSTICK;
}
if (!CLIENT_CAN_HIDE_WINDOW (c))
{
insensitive |= MENU_OP_MINIMIZE;
}
if (!CLIENT_CAN_MAXIMIZE_WINDOW (c))
{
insensitive |= MENU_OP_MAXIMIZE;
}
if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MOVE))
{
insensitive |= MENU_OP_MOVE;
}
if (!FLAG_TEST_ALL (c->xfwm_flags, XFWM_FLAG_HAS_RESIZE | XFWM_FLAG_IS_RESIZABLE) ||
FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED))
{
insensitive |= MENU_OP_RESIZE;
}
if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
{
insensitive |= MENU_OP_SHADE | MENU_OP_MOVE | MENU_OP_RESIZE | MENU_OP_MAXIMIZE | MENU_OP_UNMAXIMIZE;
}
if (FLAG_TEST(c->flags, CLIENT_FLAG_FULLSCREEN))
{
ops |= MENU_OP_UNFULLSCREEN;
}
else
{
ops |= MENU_OP_FULLSCREEN;
}
if (clientIsTransientOrModal (c) || (c->type != WINDOW_NORMAL))
{
insensitive |= MENU_OP_FULLSCREEN | MENU_OP_UNFULLSCREEN;
Olivier Fourdan
committed
}
Olivier Fourdan
committed
if (FLAG_TEST(c->flags, CLIENT_FLAG_ABOVE))
{
Olivier Fourdan
committed
ops |= MENU_OP_NORMAL | MENU_OP_BELOW;
}
else if (FLAG_TEST(c->flags, CLIENT_FLAG_BELOW))
{
ops |= MENU_OP_NORMAL | MENU_OP_ABOVE;
Olivier Fourdan
committed
}
else
{
Olivier Fourdan
committed
ops |= MENU_OP_ABOVE | MENU_OP_BELOW;
}
if (clientIsValidTransientOrModal (c) ||
FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
{
insensitive |= MENU_OP_NORMAL | MENU_OP_ABOVE | MENU_OP_BELOW;
}
/* KDE extension */
clientGetWMProtocols(c);
if (FLAG_TEST (c->wm_flags, WM_FLAG_CONTEXT_HELP))
{
ops |= MENU_OP_CONTEXT_HELP;
Olivier Fourdan
committed
}
if (clientIsValidTransientOrModal (c)
|| !FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_STICK)
|| FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
{
insensitive |= MENU_OP_WORKSPACES;
Olivier Fourdan
committed
}
Olivier Fourdan
committed
{
g_signal_handler_disconnect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)), screen_info->button_handler_id);
Olivier Fourdan
committed
}
screen_info->button_handler_id = g_signal_connect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)),
"button_press_event", GTK_SIGNAL_FUNC (show_popup_cb), (gpointer) NULL);
Olivier Fourdan
committed
/*
Since all button press/release events are catched by the windows frames, there is some
side effect with GTK menu. When a menu is opened, any click on the window frame is not
detected as a click outside the menu, and the menu doesn't close.
To avoid this (painless but annoying) behavior, we just setup a no event window that
"hides" the events to regular windows.
That might look tricky, but it's very efficient and save plenty of lines of complicated
Don't forget to delete that window once the menu is closed, though, or we'll get in
xfwmWindowTemp (screen_info,
&menu_event_window, 0, 0,
screen_info->width,
screen_info->height,
Olivier Fourdan
committed
NoEventMask,
FALSE);
menu = menu_default (screen_info->gscr, c->window, ops, insensitive, menu_callback,
c->win_workspace, screen_info->workspace_count,
screen_info->workspace_names, screen_info->workspace_names_items,
display_info->xfilter, screen_info);
Olivier Fourdan
committed
if (!menu_popup (menu, x, y, button, time))
TRACE ("Cannot open menu");
gdk_beep ();
c->button_status[MENU_BUTTON] = BUTTON_STATE_NORMAL;
menu_free (menu);
Olivier Fourdan
committed
}
Olivier Fourdan
committed
}
static gboolean
show_popup_cb (GtkWidget * widget, GdkEventButton * ev, gpointer data)
{
TRACE ("entering show_popup_cb");
show_window_menu ((Client *) data, (gint) ev->x_root, (gint) ev->y_root, ev->button, ev->time);
Olivier Fourdan
committed
return (TRUE);
static gboolean
set_reload (GObject * obj, GdkEvent * ev, gpointer data)
Olivier Fourdan
committed
DisplayInfo *display_info;
TRACE ("setting reload flag so all prefs will be reread at next event loop");
Olivier Fourdan
committed
display_info = (DisplayInfo *) data;
display_info->reload = TRUE;
static gboolean
dbl_click_time_cb (GObject * obj, GdkEvent * ev, gpointer data)
Olivier Fourdan
committed
g_value_init (&tmp_val, G_TYPE_INT);
if (gdk_setting_get ("gtk-double-click-time", &tmp_val))
display_info->dbl_click_time = abs (g_value_get_int (&tmp_val));
}
return (TRUE);
}
static gboolean
client_event_cb (GtkWidget * widget, GdkEventClient * ev, gpointer data)
TRACE ("entering client_event_cb");
Olivier Fourdan
committed
if (!atom_rcfiles)
Olivier Fourdan
committed
{
atom_rcfiles = gdk_atom_intern ("_GTK_READ_RCFILES", FALSE);
Olivier Fourdan
committed
}
if (ev->message_type == atom_rcfiles)
Olivier Fourdan
committed
{
set_reload (G_OBJECT (widget), (GdkEvent *) ev, data);
Olivier Fourdan
committed
}
return (FALSE);
Olivier Fourdan
committed
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
static void
size_changed_cb(GdkScreen *gscreen, gpointer data)
{
ScreenInfo *screen_info;
DisplayInfo *display_info;
TRACE ("entering size_changed_cb");
screen_info = (ScreenInfo *) data;
g_return_if_fail (screen_info);
display_info = screen_info->display_info;
screen_info->width = WidthOfScreen (screen_info->xscreen);
screen_info->height = HeightOfScreen (screen_info->xscreen);
setNetWorkarea (display_info, screen_info->xroot, screen_info->workspace_count,
screen_info->width, screen_info->height, screen_info->margins);
placeSidewalks (screen_info, screen_info->params->wrap_workspaces);
clientScreenResize (screen_info);
compositorUpdateScreenSize (screen_info);
}
static void
monitors_changed_cb(GdkScreen *gscreen, gpointer data)
{
TRACE ("entering monitors_changed_cb");
/*
* From the window manager point of view,
* a XRand 1.2 monitor change is similar to
* a screen size change.
*/
size_changed_cb(gscreen, data);
}
Olivier Fourdan
committed
screen_info->button_handler_id =
g_signal_connect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)),
"button_press_event", GTK_SIGNAL_FUNC (show_popup_cb), (gpointer) NULL);
g_signal_connect (GTK_OBJECT (myScreenGetGtkWidget (screen_info)), "client_event",
Olivier Fourdan
committed
GTK_SIGNAL_FUNC (client_event_cb), (gpointer) (screen_info->display_info));
Olivier Fourdan
committed
g_signal_connect(G_OBJECT(screen_info->gscr), "size-changed",
G_CALLBACK(size_changed_cb),
(gpointer) (screen_info));
if(gtk_major_version > 2 || (gtk_major_version == 2 && gtk_minor_version >= 13))
{
TRACE ("connect \"monitors-changed\" cb");
g_signal_connect(G_OBJECT(screen_info->gscr), "monitors-changed",
G_CALLBACK(monitors_changed_cb),
(gpointer) (screen_info));
}
settings = gtk_settings_get_default ();
if (settings)
{
g_signal_connect (settings, "notify::gtk-theme-name",
Olivier Fourdan
committed
G_CALLBACK (set_reload), (gpointer) (screen_info->display_info));
g_signal_connect (settings, "notify::gtk-font-name",
Olivier Fourdan
committed
G_CALLBACK (set_reload), (gpointer) (screen_info->display_info));
g_signal_connect (settings, "notify::gtk-double-click-time",
G_CALLBACK (dbl_click_time_cb), (gpointer) (screen_info->display_info));