Newer
Older
Olivier Fourdan
committed
clientHandleNetActiveWindow (c, (guint32) ev->data.l[1], (gboolean) (ev->data.l[0] == 1));
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
}
else if (ev->message_type == display_info->atoms[NET_WM_FULLSCREEN_MONITORS])
{
TRACE ("client \"%s\" (0x%lx) has received a NET_WM_FULLSCREEN_MONITORS event", c->name, c->window);
clientSetFullscreenMonitor (c, (gint) ev->data.l[0], (gint) ev->data.l[1],
(gint) ev->data.l[2], (gint) ev->data.l[3]);
}
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] < (long) screen_info->workspace_count) &&
(ev->data.l[0] != (long) screen_info->current_ws))
workspaceSwitch (screen_info, ev->data.l[0], NULL, TRUE,
myDisplayGetTime (display_info, (guint32) 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] != (long) 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 ((Atom) ev->data.l[0] == display_info->atoms[NET_WM_PING])
{
TRACE ("root has received a NET_WM_PING (pong) event\n");
clientReceiveNetWMPong (screen_info, (guint32) ev->data.l[1]);
TRACE ("unidentified client message for window 0x%lx", ev->window);
return status;
Olivier Fourdan
committed
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
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;
Olivier Fourdan
committed
static eventFilterStatus
handleReparentNotify (DisplayInfo *display_info, XReparentEvent * ev)
{
TRACE ("entering handleReparentNotify, 0x%lx reparented in 0x%lx", ev->window, ev->parent);
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);
Olivier Fourdan
committed
case ReparentNotify:
status = handleReparentNotify (display_info, (XReparentEvent *) ev);
break;
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)
Olivier Fourdan
committed
/*
* Qutting on purpose, update session manager so
* it does not restart the program immediately
Olivier Fourdan
committed
*/
client_session_set_restart_style(display_info->session, SESSION_RESTART_IF_RUNNING);
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))
{
Olivier Fourdan
committed
clientWithdraw (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:
Olivier Fourdan
committed
clientWithdrawAll (c, c->win_workspace);
break;
case MENU_OP_UNMINIMIZE:
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN))
{
clientClearAllShowDesktop (c->screen_info);
}
clientShow (c, TRUE);
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 timestamp)
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;
is_transient = clientIsValidTransientOrModal (c);
Olivier Fourdan
committed
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
insensitive |= MENU_OP_DELETE;
}
if (is_transient || !FLAG_TEST(c->xfwm_flags, XFWM_FLAG_HAS_STICK))
Olivier Fourdan
committed
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
{
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 (is_transient || (c->type != WINDOW_NORMAL))
Olivier Fourdan
committed
{
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 (is_transient || FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
Olivier Fourdan
committed
{
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
}
Olivier Fourdan
committed
|| !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);
if (!menu_popup (menu, x, y, button, timestamp))
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);
static gboolean
refresh_font_cb (GObject * obj, GdkEvent * ev, gpointer data)
{
ScreenInfo *screen_info;
screen_info = (ScreenInfo *) data;
g_return_val_if_fail (screen_info, TRUE);
myScreenUpdateFontHeight (screen_info);
clientUpdateAllFrames (screen_info, UPDATE_FRAME);
return (TRUE);
}
Olivier Fourdan
committed
static void
size_changed_cb(GdkScreen *gscreen, gpointer data)
{
ScreenInfo *screen_info;
DisplayInfo *display_info;
Olivier Fourdan
committed
gboolean size_changed;
Olivier Fourdan
committed
TRACE ("entering size_changed_cb");
screen_info = (ScreenInfo *) data;
g_return_if_fail (screen_info);
Olivier Fourdan
committed
display_info = screen_info->display_info;
Olivier Fourdan
committed
/*
* We have added/removed a monitor or even changed the layout,
* the cache for monitor position we use in our screen structure
* is not valid anymore and potentially refers to a monitor that
* was just removed, so invalidate it.
*/
screen_info->cache_monitor.x = -1;
screen_info->cache_monitor.y = -1;
screen_info->cache_monitor.width = 0;
screen_info->cache_monitor.height = 0;
Olivier Fourdan
committed
size_changed = myScreenComputeSize (screen_info);
Olivier Fourdan
committed
setNetWorkarea (display_info, screen_info->xroot, screen_info->workspace_count,
Olivier Fourdan
committed
screen_info->width, screen_info->height, screen_info->margins);
Olivier Fourdan
committed
placeSidewalks (screen_info, screen_info->params->wrap_workspaces);
clientScreenResize (screen_info);
Olivier Fourdan
committed
if (size_changed)
{
compositorUpdateScreenSize (screen_info);
}
Olivier Fourdan
committed
}
static void
monitors_changed_cb(GdkScreen *gscreen, gpointer data)
{
ScreenInfo *screen_info;
Olivier Fourdan
committed
TRACE ("entering monitors_changed_cb");
screen_info = (ScreenInfo *) data;
g_return_if_fail (screen_info);
Olivier Fourdan
committed
/*
* 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
}
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));
g_signal_connect (G_OBJECT(screen_info->gscr), "size-changed",
G_CALLBACK(size_changed_cb),
(gpointer) (screen_info));
Olivier Fourdan
committed
if (gtk_major_version > 2 || (gtk_major_version == 2 && gtk_minor_version >= 13))
Olivier Fourdan
committed
{
TRACE ("connect \"monitors-changed\" cb");
g_signal_connect (G_OBJECT(screen_info->gscr), "monitors-changed",
G_CALLBACK(monitors_changed_cb),
(gpointer) (screen_info));
Olivier Fourdan
committed
}
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));
g_signal_connect_after (settings, "notify::gtk-xft-antialias",
G_CALLBACK (refresh_font_cb), (gpointer) (screen_info));
g_signal_connect_after (settings, "notify::gtk-xft-dpi",
G_CALLBACK (refresh_font_cb), (gpointer) (screen_info));
g_signal_connect_after (settings, "notify::gtk-xft-hinting",
G_CALLBACK (refresh_font_cb), (gpointer) (screen_info));
g_signal_connect_after (settings, "notify::gtk-xft-hintstyle",
G_CALLBACK (refresh_font_cb), (gpointer) (screen_info));
g_signal_connect_after (settings, "notify::gtk-xft-rgba",
G_CALLBACK (refresh_font_cb), (gpointer) (screen_info));