brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move screen size and cursor setting to MetaDisplay

Browse Source 
Split X11 specific parts into MetaX11Display
This commit is contained in:
Armin Krezović
2017-08-26 18:37:29 +02:00
parent a72a2381de
commit a2d13e76cc
17 changed files with 379 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/compositor/compositor.c
View File

@@ -614,7 +614,7 @@ meta_shape_cow_for_window (MetaCompositor *compositor,
window_bounds.width = rect.width; window_bounds.width = rect.width;
window_bounds.height = rect.height; window_bounds.height = rect.height;
meta_screen_get_size (display->screen, &width, &height); meta_display_get_size (display, &width, &height);
screen_rect.x = 0; screen_rect.x = 0;
screen_rect.y = 0; screen_rect.y = 0;
screen_rect.width = width; screen_rect.width = width;

24
src/compositor/meta-background.c
View File

@@ -17,6 +17,7 @@
* along with this program; if not, see <http://www.gnu.org/licenses/>. * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/ */
#include <meta/display.h>
#include <meta/util.h> #include <meta/util.h>
#include <meta/meta-background.h> #include <meta/meta-background.h>
#include <meta/meta-background-image.h> #include <meta/meta-background-image.h>
@@ -25,6 +26,10 @@
#include <string.h> #include <string.h>
// XXX: Remove this once transition to MetaDisplay has been completed
#include "core/display-private.h"
#include "core/screen-private.h"
enum enum
{ {
CHANGED, CHANGED,
@@ -128,10 +133,11 @@ free_wallpaper_texture (MetaBackground *self)
} }
static void static void
on_monitors_changed (MetaScreen *screen, on_monitors_changed (MetaDisplay *display,
MetaBackground *self) MetaBackground *self)
{ {
MetaBackgroundPrivate *priv = self->priv; MetaBackgroundPrivate *priv = self->priv;
MetaScreen *screen = display->screen;
free_fbos (self); free_fbos (self);
g_free (priv->monitors); g_free (priv->monitors);
@@ -156,22 +162,22 @@ set_screen (MetaBackground *self,
{ {
MetaBackgroundPrivate *priv = self->priv; MetaBackgroundPrivate *priv = self->priv;
if (priv->screen != NULL) if (priv->screen != NULL && priv->screen->display != NULL)
{ {
g_signal_handlers_disconnect_by_func (priv->screen, g_signal_handlers_disconnect_by_func (priv->screen->display,
(gpointer)on_monitors_changed, (gpointer)on_monitors_changed,
self); self);
} }
priv->screen = screen; priv->screen = screen;
if (priv->screen != NULL) if (priv->screen != NULL && priv->screen->display != NULL)
{ {
g_signal_connect (priv->screen, "monitors-changed", g_signal_connect (priv->screen->display, "monitors-changed",
G_CALLBACK (on_monitors_changed), self); G_CALLBACK (on_monitors_changed), self);
} }
on_monitors_changed (priv->screen, self); on_monitors_changed (priv->screen->display, self);
} }
static void static void
@@ -388,6 +394,7 @@ get_texture_area (MetaBackground *self,
CoglTexture *texture, CoglTexture *texture,
cairo_rectangle_int_t *texture_area) cairo_rectangle_int_t *texture_area)
{ {
MetaDisplay *display;
MetaBackgroundPrivate *priv = self->priv; MetaBackgroundPrivate *priv = self->priv;
cairo_rectangle_int_t image_area; cairo_rectangle_int_t image_area;
int screen_width, screen_height; int screen_width, screen_height;
@@ -396,6 +403,7 @@ get_texture_area (MetaBackground *self,
texture_width = cogl_texture_get_width (texture); texture_width = cogl_texture_get_width (texture);
texture_height = cogl_texture_get_height (texture); texture_height = cogl_texture_get_height (texture);
display = meta_screen_get_display (priv->screen);
switch (priv->style) switch (priv->style)
{ {
@@ -407,7 +415,7 @@ get_texture_area (MetaBackground *self,
set_texture_area_from_monitor_area (monitor_rect, texture_area); set_texture_area_from_monitor_area (monitor_rect, texture_area);
break; break;
case G_DESKTOP_BACKGROUND_STYLE_WALLPAPER: case G_DESKTOP_BACKGROUND_STYLE_WALLPAPER:
meta_screen_get_size (priv->screen, &screen_width, &screen_height); meta_display_get_size (display, &screen_width, &screen_height);
/* Start off by centering a tile in the middle of the /* Start off by centering a tile in the middle of the
* total screen area. * total screen area.
@@ -476,7 +484,7 @@ get_texture_area (MetaBackground *self,
/* paint region is the union of all monitors, with the origin /* paint region is the union of all monitors, with the origin
* of the region set to align with monitor associated with the background. * of the region set to align with monitor associated with the background.
*/ */
meta_screen_get_size (priv->screen, &screen_width, &screen_height); meta_display_get_size (display, &screen_width, &screen_height);
/* unclipped texture area is whole screen */ /* unclipped texture area is whole screen */
image_area.width = screen_width; image_area.width = screen_width;

3
src/compositor/meta-window-group.c
View File

@@ -13,6 +13,7 @@
#include "meta-window-group.h" #include "meta-window-group.h"
#include "window-private.h" #include "window-private.h"
#include "meta-cullable.h" #include "meta-cullable.h"
#include "display-private.h"
struct _MetaWindowGroupClass struct _MetaWindowGroupClass
{ {
@@ -64,7 +65,7 @@ meta_window_group_paint (ClutterActor *actor)
MetaWindowGroup *window_group = META_WINDOW_GROUP (actor); MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
ClutterActor *stage = clutter_actor_get_stage (actor); ClutterActor *stage = clutter_actor_get_stage (actor);
meta_screen_get_size (window_group->screen, &screen_width, &screen_height); meta_display_get_size (window_group->screen->display, &screen_width, &screen_height);
/* Normally we expect an actor to be drawn at it's position on the screen. /* Normally we expect an actor to be drawn at it's position on the screen.
* However, if we're inside the paint of a ClutterClone, that won't be the * However, if we're inside the paint of a ClutterClone, that won't be the

16
src/compositor/plugins/default.c
View File

@@ -21,6 +21,7 @@
#include <config.h> #include <config.h>
#include <meta/display.h>
#include <meta/meta-plugin.h> #include <meta/meta-plugin.h>
#include <meta/window.h> #include <meta/window.h>
#include <meta/meta-background-group.h> #include <meta/meta-background-group.h>
@@ -32,6 +33,9 @@
#include <gmodule.h> #include <gmodule.h>
#include <string.h> #include <string.h>
// XXX: Remove this once transition to MetaDisplay has been completed
#include "core/display-private.h"
#define DESTROY_TIMEOUT 100 #define DESTROY_TIMEOUT 100
#define MINIMIZE_TIMEOUT 250 #define MINIMIZE_TIMEOUT 250
#define MAP_TIMEOUT 250 #define MAP_TIMEOUT 250
@@ -318,9 +322,10 @@ on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data)
} }
static void static void
on_monitors_changed (MetaScreen *screen, on_monitors_changed (MetaDisplay *display,
MetaPlugin *plugin) MetaPlugin *plugin)
{ {
MetaScreen *screen = display->screen;
MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin); MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
int i, n; int i, n;
GRand *rand = g_rand_new_with_seed (123456); GRand *rand = g_rand_new_with_seed (123456);
@@ -373,14 +378,15 @@ start (MetaPlugin *plugin)
{ {
MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin); MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
MetaScreen *screen = meta_plugin_get_screen (plugin); MetaScreen *screen = meta_plugin_get_screen (plugin);
MetaDisplay *display = meta_screen_get_display (screen);
self->priv->background_group = meta_background_group_new (); self->priv->background_group = meta_background_group_new ();
clutter_actor_insert_child_below (meta_get_window_group_for_screen (screen), clutter_actor_insert_child_below (meta_get_window_group_for_screen (screen),
self->priv->background_group, NULL); self->priv->background_group, NULL);
g_signal_connect (screen, "monitors-changed", g_signal_connect (display, "monitors-changed",
G_CALLBACK (on_monitors_changed), plugin); G_CALLBACK (on_monitors_changed), plugin);
on_monitors_changed (screen, plugin); on_monitors_changed (display, plugin);
clutter_actor_show (meta_get_stage_for_screen (screen)); clutter_actor_show (meta_get_stage_for_screen (screen));
} }
@@ -391,6 +397,7 @@ switch_workspace (MetaPlugin *plugin,
MetaMotionDirection direction) MetaMotionDirection direction)
{ {
MetaScreen *screen; MetaScreen *screen;
MetaDisplay *display;
MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv; MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;
GList *l; GList *l;
ClutterActor *workspace0 = clutter_actor_new (); ClutterActor *workspace0 = clutter_actor_new ();
@@ -399,9 +406,10 @@ switch_workspace (MetaPlugin *plugin,
int screen_width, screen_height; int screen_width, screen_height;
screen = meta_plugin_get_screen (plugin); screen = meta_plugin_get_screen (plugin);
display = meta_screen_get_display (screen);
stage = meta_get_stage_for_screen (screen); stage = meta_get_stage_for_screen (screen);
meta_screen_get_size (screen, meta_display_get_size (display,
&screen_width, &screen_width,
&screen_height); &screen_height);

15
src/core/display-private.h
View File

@@ -106,6 +106,9 @@ typedef gboolean (*MetaAlarmFilter) (MetaDisplay *display,
XSyncAlarmNotifyEvent *event, XSyncAlarmNotifyEvent *event,
gpointer data); gpointer data);
typedef void (* MetaDisplayWindowFunc) (MetaWindow *window,
gpointer user_data);
struct _MetaDisplay struct _MetaDisplay
{ {
GObject parent_instance; GObject parent_instance;
@@ -260,6 +263,9 @@ struct _MetaDisplay
ClutterActor *current_pad_osd; ClutterActor *current_pad_osd;
MetaStartupNotification *startup_notification; MetaStartupNotification *startup_notification;
MetaRectangle rect; /* Size of screen; rect.x & rect.y are always 0 */
MetaCursor current_cursor;
}; };
struct _MetaDisplayClass struct _MetaDisplayClass
@@ -286,8 +292,7 @@ gboolean meta_display_open (void);
void meta_display_close (MetaDisplay *display, void meta_display_close (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
void meta_display_unmanage_windows_for_screen (MetaDisplay *display, void meta_display_unmanage_windows (MetaDisplay *display,
MetaScreen *screen,
guint32 timestamp); guint32 timestamp);
/* Utility function to compare the stacking of two windows */ /* Utility function to compare the stacking of two windows */
@@ -350,6 +355,7 @@ GSList* meta_display_list_windows (MetaDisplay *display,
MetaDisplay* meta_display_for_x_display (Display *xdisplay); MetaDisplay* meta_display_for_x_display (Display *xdisplay);
MetaDisplay* meta_get_display (void); MetaDisplay* meta_get_display (void);
void meta_display_reload_cursor (MetaDisplay *display);
void meta_display_update_cursor (MetaDisplay *display); void meta_display_update_cursor (MetaDisplay *display);
void meta_display_check_threshold_reached (MetaDisplay *display, void meta_display_check_threshold_reached (MetaDisplay *display,
@@ -465,4 +471,9 @@ void meta_display_notify_pad_group_switch (MetaDisplay *display,
guint n_mode, guint n_mode,
guint n_modes); guint n_modes);
void meta_display_foreach_window (MetaDisplay *display,
MetaListWindowsFlags flags,
MetaDisplayWindowFunc func,
gpointer data);
#endif #endif

269
src/core/display.c
View File

@@ -37,6 +37,7 @@
#include <meta/main.h> #include <meta/main.h>
#include "screen-private.h" #include "screen-private.h"
#include "window-private.h" #include "window-private.h"
#include "boxes-private.h"
#include "frame.h" #include "frame.h"
#include <meta/errors.h> #include <meta/errors.h>
#include "keybindings-private.h" #include "keybindings-private.h"
@@ -118,6 +119,7 @@ G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);
/* Signals */ /* Signals */
enum enum
{ {
CURSOR_UPDATED,
OVERLAY_KEY, OVERLAY_KEY,
ACCELERATOR_ACTIVATED, ACCELERATOR_ACTIVATED,
MODIFIERS_ACCELERATOR_ACTIVATED, MODIFIERS_ACCELERATOR_ACTIVATED,
@@ -134,6 +136,7 @@ enum
SHOW_PAD_OSD, SHOW_PAD_OSD,
SHOW_OSD, SHOW_OSD,
PAD_MODE_SWITCH, PAD_MODE_SWITCH,
MONITORS_CHANGED,
LAST_SIGNAL LAST_SIGNAL
}; };
@@ -157,7 +160,8 @@ static MetaDisplay *the_display = NULL;
static const char *gnome_wm_keybindings = "Mutter"; static const char *gnome_wm_keybindings = "Mutter";
static const char *net_wm_name = "Mutter"; static const char *net_wm_name = "Mutter";
static void update_cursor_theme (void); static void on_monitors_changed (MetaMonitorManager *manager,
MetaDisplay *display);
static void prefs_changed_callback (MetaPreference pref, static void prefs_changed_callback (MetaPreference pref,
void *data); void *data);
@@ -206,6 +210,14 @@ meta_display_class_init (MetaDisplayClass *klass)
object_class->get_property = meta_display_get_property; object_class->get_property = meta_display_get_property;
object_class->set_property = meta_display_set_property; object_class->set_property = meta_display_set_property;
display_signals[CURSOR_UPDATED] =
g_signal_new ("cursor-updated",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
display_signals[OVERLAY_KEY] = display_signals[OVERLAY_KEY] =
g_signal_new ("overlay-key", g_signal_new ("overlay-key",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
@@ -395,6 +407,13 @@ meta_display_class_init (MetaDisplayClass *klass)
G_TYPE_NONE, 3, CLUTTER_TYPE_INPUT_DEVICE, G_TYPE_NONE, 3, CLUTTER_TYPE_INPUT_DEVICE,
G_TYPE_UINT, G_TYPE_UINT); G_TYPE_UINT, G_TYPE_UINT);
display_signals[MONITORS_CHANGED] =
g_signal_new ("monitors-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
g_object_class_install_property (object_class, g_object_class_install_property (object_class,
PROP_FOCUS_WINDOW, PROP_FOCUS_WINDOW,
g_param_spec_object ("focus-window", g_param_spec_object ("focus-window",
@@ -597,6 +616,7 @@ meta_display_open (void)
int i; int i;
guint32 timestamp; guint32 timestamp;
Window old_active_xwindow = None; Window old_active_xwindow = None;
MetaMonitorManager *manager;
g_assert (the_display == NULL); g_assert (the_display == NULL);
display = the_display = g_object_new (META_TYPE_DISPLAY, NULL); display = the_display = g_object_new (META_TYPE_DISPLAY, NULL);
@@ -611,6 +631,9 @@ meta_display_open (void)
display->screen = NULL; display->screen = NULL;
display->x11_display = NULL; display->x11_display = NULL;
display->rect.x = display->rect.y = 0;
display->current_cursor = -1; /* invalid/unset */
display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */ display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */
display->allow_terminal_deactivation = TRUE; /* Only relevant for when a display->allow_terminal_deactivation = TRUE; /* Only relevant for when a
terminal has the focus */ terminal has the focus */
@@ -647,6 +670,16 @@ meta_display_open (void)
g_int64_equal); g_int64_equal);
display->wayland_windows = g_hash_table_new (NULL, NULL); display->wayland_windows = g_hash_table_new (NULL, NULL);
manager = meta_monitor_manager_get ();
g_signal_connect (manager, "monitors-changed",
G_CALLBACK (on_monitors_changed), display);
meta_monitor_manager_get_screen_size (manager,
&display->rect.width,
&display->rect.height);
meta_display_set_cursor (display, META_CURSOR_DEFAULT);
x11_display = meta_x11_display_new (display, &error); x11_display = meta_x11_display_new (display, &error);
g_assert (x11_display != NULL); /* Required, for now */ g_assert (x11_display != NULL); /* Required, for now */
display->x11_display = x11_display; display->x11_display = x11_display;
@@ -677,8 +710,6 @@ meta_display_open (void)
display->xids = g_hash_table_new (meta_unsigned_long_hash, display->xids = g_hash_table_new (meta_unsigned_long_hash,
meta_unsigned_long_equal); meta_unsigned_long_equal);
update_cursor_theme ();
/* Create the leader window here. Set its properties and /* Create the leader window here. Set its properties and
* use the timestamp from one of the PropertyNotify events * use the timestamp from one of the PropertyNotify events
* that will follow. * that will follow.
@@ -939,6 +970,10 @@ meta_display_close (MetaDisplay *display,
/* Stop caring about events */ /* Stop caring about events */
meta_display_free_events (display); meta_display_free_events (display);
meta_compositor_unmanage (display->compositor);
meta_display_unmanage_windows (display, timestamp);
if (display->screen) if (display->screen)
meta_screen_free (display->screen, timestamp); meta_screen_free (display->screen, timestamp);
display->screen = NULL; display->screen = NULL;
@@ -1602,10 +1637,124 @@ meta_cursor_for_grab_op (MetaGrabOp op)
return META_CURSOR_DEFAULT; return META_CURSOR_DEFAULT;
} }
static int
find_highest_logical_monitor_scale (MetaBackend *backend,
MetaCursorSprite *cursor_sprite)
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaCursorRenderer *cursor_renderer =
meta_backend_get_cursor_renderer (backend);
ClutterRect cursor_rect;
GList *logical_monitors;
GList *l;
int highest_scale = 0.0;
cursor_rect = meta_cursor_renderer_calculate_rect (cursor_renderer,
cursor_sprite);
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
for (l = logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
ClutterRect logical_monitor_rect =
meta_rectangle_to_clutter_rect (&logical_monitor->rect);
if (!clutter_rect_intersection (&cursor_rect,
&logical_monitor_rect,
NULL))
continue;
highest_scale = MAX (highest_scale, logical_monitor->scale);
}
return highest_scale;
}
static void
root_cursor_prepare_at (MetaCursorSprite *cursor_sprite,
int x,
int y,
MetaDisplay *display)
{
MetaBackend *backend = meta_get_backend ();
if (meta_is_stage_views_scaled ())
{
int scale;
scale = find_highest_logical_monitor_scale (backend, cursor_sprite);
if (scale != 0.0)
{
meta_cursor_sprite_set_theme_scale (cursor_sprite, scale);
meta_cursor_sprite_set_texture_scale (cursor_sprite, 1.0 / scale);
}
}
else
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor;
logical_monitor =
meta_monitor_manager_get_logical_monitor_at (monitor_manager, x, y);
/* Reload the cursor texture if the scale has changed. */
if (logical_monitor)
{
meta_cursor_sprite_set_theme_scale (cursor_sprite,
logical_monitor->scale);
meta_cursor_sprite_set_texture_scale (cursor_sprite, 1.0);
}
}
}
static void
manage_root_cursor_sprite_scale (MetaDisplay *display,
MetaCursorSprite *cursor_sprite)
{
g_signal_connect_object (cursor_sprite,
"prepare-at",
G_CALLBACK (root_cursor_prepare_at),
display,
0);
}
void
meta_display_reload_cursor (MetaDisplay *display)
{
MetaCursor cursor = display->current_cursor;
MetaCursorSprite *cursor_sprite;
MetaBackend *backend = meta_get_backend ();
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
cursor_sprite = meta_cursor_sprite_from_theme (cursor);
if (meta_is_wayland_compositor ())
manage_root_cursor_sprite_scale (display, cursor_sprite);
meta_cursor_tracker_set_root_cursor (cursor_tracker, cursor_sprite);
g_object_unref (cursor_sprite);
g_signal_emit (display, display_signals[CURSOR_UPDATED], 0, display);
}
void
meta_display_set_cursor (MetaDisplay *display,
MetaCursor cursor)
{
if (cursor == display->current_cursor)
return;
display->current_cursor = cursor;
meta_display_reload_cursor (display);
}
void void
meta_display_update_cursor (MetaDisplay *display) meta_display_update_cursor (MetaDisplay *display)
{ {
meta_screen_set_cursor (display->screen, meta_cursor_for_grab_op (display->grab_op)); meta_display_set_cursor (display, meta_cursor_for_grab_op (display->grab_op));
} }
static MetaWindow * static MetaWindow *
@@ -1953,34 +2102,6 @@ meta_display_retheme_all (void)
meta_display_queue_retheme_all_windows (meta_get_display ()); meta_display_queue_retheme_all_windows (meta_get_display ());
} }
static void
set_cursor_theme (Display *xdisplay)
{
XcursorSetTheme (xdisplay, meta_prefs_get_cursor_theme ());
XcursorSetDefaultSize (xdisplay, meta_prefs_get_cursor_size ());
}
static void
update_cursor_theme (void)
{
{
MetaDisplay *display = meta_get_display ();
set_cursor_theme (display->x11_display->xdisplay);
if (display->screen)
meta_screen_update_cursor (display->screen);
}
{
MetaBackend *backend = meta_get_backend ();
if (META_IS_BACKEND_X11 (backend))
{
Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));
set_cursor_theme (xdisplay);
}
}
}
/* /*
* Stores whether syncing is currently enabled. * Stores whether syncing is currently enabled.
*/ */
@@ -2486,8 +2607,7 @@ meta_display_unmanage_screen (MetaDisplay *display,
} }
void void
meta_display_unmanage_windows_for_screen (MetaDisplay *display, meta_display_unmanage_windows (MetaDisplay *display,
MetaScreen *screen,
guint32 timestamp) guint32 timestamp)
{ {
GSList *tmp; GSList *tmp;
@@ -2568,7 +2688,7 @@ prefs_changed_callback (MetaPreference pref,
else if (pref == META_PREF_CURSOR_THEME || else if (pref == META_PREF_CURSOR_THEME ||
pref == META_PREF_CURSOR_SIZE) pref == META_PREF_CURSOR_SIZE)
{ {
update_cursor_theme (); meta_display_reload_cursor (display);
} }
} }
@@ -2777,6 +2897,26 @@ meta_display_get_x11_display (MetaDisplay *display)
return display->x11_display; return display->x11_display;
} }
/**
* meta_display_get_size:
* @display: A #MetaDisplay
* @width: (out): The width of the screen
* @height: (out): The height of the screen
*
* Retrieve the size of the display.
*/
void
meta_display_get_size (MetaDisplay *display,
int *width,
int *height)
{
if (width != NULL)
*width = display->rect.width;
if (height != NULL)
*height = display->rect.height;
}
/** /**
* meta_display_get_focus_window: * meta_display_get_focus_window:
* @display: a #MetaDisplay * @display: a #MetaDisplay
@@ -3056,3 +3196,62 @@ meta_display_notify_pad_group_switch (MetaDisplay *display,
g_string_free (message, TRUE); g_string_free (message, TRUE);
} }
void
meta_display_foreach_window (MetaDisplay *display,
MetaListWindowsFlags flags,
MetaDisplayWindowFunc func,
gpointer data)
{
GSList *windows;
/* If we end up doing this often, just keeping a list
* of windows might be sensible.
*/
windows = meta_display_list_windows (display, flags);
g_slist_foreach (windows, (GFunc) func, data);
g_slist_free (windows);
}
static void
meta_display_resize_func (MetaWindow *window,
gpointer user_data)
{
if (window->struts)
{
meta_window_update_struts (window);
}
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
meta_window_recalc_features (window);
}
static void
on_monitors_changed (MetaMonitorManager *manager,
MetaDisplay *display)
{
MetaBackend *backend;
MetaCursorRenderer *cursor_renderer;
meta_monitor_manager_get_screen_size (manager,
&display->rect.width,
&display->rect.height);
/* Fix up monitor for all windows on this display */
meta_display_foreach_window (display, META_LIST_INCLUDE_OVERRIDE_REDIRECT,
(MetaDisplayWindowFunc)
meta_window_update_for_monitors_changed, 0);
/* Queue a resize on all the windows */
meta_display_foreach_window (display, META_LIST_DEFAULT,
meta_display_resize_func, 0);
backend = meta_get_backend ();
cursor_renderer = meta_backend_get_cursor_renderer (backend);
meta_cursor_renderer_force_update (cursor_renderer);
g_signal_emit (display, display_signals[MONITORS_CHANGED], 0);
}

2
src/core/edge-resistance.c
View File

@@ -1027,7 +1027,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
* by other windows or DOCKS, but that's handled below). * by other windows or DOCKS, but that's handled below).
*/ */
meta_rectangle_intersect (&cur_rect, meta_rectangle_intersect (&cur_rect,
&display->screen->rect, &display->rect,
&reduced); &reduced);
new_edges = NULL; new_edges = NULL;

13
src/core/screen-private.h
View File

@@ -38,9 +38,6 @@
#include "ui.h" #include "ui.h"
#include "meta-monitor-manager-private.h" #include "meta-monitor-manager-private.h"
typedef void (* MetaScreenWindowFunc) (MetaWindow *window,
gpointer user_data);
#define META_WIREFRAME_XOR_LINE_WIDTH 2 #define META_WIREFRAME_XOR_LINE_WIDTH 2
struct _MetaScreen struct _MetaScreen
@@ -48,7 +45,6 @@ struct _MetaScreen
GObject parent_instance; GObject parent_instance;
MetaDisplay *display; MetaDisplay *display;
MetaRectangle rect; /* Size of screen; rect.x & rect.y are always 0 */
MetaUI *ui; MetaUI *ui;
guint tile_preview_timeout_id; guint tile_preview_timeout_id;
@@ -65,8 +61,6 @@ struct _MetaScreen
MetaStack *stack; MetaStack *stack;
MetaStackTracker *stack_tracker; MetaStackTracker *stack_tracker;
MetaCursor current_cursor;
Window wm_sn_selection_window; Window wm_sn_selection_window;
Atom wm_sn_atom; Atom wm_sn_atom;
guint32 wm_sn_timestamp; guint32 wm_sn_timestamp;
@@ -103,7 +97,6 @@ struct _MetaScreenClass
void (*restacked) (MetaScreen *); void (*restacked) (MetaScreen *);
void (*workareas_changed) (MetaScreen *); void (*workareas_changed) (MetaScreen *);
void (*monitors_changed) (MetaScreen *);
}; };
MetaScreen* meta_screen_new (MetaDisplay *display, MetaScreen* meta_screen_new (MetaDisplay *display,
@@ -112,12 +105,6 @@ void meta_screen_free (MetaScreen *scree
guint32 timestamp); guint32 timestamp);
void meta_screen_init_workspaces (MetaScreen *screen); void meta_screen_init_workspaces (MetaScreen *screen);
void meta_screen_manage_all_windows (MetaScreen *screen); void meta_screen_manage_all_windows (MetaScreen *screen);
void meta_screen_foreach_window (MetaScreen *screen,
MetaListWindowsFlags flags,
MetaScreenWindowFunc func,
gpointer data);
void meta_screen_update_cursor (MetaScreen *screen);
void meta_screen_update_tile_preview (MetaScreen *screen, void meta_screen_update_tile_preview (MetaScreen *screen,
gboolean delay); gboolean delay);

239
src/core/screen.c
View File

@@ -71,7 +71,7 @@ static void prefs_changed_callback (MetaPreference pref,
static void set_desktop_geometry_hint (MetaScreen *screen); static void set_desktop_geometry_hint (MetaScreen *screen);
static void set_desktop_viewport_hint (MetaScreen *screen); static void set_desktop_viewport_hint (MetaScreen *screen);
static void on_monitors_changed (MetaMonitorManager *manager, static void on_monitors_changed (MetaDisplay *display,
MetaScreen *screen); MetaScreen *screen);
enum enum
@@ -89,7 +89,6 @@ enum
WINDOW_LEFT_MONITOR, WINDOW_LEFT_MONITOR,
STARTUP_SEQUENCE_CHANGED, STARTUP_SEQUENCE_CHANGED,
WORKAREAS_CHANGED, WORKAREAS_CHANGED,
MONITORS_CHANGED,
IN_FULLSCREEN_CHANGED, IN_FULLSCREEN_CHANGED,
LAST_SIGNAL LAST_SIGNAL
@@ -241,14 +240,6 @@ meta_screen_class_init (MetaScreenClass *klass)
NULL, NULL, NULL, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
screen_signals[MONITORS_CHANGED] =
g_signal_new ("monitors-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MetaScreenClass, monitors_changed),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
screen_signals[IN_FULLSCREEN_CHANGED] = screen_signals[IN_FULLSCREEN_CHANGED] =
g_signal_new ("in-fullscreen-changed", g_signal_new ("in-fullscreen-changed",
G_TYPE_FROM_CLASS (object_class), G_TYPE_FROM_CLASS (object_class),
@@ -517,8 +508,8 @@ create_guard_window (Display *xdisplay, MetaScreen *screen)
x11_display->xroot, x11_display->xroot,
0, /* x */ 0, /* x */
0, /* y */ 0, /* y */
screen->rect.width, screen->display->rect.width,
screen->rect.height, screen->display->rect.height,
0, /* border width */ 0, /* border width */
0, /* depth */ 0, /* depth */
InputOnly, /* class */ InputOnly, /* class */
@@ -647,7 +638,6 @@ meta_screen_new (MetaDisplay *display,
gboolean replace_current_wm; gboolean replace_current_wm;
Atom wm_sn_atom; Atom wm_sn_atom;
char buf[128]; char buf[128];
MetaMonitorManager *manager;
replace_current_wm = meta_get_replace_current_wm (); replace_current_wm = meta_get_replace_current_wm ();
@@ -693,18 +683,10 @@ meta_screen_new (MetaDisplay *display,
screen->closing = 0; screen->closing = 0;
screen->display = display; screen->display = display;
screen->rect.x = screen->rect.y = 0;
manager = meta_monitor_manager_get (); g_signal_connect (display, "monitors-changed",
g_signal_connect (manager, "monitors-changed",
G_CALLBACK (on_monitors_changed), screen); G_CALLBACK (on_monitors_changed), screen);
meta_monitor_manager_get_screen_size (manager,
&screen->rect.width,
&screen->rect.height);
screen->current_cursor = -1; /* invalid/unset */
screen->wm_sn_selection_window = new_wm_sn_owner; screen->wm_sn_selection_window = new_wm_sn_owner;
screen->wm_sn_atom = wm_sn_atom; screen->wm_sn_atom = wm_sn_atom;
screen->wm_sn_timestamp = timestamp; screen->wm_sn_timestamp = timestamp;
@@ -730,8 +712,6 @@ meta_screen_new (MetaDisplay *display,
reload_logical_monitors (screen); reload_logical_monitors (screen);
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
/* Handle creating a no_focus_window for this screen */ /* Handle creating a no_focus_window for this screen */
screen->no_focus_window = screen->no_focus_window =
meta_x11_display_create_offscreen_window (display->x11_display, meta_x11_display_create_offscreen_window (display->x11_display,
@@ -821,9 +801,9 @@ meta_screen_free (MetaScreen *screen,
screen->closing += 1; screen->closing += 1;
meta_compositor_unmanage (screen->display->compositor); g_signal_handlers_disconnect_by_func (display,
(gpointer)on_monitors_changed,
meta_display_unmanage_windows_for_screen (display, screen, timestamp); screen);
meta_prefs_remove_listener (prefs_changed_callback, screen); meta_prefs_remove_listener (prefs_changed_callback, screen);
@@ -906,25 +886,6 @@ prefs_changed_callback (MetaPreference pref,
} }
} }
void
meta_screen_foreach_window (MetaScreen *screen,
MetaListWindowsFlags flags,
MetaScreenWindowFunc func,
gpointer data)
{
GSList *windows;
/* If we end up doing this often, just keeping a list
* of windows might be sensible.
*/
windows = meta_display_list_windows (screen->display, flags);
g_slist_foreach (windows, (GFunc) func, data);
g_slist_free (windows);
}
int int
meta_screen_get_n_workspaces (MetaScreen *screen) meta_screen_get_n_workspaces (MetaScreen *screen)
{ {
@@ -982,8 +943,8 @@ set_desktop_geometry_hint (MetaScreen *screen)
if (screen->closing > 0) if (screen->closing > 0)
return; return;
data[0] = screen->rect.width; data[0] = screen->display->rect.width;
data[1] = screen->rect.height; data[1] = screen->display->rect.height;
meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]); meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %lu, %lu\n", data[0], data[1]);
@@ -1235,128 +1196,6 @@ update_num_workspaces (MetaScreen *screen,
g_object_notify (G_OBJECT (screen), "n-workspaces"); g_object_notify (G_OBJECT (screen), "n-workspaces");
} }
static int
find_highest_logical_monitor_scale (MetaBackend *backend,
MetaCursorSprite *cursor_sprite)
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaCursorRenderer *cursor_renderer =
meta_backend_get_cursor_renderer (backend);
ClutterRect cursor_rect;
GList *logical_monitors;
GList *l;
int highest_scale = 0.0;
cursor_rect = meta_cursor_renderer_calculate_rect (cursor_renderer,
cursor_sprite);
logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager);
for (l = logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
ClutterRect logical_monitor_rect =
meta_rectangle_to_clutter_rect (&logical_monitor->rect);
if (!clutter_rect_intersection (&cursor_rect,
&logical_monitor_rect,
NULL))
continue;
highest_scale = MAX (highest_scale, logical_monitor->scale);
}
return highest_scale;
}
static void
root_cursor_prepare_at (MetaCursorSprite *cursor_sprite,
int x,
int y,
MetaScreen *screen)
{
MetaBackend *backend = meta_get_backend ();
if (meta_is_stage_views_scaled ())
{
int scale;
scale = find_highest_logical_monitor_scale (backend, cursor_sprite);
if (scale != 0.0)
{
meta_cursor_sprite_set_theme_scale (cursor_sprite, scale);
meta_cursor_sprite_set_texture_scale (cursor_sprite, 1.0 / scale);
}
}
else
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor;
logical_monitor =
meta_monitor_manager_get_logical_monitor_at (monitor_manager, x, y);
/* Reload the cursor texture if the scale has changed. */
if (logical_monitor)
{
meta_cursor_sprite_set_theme_scale (cursor_sprite,
logical_monitor->scale);
meta_cursor_sprite_set_texture_scale (cursor_sprite, 1.0);
}
}
}
static void
manage_root_cursor_sprite_scale (MetaScreen *screen,
MetaCursorSprite *cursor_sprite)
{
g_signal_connect_object (cursor_sprite,
"prepare-at",
G_CALLBACK (root_cursor_prepare_at),
screen,
0);
}
void
meta_screen_update_cursor (MetaScreen *screen)
{
MetaDisplay *display = screen->display;
MetaX11Display *x11_display = display->x11_display;
MetaCursor cursor = screen->current_cursor;
Cursor xcursor;
MetaCursorSprite *cursor_sprite;
MetaBackend *backend = meta_get_backend ();
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
cursor_sprite = meta_cursor_sprite_from_theme (cursor);
if (meta_is_wayland_compositor ())
manage_root_cursor_sprite_scale (screen, cursor_sprite);
meta_cursor_tracker_set_root_cursor (cursor_tracker, cursor_sprite);
g_object_unref (cursor_sprite);
/* Set a cursor for X11 applications that don't specify their own */
xcursor = meta_x11_display_create_x_cursor (x11_display, cursor);
XDefineCursor (x11_display->xdisplay, x11_display->xroot, xcursor);
XFlush (x11_display->xdisplay);
XFreeCursor (x11_display->xdisplay, xcursor);
}
void
meta_screen_set_cursor (MetaScreen *screen,
MetaCursor cursor)
{
if (cursor == screen->current_cursor)
return;
screen->current_cursor = cursor;
meta_screen_update_cursor (screen);
}
static gboolean static gboolean
meta_screen_update_tile_preview_timeout (gpointer data) meta_screen_update_tile_preview_timeout (gpointer data)
{ {
@@ -2181,29 +2020,9 @@ meta_screen_free_workspace_layout (MetaWorkspaceLayout *layout)
} }
static void static void
meta_screen_resize_func (MetaWindow *window, on_monitors_changed (MetaDisplay *display,
gpointer user_data)
{
if (window->struts)
{
meta_window_update_struts (window);
}
meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
meta_window_recalc_features (window);
}
static void
on_monitors_changed (MetaMonitorManager *manager,
MetaScreen *screen) MetaScreen *screen)
{ {
MetaBackend *backend;
MetaCursorRenderer *cursor_renderer;
meta_monitor_manager_get_screen_size (manager,
&screen->rect.width,
&screen->rect.height);
reload_logical_monitors (screen); reload_logical_monitors (screen);
set_desktop_geometry_hint (screen); set_desktop_geometry_hint (screen);
@@ -2214,28 +2033,16 @@ on_monitors_changed (MetaMonitorManager *manager,
changes.x = 0; changes.x = 0;
changes.y = 0; changes.y = 0;
changes.width = screen->rect.width; changes.width = display->rect.width;
changes.height = screen->rect.height; changes.height = display->rect.height;
XConfigureWindow(screen->display->x11_display->xdisplay, XConfigureWindow(display->x11_display->xdisplay,
screen->guard_window, screen->guard_window,
CWX | CWY | CWWidth | CWHeight, CWX | CWY | CWWidth | CWHeight,
&changes); &changes);
} }
/* Fix up monitor for all windows on this screen */
meta_screen_foreach_window (screen, META_LIST_INCLUDE_OVERRIDE_REDIRECT, (MetaScreenWindowFunc) meta_window_update_for_monitors_changed, 0);
/* Queue a resize on all the windows */
meta_screen_foreach_window (screen, META_LIST_DEFAULT, meta_screen_resize_func, 0);
meta_screen_queue_check_fullscreen (screen); meta_screen_queue_check_fullscreen (screen);
backend = meta_get_backend ();
cursor_renderer = meta_backend_get_cursor_renderer (backend);
meta_cursor_renderer_force_update (cursor_renderer);
g_signal_emit (screen, screen_signals[MONITORS_CHANGED], 0);
} }
void void
@@ -2495,26 +2302,6 @@ meta_screen_get_display (MetaScreen *screen)
return screen->display; return screen->display;
} }
/**
* meta_screen_get_size:
* @screen: A #MetaScreen
* @width: (out): The width of the screen
* @height: (out): The height of the screen
*
* Retrieve the size of the screen.
*/
void
meta_screen_get_size (MetaScreen *screen,
int *width,
int *height)
{
if (width != NULL)
*width = screen->rect.width;
if (height != NULL)
*height = screen->rect.height;
}
void void
meta_screen_set_cm_selection (MetaScreen *screen) meta_screen_set_cm_selection (MetaScreen *screen)
{ {

6
src/core/startup-notification.c
View File

@@ -144,19 +144,19 @@ static void meta_startup_notification_ensure_timeout (MetaStartupNotification *
static void static void
meta_startup_notification_update_feedback (MetaStartupNotification *sn) meta_startup_notification_update_feedback (MetaStartupNotification *sn)
{ {
MetaScreen *screen = sn->display->screen; MetaDisplay *display = sn->display;
if (sn->startup_sequences != NULL) if (sn->startup_sequences != NULL)
{ {
meta_topic (META_DEBUG_STARTUP, meta_topic (META_DEBUG_STARTUP,
"Setting busy cursor\n"); "Setting busy cursor\n");
meta_screen_set_cursor (screen, META_CURSOR_BUSY); meta_display_set_cursor (display, META_CURSOR_BUSY);
} }
else else
{ {
meta_topic (META_DEBUG_STARTUP, meta_topic (META_DEBUG_STARTUP,
"Setting default cursor\n"); "Setting default cursor\n");
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT); meta_display_set_cursor (display, META_CURSOR_DEFAULT);
} }
} }

14
src/core/window.c
View File

@@ -2811,7 +2811,7 @@ meta_window_is_screen_sized (MetaWindow *window)
MetaRectangle window_rect; MetaRectangle window_rect;
int screen_width, screen_height; int screen_width, screen_height;
meta_screen_get_size (window->screen, &screen_width, &screen_height); meta_display_get_size (window->display, &screen_width, &screen_height);
meta_window_get_frame_rect (window, &window_rect); meta_window_get_frame_rect (window, &window_rect);
if (window_rect.x == 0 && window_rect.y == 0 && if (window_rect.x == 0 && window_rect.y == 0 &&
@@ -5327,8 +5327,8 @@ meta_window_recalc_features (MetaWindow *window)
* is entire screen size (kind of broken, because we * is entire screen size (kind of broken, because we
* actually fullscreen to monitor size not screen size) * actually fullscreen to monitor size not screen size)
*/ */
if (window->size_hints.min_width == window->screen->rect.width && if (window->size_hints.min_width == window->display->rect.width &&
window->size_hints.min_height == window->screen->rect.height) window->size_hints.min_height == window->display->rect.height)
; /* leave fullscreen available */ ; /* leave fullscreen available */
else else
window->has_fullscreen_func = FALSE; window->has_fullscreen_func = FALSE;
@@ -6221,8 +6221,8 @@ meta_window_get_work_area_all_monitors (MetaWindow *window,
{ {
GList *tmp; GList *tmp;
/* Initialize to the whole screen */ /* Initialize to the whole display */
*area = window->screen->rect; *area = window->display->rect;
tmp = meta_window_get_workspaces (window); tmp = meta_window_get_workspaces (window);
while (tmp != NULL) while (tmp != NULL)
@@ -6465,8 +6465,8 @@ warp_grab_pointer (MetaWindow *window,
*y += rect.y; *y += rect.y;
/* Avoid weird bouncing at the screen edge; see bug 154706 */ /* Avoid weird bouncing at the screen edge; see bug 154706 */
*x = CLAMP (*x, 0, window->screen->rect.width-1); *x = CLAMP (*x, 0, window->display->rect.width-1);
*y = CLAMP (*y, 0, window->screen->rect.height-1); *y = CLAMP (*y, 0, window->display->rect.height-1);
meta_error_trap_push (display->x11_display); meta_error_trap_push (display->x11_display);

14
src/core/workspace.c
View File

@@ -848,13 +848,13 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
workspace->screen_region = workspace->screen_region =
meta_rectangle_get_minimal_spanning_set_for_region ( meta_rectangle_get_minimal_spanning_set_for_region (
&workspace->screen->rect, &workspace->screen->display->rect,
workspace->all_struts); workspace->all_struts);
/* STEP 3: Get the work areas (region-to-maximize-to) for the screen and /* STEP 3: Get the work areas (region-to-maximize-to) for the screen and
* monitors. * monitors.
*/ */
work_area = workspace->screen->rect; /* start with the screen */ work_area = workspace->screen->display->rect; /* start with the screen */
if (workspace->screen_region == NULL) if (workspace->screen_region == NULL)
work_area = meta_rect (0, 0, -1, -1); work_area = meta_rect (0, 0, -1, -1);
else else
@@ -871,7 +871,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
work_area.width, MIN_SANE_AREA); work_area.width, MIN_SANE_AREA);
if (work_area.width < 1) if (work_area.width < 1)
{ {
work_area.x = (workspace->screen->rect.width - MIN_SANE_AREA)/2; work_area.x = (workspace->screen->display->rect.width - MIN_SANE_AREA)/2;
work_area.width = MIN_SANE_AREA; work_area.width = MIN_SANE_AREA;
} }
else else
@@ -888,7 +888,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
work_area.height, MIN_SANE_AREA); work_area.height, MIN_SANE_AREA);
if (work_area.height < 1) if (work_area.height < 1)
{ {
work_area.y = (workspace->screen->rect.height - MIN_SANE_AREA)/2; work_area.y = (workspace->screen->display->rect.height - MIN_SANE_AREA)/2;
work_area.height = MIN_SANE_AREA; work_area.height = MIN_SANE_AREA;
} }
else else
@@ -955,7 +955,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
g_assert (workspace->screen_edges == NULL); g_assert (workspace->screen_edges == NULL);
g_assert (workspace->monitor_edges == NULL); g_assert (workspace->monitor_edges == NULL);
workspace->screen_edges = workspace->screen_edges =
meta_rectangle_find_onscreen_edges (&workspace->screen->rect, meta_rectangle_find_onscreen_edges (&workspace->screen->display->rect,
workspace->all_struts); workspace->all_struts);
tmp = NULL; tmp = NULL;
for (l = logical_monitors; l; l = l->next) for (l = logical_monitors; l; l = l->next)
@@ -1035,7 +1035,7 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
META_SCREEN_DOWN)) META_SCREEN_DOWN))
continue; continue;
strut->rect.height = screen->rect.height - strut->rect.y; strut->rect.height = screen->display->rect.height - strut->rect.y;
break; break;
case META_SIDE_LEFT: case META_SIDE_LEFT:
if (meta_monitor_manager_get_logical_monitor_neighbor (monitor_manager, if (meta_monitor_manager_get_logical_monitor_neighbor (monitor_manager,
@@ -1052,7 +1052,7 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
META_SCREEN_RIGHT)) META_SCREEN_RIGHT))
continue; continue;
strut->rect.width = screen->rect.width - strut->rect.x; strut->rect.width = screen->display->rect.width - strut->rect.x;
break; break;
} }
} }

7
src/meta/display.h
View File

@@ -191,4 +191,11 @@ gchar * meta_display_get_pad_action_label (MetaDisplay *display,
MetaPadActionType action_type, MetaPadActionType action_type,
guint action_number); guint action_number);
void meta_display_get_size (MetaDisplay *display,
int *width,
int *height);
void meta_display_set_cursor (MetaDisplay *display,
MetaCursor cursor);
#endif #endif

7
src/meta/screen.h
View File

@@ -38,10 +38,6 @@ GType meta_screen_get_type (void);
MetaDisplay *meta_screen_get_display (MetaScreen *screen); MetaDisplay *meta_screen_get_display (MetaScreen *screen);
void meta_screen_get_size (MetaScreen *screen,
int *width,
int *height);
void meta_screen_set_cm_selection (MetaScreen *screen); void meta_screen_set_cm_selection (MetaScreen *screen);
GSList *meta_screen_get_startup_sequences (MetaScreen *screen); GSList *meta_screen_get_startup_sequences (MetaScreen *screen);
@@ -120,7 +116,4 @@ void meta_screen_override_workspace_layout (MetaScreen *screen,
int n_rows, int n_rows,
int n_columns); int n_columns);
void meta_screen_set_cursor (MetaScreen *screen,
MetaCursor cursor);
#endif #endif

2
src/x11/meta-x11-display-private.h
View File

@@ -94,4 +94,6 @@ Window meta_x11_display_create_offscreen_window (MetaX11Display *x11_display,
Cursor meta_x11_display_create_x_cursor (MetaX11Display *x11_display, Cursor meta_x11_display_create_x_cursor (MetaX11Display *x11_display,
MetaCursor cursor); MetaCursor cursor);
void meta_x11_display_reload_cursor (MetaX11Display *x11_display);
#endif /* META_X11_DISPLAY_PRIVATE_H */ #endif /* META_X11_DISPLAY_PRIVATE_H */

52
src/x11/meta-x11-display.c
View File

@@ -47,7 +47,8 @@
#include <X11/extensions/Xdamage.h> #include <X11/extensions/Xdamage.h>
#include <X11/extensions/Xfixes.h> #include <X11/extensions/Xfixes.h>
#include "backends/meta-backend-private.h"
#include "backends/x11/meta-backend-x11.h"
#include "core/util-private.h" #include "core/util-private.h"
#include "meta/errors.h" #include "meta/errors.h"
@@ -60,6 +61,8 @@ G_DEFINE_TYPE (MetaX11Display, meta_x11_display, G_TYPE_OBJECT)
static char *get_screen_name (Display *xdisplay, static char *get_screen_name (Display *xdisplay,
int number); int number);
static void update_cursor_theme (MetaX11Display *x11_display);
static void static void
meta_x11_display_dispose (GObject *object) meta_x11_display_dispose (GObject *object)
{ {
@@ -388,6 +391,14 @@ meta_x11_display_new (MetaDisplay *display, GError **error)
query_xfixes_extension (x11_display); query_xfixes_extension (x11_display);
query_xi_extension (x11_display); query_xi_extension (x11_display);
g_signal_connect_object (display,
"cursor-updated",
G_CALLBACK (update_cursor_theme),
x11_display,
G_CONNECT_SWAPPED);
update_cursor_theme (x11_display);
return x11_display; return x11_display;
} }
@@ -509,3 +520,42 @@ get_screen_name (Display *xdisplay,
return scr; return scr;
} }
void
meta_x11_display_reload_cursor (MetaX11Display *x11_display)
{
Cursor xcursor;
MetaCursor cursor = x11_display->display->current_cursor;
/* Set a cursor for X11 applications that don't specify their own */
xcursor = meta_x11_display_create_x_cursor (x11_display, cursor);
XDefineCursor (x11_display->xdisplay, x11_display->xroot, xcursor);
XFlush (x11_display->xdisplay);
XFreeCursor (x11_display->xdisplay, xcursor);
}
static void
set_cursor_theme (Display *xdisplay)
{
XcursorSetTheme (xdisplay, meta_prefs_get_cursor_theme ());
XcursorSetDefaultSize (xdisplay, meta_prefs_get_cursor_size ());
}
static void
update_cursor_theme (MetaX11Display *x11_display)
{
{
set_cursor_theme (x11_display->xdisplay);
meta_x11_display_reload_cursor (x11_display);
}
{
MetaBackend *backend = meta_get_backend ();
if (META_IS_BACKEND_X11 (backend))
{
Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));
set_cursor_theme (xdisplay);
}
}
}

4
src/x11/window-x11.c
View File

@@ -1316,7 +1316,7 @@ meta_window_x11_update_struts (MetaWindow *window)
temp = g_new (MetaStrut, 1); temp = g_new (MetaStrut, 1);
temp->side = 1 << i; /* See MetaSide def. Matches nicely, eh? */ temp->side = 1 << i; /* See MetaSide def. Matches nicely, eh? */
temp->rect = window->screen->rect; temp->rect = window->display->rect;
switch (temp->side) switch (temp->side)
{ {
case META_SIDE_RIGHT: case META_SIDE_RIGHT:
@@ -1379,7 +1379,7 @@ meta_window_x11_update_struts (MetaWindow *window)
temp = g_new (MetaStrut, 1); temp = g_new (MetaStrut, 1);
temp->side = 1 << i; temp->side = 1 << i;
temp->rect = window->screen->rect; temp->rect = window->display->rect;
switch (temp->side) switch (temp->side)
{ {
case META_SIDE_RIGHT: case META_SIDE_RIGHT: