void
frame_update_shadow (decor_frame_t *frame,
decor_shadow_info_t *info,
decor_shadow_options_t *opt_active_shadow,
decor_shadow_options_t *opt_inactive_shadow)
{
static decor_shadow_options_t no_shadow = {0.0, 0.0, {0, 0, 0}, 0, 0};
gwd_decor_frame_ref (frame);
info->active = TRUE;
(*frame->update_shadow) (gdk_x11_get_default_xdisplay (),
gdk_x11_screen_get_xscreen (gdk_screen_get_default ()),
frame, &frame->border_shadow_active,
&frame->window_context_active,
&frame->max_border_shadow_active,
&frame->max_window_context_active,
info, opt_active_shadow, &no_shadow);
info->active = FALSE;
(*frame->update_shadow) (gdk_x11_get_default_xdisplay (),
gdk_x11_screen_get_xscreen (gdk_screen_get_default ()),
frame, &frame->border_shadow_inactive,
&frame->window_context_inactive,
&frame->max_border_shadow_inactive,
&frame->max_window_context_inactive,
info, opt_inactive_shadow, &no_shadow);
gwd_decor_frame_unref (frame);
}
// -----------------------------------------------------------------------------
int g_workspace_count()
{
DEBUGLOGB;
#if _USEGTK
#if _USEWKSPACE
int ret = wnck_screen_get_workspace_count(wnck_screen_get_default());
#else // _USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
#endif
int ret = _wncki_screen_get_workspace_count(xscreen);
#endif // _USEWKSPACE
#else // _USEGTK
int ret = 1;
#endif // _USEGTK
DEBUGLOGE;
return ret;
}
/* Ask X to move to the desktop on which @window currently is
* and the present @window. */
void
empathy_move_to_window_desktop (GtkWindow *window,
guint32 timestamp)
{
#ifdef GDK_WINDOWING_X11
GdkScreen *screen;
Screen *xscreen;
GdkWindow *gdk_window;
int workspace;
screen = gtk_window_get_screen (window);
if (!GDK_IS_X11_SCREEN (screen))
goto out;
xscreen = gdk_x11_screen_get_xscreen (screen);
gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
workspace = window_get_workspace (xscreen,
gdk_x11_window_get_xid (gdk_window));
if (workspace == -1)
goto out;
_wnck_activate_workspace (xscreen, workspace, timestamp);
out:
gtk_window_present_with_time (window, timestamp);
#endif
}
// -----------------------------------------------------------------------------
void g_window_workspace(GtkWidget* pWidget, int space)
{
DEBUGLOGB;
#if !_USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(pWidget));
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
Window xwindow = GDK_WINDOW_XWINDOW(gtk_widget_get_window(pWidget));
#endif
_wncki_change_workspace(xscreen, xwindow, space);
#else // !_USEWKSPACE
WnckScreen* screen = wnck_screen_get_default();
if( screen )
{
DEBUGLOGS("got default screen");
wnck_screen_force_update(screen);
DEBUGLOGP("sticky is off and workspace is %d\n", space);
WnckWindow* window = wnck_window_get(gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget)));
if( window && !wnck_window_is_pinned(window) )
{
DEBUGLOGS("got non-pinned window");
WnckWorkspace* trgtWrk = wnck_screen_get_workspace (screen, space);
WnckWorkspace* actvWrk = wnck_screen_get_active_workspace(screen);
if( trgtWrk && actvWrk && trgtWrk != actvWrk )
{
DEBUGLOGS("got target workspace is diff from current so moving window to target");
wnck_window_move_to_workspace(window, trgtWrk);
}
}
#ifdef _DEBUGLOG
else
{
DEBUGLOGP("WnckWindow for clock window is%svalid\n", window ? " " : " NOT ");
guint xw1 = GDK_WINDOW_XWINDOW (gtk_widget_get_window(pWidget));
guint xw2 = gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget));
DEBUGLOGP("X11 XID1 for clock window is %d\n", (int)xw1);
DEBUGLOGP("X11 XID2 for clock window is %d\n", (int)xw2);
}
#endif
}
#endif // !_USEWKSPACE
DEBUGLOGE;
}
void
gfxGdkNativeRenderer::Draw(gfxContext* ctx, nsIntSize size,
PRUint32 flags, GdkColormap* colormap)
{
mColormap = colormap;
Visual* visual =
gdk_x11_visual_get_xvisual(gdk_colormap_get_visual(colormap));
Screen* screen =
gdk_x11_screen_get_xscreen(gdk_colormap_get_screen(colormap));
gfxXlibNativeRenderer::Draw(ctx, size, flags, screen, visual, nsnull);
}
void
move_resize_window (WnckWindow *win,
int direction,
decor_event *gtkwd_event)
{
Display *xdisplay;
GdkDisplay *gdkdisplay;
GdkScreen *screen;
Window xroot;
XEvent ev;
gdkdisplay = gdk_display_get_default ();
xdisplay = GDK_DISPLAY_XDISPLAY (gdkdisplay);
screen = gdk_display_get_default_screen (gdkdisplay);
xroot = RootWindowOfScreen (gdk_x11_screen_get_xscreen (screen));
if (action_menu_mapped)
{
gtk_object_destroy (GTK_OBJECT (action_menu));
return;
}
ev.xclient.type = ClientMessage;
ev.xclient.display = xdisplay;
ev.xclient.serial = 0;
ev.xclient.send_event = TRUE;
ev.xclient.window = wnck_window_get_xid (win);
ev.xclient.message_type = wm_move_resize_atom;
ev.xclient.format = 32;
ev.xclient.data.l[0] = gtkwd_event->x_root;
ev.xclient.data.l[1] = gtkwd_event->y_root;
ev.xclient.data.l[2] = direction;
ev.xclient.data.l[3] = gtkwd_event->button;
ev.xclient.data.l[4] = 1;
XUngrabPointer (xdisplay, gtkwd_event->time);
XUngrabKeyboard (xdisplay, gtkwd_event->time);
XSendEvent (xdisplay, xroot, FALSE,
SubstructureRedirectMask | SubstructureNotifyMask,
&ev);
XSync (xdisplay, FALSE);
}
void
_gdk_x11_screen_size_changed (GdkScreen *screen,
XEvent *event)
{
gint width, height;
#ifdef HAVE_RANDR
GdkX11Display *display_x11;
#endif
width = gdk_screen_get_width (screen);
height = gdk_screen_get_height (screen);
#ifdef HAVE_RANDR
display_x11 = GDK_X11_DISPLAY (gdk_screen_get_display (screen));
if (display_x11->have_randr13 && event->type == ConfigureNotify)
return;
XRRUpdateConfiguration (event);
#else
if (event->type == ConfigureNotify)
{
XConfigureEvent *rcevent = (XConfigureEvent *) event;
Screen *xscreen = gdk_x11_screen_get_xscreen (screen);
xscreen->width = rcevent->width;
xscreen->height = rcevent->height;
}
else
return;
#endif
process_monitors_change (screen);
if (width != gdk_screen_get_width (screen) ||
height != gdk_screen_get_height (screen))
g_signal_emit_by_name (screen, "size-changed");
}
/*
* update_default_decorations
*
* Description: update the default decorations
*/
void
update_default_decorations (GdkScreen *screen)
{
long *data;
Window xroot;
GdkDisplay *gdkdisplay = gdk_display_get_default ();
Display *xdisplay = gdk_x11_display_get_xdisplay (gdkdisplay);
Atom bareAtom, activeAtom;
decor_frame_t *frame;
decor_frame_t *bare_frame = gwd_get_decor_frame ("bare");
decor_extents_t extents;
unsigned int i;
xroot = RootWindowOfScreen (gdk_x11_screen_get_xscreen (screen));
bareAtom = XInternAtom (xdisplay, DECOR_BARE_ATOM_NAME, FALSE);
activeAtom = XInternAtom (xdisplay, DECOR_ACTIVE_ATOM_NAME, FALSE);
if (bare_frame->border_shadow_active)
{
decor_layout_t layout;
unsigned int frame_type = 0;
unsigned int frame_state = 0;
unsigned int frame_actions = 0;
unsigned int nQuad;
decor_quad_t quads[N_QUADS_MAX];
long *data = decor_alloc_property (1, WINDOW_DECORATION_TYPE_PIXMAP);
decor_get_default_layout (&bare_frame->window_context_active, 1, 1, &layout);
nQuad = decor_set_lSrStSbS_window_quads (quads, &bare_frame->window_context_active,
&layout);
decor_quads_to_property (data, 0, bare_frame->border_shadow_active->pixmap,
&bare_frame->win_extents, &bare_frame->win_extents,
&bare_frame->win_extents, &bare_frame->win_extents,
0, 0, quads, nQuad, frame_type, frame_state, frame_actions);
XChangeProperty (xdisplay, xroot,
bareAtom,
XA_INTEGER,
32, PropModeReplace, (guchar *) data,
PROP_HEADER_SIZE + BASE_PROP_SIZE + QUAD_PROP_SIZE * N_QUADS_MAX);
if (minimal)
{
XChangeProperty (xdisplay, xroot,
activeAtom,
XA_INTEGER,
32, PropModeReplace, (guchar *) data,
PROP_HEADER_SIZE + BASE_PROP_SIZE + QUAD_PROP_SIZE * N_QUADS_MAX);
}
free (data);
}
else
{
XDeleteProperty (xdisplay, xroot, bareAtom);
if (minimal)
{
XDeleteProperty (xdisplay, xroot, activeAtom);
}
}
if (minimal)
{
gwd_decor_frame_unref (bare_frame);
return;
}
XDeleteProperty (xdisplay, xroot,
activeAtom);
data = decor_alloc_property (WINDOW_TYPE_FRAMES_NUM * 2, WINDOW_DECORATION_TYPE_PIXMAP);
/* All active states and all inactive states */
for (i = 0; i < WINDOW_TYPE_FRAMES_NUM * 2; ++i)
{
frame = gwd_get_decor_frame (default_frames[i].name);
extents = frame->win_extents;
if (default_frames[i].d)
{
if (default_frames[i].d->surface)
cairo_surface_destroy (default_frames[i].d->surface);
free (default_frames[i].d);
}
default_frames[i].d = calloc (1, sizeof (decor_t));
default_frames[i].d->context = i < WINDOW_TYPE_FRAMES_NUM ? &frame->window_context_active : &frame->window_context_inactive;
default_frames[i].d->shadow = i < WINDOW_TYPE_FRAMES_NUM ? frame->border_shadow_active : frame->border_shadow_inactive;
default_frames[i].d->layout = pango_layout_new (frame->pango_context);
decor_get_default_layout (default_frames[i].d->context, 1, 1, &default_frames[i].d->border_layout);
default_frames[i].d->width = default_frames[i].d->border_layout.width;
default_frames[i].d->height = default_frames[i].d->border_layout.height;
default_frames[i].d->frame = frame;
default_frames[i].d->active = i < WINDOW_TYPE_FRAMES_NUM ? TRUE : FALSE;
extents.top += frame->titlebar_height;
default_frames[i].d->draw = theme_draw_window_decoration;
default_frames[i].d->surface = create_native_surface_and_wrap (default_frames[i].d->width,
default_frames[i].d->height,
frame->style_window_rgba);
unsigned int j, k;
for (j = 0; j < 3; ++j)
{
for (k = 0; k < 3; k++)
{
default_frames[i].d->event_windows[j][k].window = None;
}
}
for (j = 0; j < BUTTON_NUM; ++j)
{
default_frames[i].d->button_windows[j].window = None;
default_frames[i].d->button_states[j] = 0;
}
if (default_frames[i].d->surface)
{
gint nQuad;
unsigned int frame_type = populate_frame_type (default_frames[i].d);
unsigned int frame_state = populate_frame_state (default_frames[i].d);
unsigned int frame_actions = populate_frame_actions (default_frames[i].d);
decor_quad_t quads[N_QUADS_MAX];
nQuad = decor_set_lSrStSbS_window_quads (quads, default_frames[i].d->context,
&default_frames[i].d->border_layout);
default_frames[i].d->picture = XRenderCreatePicture (xdisplay,
cairo_xlib_surface_get_drawable (default_frames[i].d->surface),
xformat_rgba, 0, NULL);
(*default_frames[i].d->draw) (default_frames[i].d);
decor_quads_to_property (data, i, cairo_xlib_surface_get_drawable (default_frames[i].d->surface),
&extents, &extents,
&extents, &extents, 0, 0, quads, nQuad, frame_type, frame_state, frame_actions);
}
gwd_decor_frame_unref (frame);
}
XChangeProperty (xdisplay, xroot,
activeAtom,
XA_INTEGER,
32, PropModeAppend, (guchar *) data,
PROP_HEADER_SIZE + (WINDOW_TYPE_FRAMES_NUM * 2) * (BASE_PROP_SIZE + QUAD_PROP_SIZE * N_QUADS_MAX));
free (data);
gwd_decor_frame_unref (bare_frame);
}
/* Returns NULL if screen could not be created. For instance, if
* the driver does not support Xrandr 1.2.
*/
MateRRScreen *
mate_rr_screen_new (GdkScreen *gdk_screen,
MateRRScreenChanged callback,
gpointer data,
GError **error)
{
#ifdef HAVE_RANDR
Display *dpy = GDK_SCREEN_XDISPLAY (gdk_screen);
int event_base;
int ignore;
#endif
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
_mate_desktop_init_i18n ();
#ifdef HAVE_RANDR
if (XRRQueryExtension (dpy, &event_base, &ignore))
{
MateRRScreen *screen = g_new0 (MateRRScreen, 1);
screen->gdk_screen = gdk_screen;
screen->gdk_root = gdk_screen_get_root_window (gdk_screen);
screen->xroot = gdk_x11_drawable_get_xid (screen->gdk_root);
screen->xdisplay = dpy;
screen->xscreen = gdk_x11_screen_get_xscreen (screen->gdk_screen);
screen->connector_type_atom = XInternAtom (dpy, "ConnectorType", FALSE);
screen->callback = callback;
screen->data = data;
screen->randr_event_base = event_base;
XRRQueryVersion (dpy, &screen->rr_major_version, &screen->rr_minor_version);
if (screen->rr_major_version > 1 || (screen->rr_major_version == 1 && screen->rr_minor_version < 2)) {
g_set_error (error, MATE_RR_ERROR, MATE_RR_ERROR_NO_RANDR_EXTENSION,
"RANDR extension is too old (must be at least 1.2)");
g_free (screen);
return NULL;
}
screen->info = screen_info_new (screen, TRUE, error);
if (!screen->info) {
g_free (screen);
return NULL;
}
if (screen->callback) {
XRRSelectInput (screen->xdisplay,
screen->xroot,
RRScreenChangeNotifyMask);
gdk_x11_register_standard_event_type (gdk_screen_get_display (gdk_screen),
event_base,
RRNotify + 1);
gdk_window_add_filter (screen->gdk_root, screen_on_event, screen);
}
return screen;
}
else
{
#endif /* HAVE_RANDR */
g_set_error (error, MATE_RR_ERROR, MATE_RR_ERROR_NO_RANDR_EXTENSION,
_("RANDR extension is not present"));
return NULL;
#ifdef HAVE_RANDR
}
#endif
}
gboolean
gf_display_get_workarea(GdkScreen* g_screen, GdkRectangle *rect) {
Atom xa_desktops, xa_current, xa_workarea, xa_type;
Display *x_display;
Window x_root;
guint32 desktops = 0, current = 0;
gulong *workareas, len, fill;
guchar *data;
gint format;
GdkDisplay *g_display;
Screen *x_screen;
/* get the gdk display */
g_display = gdk_display_get_default();
if(!g_display)
return FALSE;
/* get the x display from the gdk display */
x_display = gdk_x11_display_get_xdisplay(g_display);
if(!x_display)
return FALSE;
/* get the x screen from the gdk screen */
x_screen = gdk_x11_screen_get_xscreen(g_screen);
if(!x_screen)
return FALSE;
/* get the root window from the screen */
x_root = XRootWindowOfScreen(x_screen);
/* find the _NET_NUMBER_OF_DESKTOPS atom */
xa_desktops = XInternAtom(x_display, "_NET_NUMBER_OF_DESKTOPS", True);
if(xa_desktops == None)
return FALSE;
/* get the number of desktops */
if(XGetWindowProperty(x_display, x_root, xa_desktops, 0, 1, False,
XA_CARDINAL, &xa_type, &format, &len, &fill,
&data) != Success)
{
return FALSE;
}
if(!data)
return FALSE;
desktops = *(guint32 *)data;
XFree(data);
/* find the _NET_CURRENT_DESKTOP atom */
xa_current = XInternAtom(x_display, "_NET_CURRENT_DESKTOP", True);
if(xa_current == None)
return FALSE;
/* get the current desktop */
if(XGetWindowProperty(x_display, x_root, xa_current, 0, 1, False,
XA_CARDINAL, &xa_type, &format, &len, &fill,
&data) != Success)
{
return FALSE;
}
if(!data)
return FALSE;
current = *(guint32 *)data;
XFree(data);
/* find the _NET_WORKAREA atom */
xa_workarea = XInternAtom(x_display, "_NET_WORKAREA", True);
if(xa_workarea == None)
return FALSE;
if(XGetWindowProperty(x_display, x_root, xa_workarea, 0, (glong)(4 * 32),
False, AnyPropertyType, &xa_type, &format, &len,
&fill, &data) != Success)
{
return FALSE;
}
/* make sure the type and format are good */
if(xa_type == None || format == 0)
return FALSE;
/* make sure we don't have any leftovers */
if(fill)
return FALSE;
/* make sure len divides evenly by 4 */
if(len % 4)
return FALSE;
/* it's good, lets use it */
workareas = (gulong *)(guint32 *)data;
rect->x = (guint32)workareas[current * 4];
rect->y = (guint32)workareas[current * 4 + 1];
rect->width = (guint32)workareas[current * 4 + 2];
rect->height = (guint32)workareas[current * 4 + 3];
/* clean up our memory */
XFree(data);
return TRUE;
}
void
panel_struts_set_window_hint (PanelToplevel *toplevel)
{
GtkWidget *widget;
PanelStrut *strut;
int strut_size;
int monitor_x, monitor_y, monitor_width, monitor_height;
int screen_width, screen_height;
int leftmost, rightmost, topmost, bottommost;
int scale;
widget = GTK_WIDGET (toplevel);
if (!gtk_widget_get_realized (widget))
return;
if (!(strut = panel_struts_find_strut (toplevel))) {
panel_struts_unset_window_hint (toplevel);
return;
}
scale = gtk_widget_get_scale_factor (widget);
strut_size = strut->allocated_strut_size;
screen_width = WidthOfScreen (gdk_x11_screen_get_xscreen (strut->screen)) / scale;
screen_height = HeightOfScreen (gdk_x11_screen_get_xscreen (strut->screen)) / scale;
panel_struts_get_monitor_geometry (strut->screen,
strut->monitor,
&monitor_x,
&monitor_y,
&monitor_width,
&monitor_height);
panel_multiscreen_is_at_visible_extreme (strut->screen,
strut->monitor,
&leftmost,
&rightmost,
&topmost,
&bottommost);
switch (strut->orientation) {
case PANEL_ORIENTATION_TOP:
if (monitor_y > 0)
strut_size += monitor_y;
if (!topmost) strut_size = 0;
break;
case PANEL_ORIENTATION_BOTTOM:
if (monitor_y + monitor_height < screen_height)
strut_size += screen_height - (monitor_y + monitor_height);
if (!bottommost) strut_size = 0;
break;
case PANEL_ORIENTATION_LEFT:
if (leftmost && monitor_x > 0)
strut_size += monitor_x;
if (!leftmost) strut_size = 0;
break;
case PANEL_ORIENTATION_RIGHT:
if (monitor_x + monitor_width < screen_width)
strut_size += screen_width - (monitor_x + monitor_width);
if (!rightmost) strut_size = 0;
break;
default:
g_assert_not_reached ();
break;
}
panel_xutils_set_strut (gtk_widget_get_window (widget),
strut->orientation,
strut_size,
strut->allocated_strut_start * scale,
strut->allocated_strut_end * scale);
}
ScreenInfo *
myScreenInit (DisplayInfo *display_info, GdkScreen *gscr, unsigned long event_mask, gboolean replace_wm)
{
#ifdef ENABLE_KDE_SYSTRAY_PROXY
gchar selection[32];
#endif
ScreenInfo *screen_info;
GdkWindow *event_win;
PangoLayout *layout;
long desktop_visible;
int i, j;
g_return_val_if_fail (display_info, NULL);
g_return_val_if_fail (GDK_IS_SCREEN (gscr), NULL);
TRACE ("entering myScreenInit");
screen_info = g_new0 (ScreenInfo, 1);
screen_info->params = g_new0 (XfwmParams, 1);
screen_info->display_info = display_info;
screen_info->gscr = gscr;
desktop_visible = 0;
layout = NULL;
/* Create a GTK window so that we are just like any other GTK application */
screen_info->gtk_win = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (screen_info->gtk_win), gscr);
gtk_window_resize (GTK_WINDOW (screen_info->gtk_win), 5, 5);
gtk_window_move (GTK_WINDOW (screen_info->gtk_win), -1000, -1000);
gtk_widget_set_name (screen_info->gtk_win, "xfwm");
gtk_widget_show_now (screen_info->gtk_win);
/*
* The first time the first Gtk application on a display uses pango,
* pango grabs the XServer while it creates the font cache window.
* Therefore, force the cache window to be created now instead of
* trying to do it while we have another grab and deadlocking the server.
*/
layout = gtk_widget_create_pango_layout (screen_info->gtk_win, "-");
pango_layout_get_pixel_extents (layout, NULL, NULL);
g_object_unref (G_OBJECT (layout));
screen_info->xscreen = gdk_x11_screen_get_xscreen (gscr);
screen_info->xroot = (Window) GDK_DRAWABLE_XID(gdk_screen_get_root_window (gscr));
screen_info->screen = gdk_screen_get_number (gscr);
screen_info->cmap = GDK_COLORMAP_XCOLORMAP(gdk_screen_get_rgb_colormap (gscr));
screen_info->depth = DefaultDepth (display_info->dpy, screen_info->screen);
screen_info->visual = DefaultVisual (display_info->dpy, screen_info->screen);
screen_info->shape_win = (Window) None;
myScreenComputeSize (screen_info);
screen_info->xfwm4_win = GDK_WINDOW_XWINDOW (screen_info->gtk_win->window);
if (!myScreenSetWMAtom (screen_info, replace_wm))
{
gtk_widget_destroy (screen_info->gtk_win);
g_free (screen_info);
return NULL;
}
event_win = eventFilterAddWin (gscr, event_mask);
if (!event_win)
{
gtk_widget_destroy (screen_info->gtk_win);
g_free (screen_info);
return NULL;
}
gdk_window_set_user_data (event_win, screen_info->gtk_win);
screen_info->current_ws = 0;
screen_info->previous_ws = 0;
screen_info->current_ws = 0;
screen_info->previous_ws = 0;
screen_info->margins[STRUTS_TOP] = screen_info->gnome_margins[STRUTS_TOP] = 0;
screen_info->margins[STRUTS_LEFT] = screen_info->gnome_margins[STRUTS_LEFT] = 0;
screen_info->margins[STRUTS_RIGHT] = screen_info->gnome_margins[STRUTS_RIGHT] = 0;
screen_info->margins[STRUTS_BOTTOM] = screen_info->gnome_margins[STRUTS_BOTTOM] = 0;
screen_info->workspace_count = 0;
screen_info->workspace_names = NULL;
screen_info->workspace_names_items = 0;
screen_info->windows_stack = NULL;
screen_info->last_raise = NULL;
screen_info->windows = NULL;
screen_info->clients = NULL;
screen_info->client_count = 0;
screen_info->client_serial = 0L;
screen_info->button_handler_id = 0L;
screen_info->key_grabs = 0;
screen_info->pointer_grabs = 0;
getHint (display_info, screen_info->xroot, NET_SHOWING_DESKTOP, &desktop_visible);
screen_info->show_desktop = (desktop_visible != 0);
/* Create the side windows to detect edge movement */
/*left*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[0],
0, 0,
1, screen_info->height,
EnterWindowMask,
TRUE);
/*right*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[1],
screen_info->width - 1, 0,
1, screen_info->height,
EnterWindowMask,
TRUE);
/*top*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[2],
0, 0,
screen_info->width, 1,
EnterWindowMask,
TRUE);
/*bottom*/
xfwmWindowTemp (screen_info,
NULL, 0,
screen_info->xroot,
&screen_info->sidewalk[3],
0, screen_info->height - 1,
screen_info->width, 1,
EnterWindowMask,
TRUE);
#ifdef ENABLE_KDE_SYSTRAY_PROXY
g_snprintf (selection, sizeof (selection), "_NET_SYSTEM_TRAY_S%d", screen_info->screen);
screen_info->net_system_tray_selection = XInternAtom (display_info->dpy, selection, FALSE);
screen_info->systray = getSystrayWindow (display_info, screen_info->net_system_tray_selection);
#endif
screen_info->font_height = 0;
screen_info->box_gc = None;
screen_info->black_gc = NULL;
screen_info->white_gc = NULL;
screen_info->title_colors[ACTIVE].gc = NULL;
screen_info->title_colors[ACTIVE].allocated = FALSE;
screen_info->title_colors[INACTIVE].gc = NULL;
screen_info->title_colors[INACTIVE].allocated = FALSE;
screen_info->title_shadow_colors[ACTIVE].gc = NULL;
screen_info->title_shadow_colors[ACTIVE].allocated = FALSE;
screen_info->title_shadow_colors[INACTIVE].gc = NULL;
screen_info->title_shadow_colors[INACTIVE].allocated = FALSE;
for (i = 0; i < SIDE_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->sides[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->sides[i][INACTIVE]);
}
for (i = 0; i < CORNER_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->corners[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->corners[i][INACTIVE]);
}
for (i = 0; i < BUTTON_COUNT; i++)
{
for (j = 0; j < STATE_COUNT; j++)
{
xfwmPixmapInit (screen_info, &screen_info->buttons[i][j]);
}
}
for (i = 0; i < TITLE_COUNT; i++)
{
xfwmPixmapInit (screen_info, &screen_info->title[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->title[i][INACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->top[i][ACTIVE]);
xfwmPixmapInit (screen_info, &screen_info->top[i][INACTIVE]);
}
screen_info->monitors_index = NULL;
myScreenInvalidateMonitorCache (screen_info);
myScreenRebuildMonitorIndex (screen_info);
return (screen_info);
}
