From e22bbd4b14174d381395fd440942e9f2d1ac6c22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20=C3=85dahl?= Date: Mon, 28 Nov 2016 20:11:24 +0800 Subject: [PATCH] MetaScreen: Remove redundant copy of logical monitors array It was just pointer to the actual list; having to synchronize a list of logical monitors with the actual monitors managed by the backend is unnecessary. https://bugzilla.gnome.org/show_bug.cgi?id=777732 --- src/backends/meta-monitor-manager-private.h | 2 + src/backends/meta-monitor-manager.c | 9 +- src/core/constraints.c | 20 +- src/core/place.c | 12 +- src/core/screen-private.h | 3 - src/core/screen.c | 246 +++++++++++++++----- src/core/window.c | 75 ++++-- src/core/workspace.c | 61 +++-- 8 files changed, 320 insertions(+), 108 deletions(-) diff --git a/src/backends/meta-monitor-manager-private.h b/src/backends/meta-monitor-manager-private.h index efdd76fd8..7a35fa58d 100644 --- a/src/backends/meta-monitor-manager-private.h +++ b/src/backends/meta-monitor-manager-private.h @@ -363,6 +363,8 @@ struct _MetaMonitorManagerClass void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager); +int meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager); + MetaLogicalMonitor *meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager, unsigned int *n_logical_monitors); diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c index dfa8766cd..d1d8f0066 100644 --- a/src/backends/meta-monitor-manager.c +++ b/src/backends/meta-monitor-manager.c @@ -1290,11 +1290,18 @@ meta_monitor_manager_get (void) return meta_backend_get_monitor_manager (backend); } +int +meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager) +{ + return (int) manager->n_logical_monitors; +} + MetaLogicalMonitor * meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager, unsigned int *n_logical_monitors) { - *n_logical_monitors = manager->n_logical_monitors; + if (n_logical_monitors) + *n_logical_monitors = manager->n_logical_monitors; return manager->logical_monitors; } diff --git a/src/core/constraints.c b/src/core/constraints.c index 14ab7c376..822d79ca8 100644 --- a/src/core/constraints.c +++ b/src/core/constraints.c @@ -27,6 +27,8 @@ #include "workspace-private.h" #include "place.h" #include +#include "backends/meta-backend-private.h" +#include "backends/meta-monitor-manager-private.h" #include #include @@ -388,17 +390,23 @@ setup_constraint_info (ConstraintInfo *info, } else { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; int i = 0; long monitor; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, NULL); + monitor = window->fullscreen_monitors[i]; - info->entire_monitor = - window->screen->logical_monitors[monitor].rect; + info->entire_monitor = logical_monitors[monitor].rect; for (i = 1; i <= 3; i++) { monitor = window->fullscreen_monitors[i]; meta_rectangle_union (&info->entire_monitor, - &window->screen->logical_monitors[monitor].rect, + &logical_monitors[monitor].rect, &info->entire_monitor); } } @@ -1441,6 +1449,10 @@ constrain_to_single_monitor (MetaWindow *window, ConstraintPriority priority, gboolean check_only) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR) return TRUE; @@ -1451,7 +1463,7 @@ constrain_to_single_monitor (MetaWindow *window, */ if (window->type == META_WINDOW_DESKTOP || window->type == META_WINDOW_DOCK || - window->screen->n_logical_monitors == 1 || + meta_monitor_manager_get_num_logical_monitors (monitor_manager) == 1 || !window->require_on_single_monitor || !window->frame || info->is_user_action || diff --git a/src/core/place.c b/src/core/place.c index 10db54a50..decb59075 100644 --- a/src/core/place.c +++ b/src/core/place.c @@ -26,6 +26,8 @@ #include "boxes-private.h" #include "place.h" +#include "backends/meta-backend-private.h" +#include #include #include #include @@ -516,8 +518,16 @@ find_first_fit (MetaWindow *window, #ifdef WITH_VERBOSE_MODE { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; char monitor_location_string[RECT_LENGTH]; - meta_rectangle_to_string (&window->screen->logical_monitors[monitor].rect, + + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, NULL); + + meta_rectangle_to_string (&logical_monitors[monitor].rect, monitor_location_string); meta_topic (META_DEBUG_XINERAMA, "Natural monitor is %s\n", diff --git a/src/core/screen-private.h b/src/core/screen-private.h index e4cc0633e..da7fbd86c 100644 --- a/src/core/screen-private.h +++ b/src/core/screen-private.h @@ -75,9 +75,6 @@ struct _MetaScreen Atom wm_sn_atom; guint32 wm_sn_timestamp; - MetaLogicalMonitor *logical_monitors; - int n_logical_monitors; - int primary_monitor_index; gboolean has_xinerama_indices; /* Cache the current monitor */ diff --git a/src/core/screen.c b/src/core/screen.c index 70a8b1fdd..6ba1f10d5 100644 --- a/src/core/screen.c +++ b/src/core/screen.c @@ -340,8 +340,14 @@ set_wm_icon_size_hint (MetaScreen *screen) static void meta_screen_ensure_xinerama_indices (MetaScreen *screen) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; XineramaScreenInfo *infos; - int n_infos, i, j; + int n_infos, j; if (screen->has_xinerama_indices) return; @@ -358,15 +364,19 @@ meta_screen_ensure_xinerama_indices (MetaScreen *screen) return; } - for (i = 0; i < screen->n_logical_monitors; ++i) + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + for (i = 0; i < n_logical_monitors; ++i) { for (j = 0; j < n_infos; ++j) { - if (screen->logical_monitors[i].rect.x == infos[j].x_org && - screen->logical_monitors[i].rect.y == infos[j].y_org && - screen->logical_monitors[i].rect.width == infos[j].width && - screen->logical_monitors[i].rect.height == infos[j].height) - screen->logical_monitors[i].xinerama_index = j; + if (logical_monitors[i].rect.x == infos[j].x_org && + logical_monitors[i].rect.y == infos[j].y_org && + logical_monitors[i].rect.width == infos[j].width && + logical_monitors[i].rect.height == infos[j].height) + logical_monitors[i].xinerama_index = j; } } @@ -377,23 +387,44 @@ int meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen, int index) { - g_return_val_if_fail (index >= 0 && index < screen->n_logical_monitors, -1); +#ifndef G_DISABLE_CHECKS + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); +#endif + + g_return_val_if_fail (index >= 0 && index < (int) n_logical_monitors, -1); meta_screen_ensure_xinerama_indices (screen); - return screen->logical_monitors[index].xinerama_index; + return logical_monitors[index].xinerama_index; } int meta_screen_xinerama_index_to_monitor_index (MetaScreen *screen, int index) { - int i; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; meta_screen_ensure_xinerama_indices (screen); - for (i = 0; i < screen->n_logical_monitors; i++) - if (screen->logical_monitors[i].xinerama_index == index) + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + for (i = 0; i < n_logical_monitors; i++) + if (logical_monitors[i].xinerama_index == index) return i; return -1; @@ -403,8 +434,6 @@ static void reload_logical_monitors (MetaScreen *screen) { GList *l; - MetaMonitorManager *manager; - unsigned int n_logical_monitors; for (l = screen->workspaces; l != NULL; l = l->next) { @@ -412,18 +441,9 @@ reload_logical_monitors (MetaScreen *screen) meta_workspace_invalidate_work_area (space); } - /* Any previous screen->logical_monitors or screen->outputs is freed by the caller */ - screen->last_monitor_index = 0; screen->has_xinerama_indices = FALSE; screen->display->monitor_cache_invalidated = TRUE; - - manager = meta_monitor_manager_get (); - - screen->logical_monitors = - meta_monitor_manager_get_logical_monitors (manager, &n_logical_monitors); - screen->n_logical_monitors = (unsigned int) n_logical_monitors; - screen->primary_monitor_index = meta_monitor_manager_get_primary_index (manager); } /* The guard window allows us to leave minimized windows mapped so @@ -807,8 +827,6 @@ meta_screen_free (MetaScreen *screen, if (screen->check_fullscreen_later != 0) meta_later_remove (screen->check_fullscreen_later); - g_free (screen->logical_monitors); - if (screen->tile_preview_timeout_id) g_source_remove (screen->tile_preview_timeout_id); @@ -1394,17 +1412,26 @@ const MetaLogicalMonitor * meta_screen_get_logical_monitor_for_rect (MetaScreen *screen, MetaRectangle *rect) { - int i; - int best_monitor, monitor_score, rect_area; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i, best_monitor; + int monitor_score, rect_area; - if (screen->n_logical_monitors == 1) - return &screen->logical_monitors[0]; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + if (n_logical_monitors == 1) + return &logical_monitors[0]; best_monitor = 0; monitor_score = -1; rect_area = meta_rectangle_area (rect); - for (i = 0; i < screen->n_logical_monitors; i++) + for (i = 0; i < n_logical_monitors; i++) { gboolean result; int cur; @@ -1412,14 +1439,14 @@ meta_screen_get_logical_monitor_for_rect (MetaScreen *screen, if (rect_area > 0) { MetaRectangle dest; - result = meta_rectangle_intersect (&screen->logical_monitors[i].rect, + result = meta_rectangle_intersect (&logical_monitors[i].rect, rect, &dest); cur = meta_rectangle_area (&dest); } else { - result = meta_rectangle_contains_rect (&screen->logical_monitors[i].rect, + result = meta_rectangle_contains_rect (&logical_monitors[i].rect, rect); cur = rect_area; } @@ -1431,7 +1458,7 @@ meta_screen_get_logical_monitor_for_rect (MetaScreen *screen, } } - return &screen->logical_monitors[best_monitor]; + return &logical_monitors[best_monitor]; } const MetaLogicalMonitor * @@ -1460,15 +1487,24 @@ meta_screen_get_logical_monitor_for_point (MetaScreen *screen, int x, int y) { - int i; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; - if (screen->n_logical_monitors == 1) - return &screen->logical_monitors[0]; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); - for (i = 0; i < screen->n_logical_monitors; i++) + if (n_logical_monitors == 1) + return &logical_monitors[0]; + + for (i = 0; i < n_logical_monitors; i++) { - if (POINT_IN_RECT (x, y, screen->logical_monitors[i].rect)) - return &screen->logical_monitors[i]; + if (POINT_IN_RECT (x, y, logical_monitors[i].rect)) + return &logical_monitors[i]; } return NULL; @@ -1479,13 +1515,23 @@ meta_screen_get_monitor_neighbor (MetaScreen *screen, int which_monitor, MetaScreenDirection direction) { - MetaLogicalMonitor *input = screen->logical_monitors + which_monitor; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; + MetaLogicalMonitor *input; MetaLogicalMonitor *current; - int i; - for (i = 0; i < screen->n_logical_monitors; i++) + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + input = &logical_monitors[which_monitor]; + + for (i = 0; i < n_logical_monitors; i++) { - current = screen->logical_monitors + i; + current = &logical_monitors[i]; if ((direction == META_SCREEN_RIGHT && current->rect.x == input->rect.x + input->rect.width && @@ -1523,10 +1569,19 @@ meta_screen_get_monitor_neighbor_index (MetaScreen *screen, const MetaLogicalMonitor * meta_screen_get_current_logical_monitor (MetaScreen *screen) { - int monitor_index; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + int monitor_index; - monitor_index = meta_screen_get_current_monitor (screen); - return &screen->logical_monitors[monitor_index]; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + monitor_index = meta_screen_get_current_monitor (screen); + + return &logical_monitors[monitor_index]; } const MetaLogicalMonitor * @@ -1534,10 +1589,19 @@ meta_screen_get_current_logical_monitor_for_pos (MetaScreen *screen, int x, int y) { - int monitor_index; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + int monitor_index; - monitor_index = meta_screen_get_current_monitor_for_pos (screen, x, y); - return &screen->logical_monitors[monitor_index]; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + monitor_index = meta_screen_get_current_monitor_for_pos (screen, x, y); + + return &logical_monitors[monitor_index]; } @@ -1556,11 +1620,21 @@ meta_screen_get_current_monitor_for_pos (MetaScreen *screen, int x, int y) { - if (screen->n_logical_monitors == 1) + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + if (n_logical_monitors == 1) return 0; else if (screen->display->monitor_cache_invalidated) { - int i; + unsigned int i; MetaRectangle pointer_position; pointer_position.x = x; pointer_position.y = y; @@ -1569,9 +1643,9 @@ meta_screen_get_current_monitor_for_pos (MetaScreen *screen, screen->display->monitor_cache_invalidated = FALSE; screen->last_monitor_index = 0; - for (i = 0; i < screen->n_logical_monitors; i++) + for (i = 0; i < n_logical_monitors; i++) { - if (meta_rectangle_contains_rect (&screen->logical_monitors[i].rect, + if (meta_rectangle_contains_rect (&logical_monitors[i].rect, &pointer_position)) { screen->last_monitor_index = i; @@ -1600,9 +1674,14 @@ meta_screen_get_current_monitor_for_pos (MetaScreen *screen, int meta_screen_get_current_monitor (MetaScreen *screen) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (screen); + int n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); - if (screen->n_logical_monitors == 1) + if (n_logical_monitors == 1) return 0; /* Sadly, we have to do it this way. Yuck. @@ -1630,9 +1709,13 @@ meta_screen_get_current_monitor (MetaScreen *screen) int meta_screen_get_n_monitors (MetaScreen *screen) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + g_return_val_if_fail (META_IS_SCREEN (screen), 0); - return screen->n_logical_monitors; + return meta_monitor_manager_get_num_logical_monitors (monitor_manager); } /** @@ -1646,9 +1729,13 @@ meta_screen_get_n_monitors (MetaScreen *screen) int meta_screen_get_primary_monitor (MetaScreen *screen) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + g_return_val_if_fail (META_IS_SCREEN (screen), 0); - return screen->primary_monitor_index; + return meta_monitor_manager_get_primary_index (monitor_manager); } /** @@ -1664,11 +1751,23 @@ meta_screen_get_monitor_geometry (MetaScreen *screen, int monitor, MetaRectangle *geometry) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; +#ifndef G_DISABLE_CHECKS + int n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); +#endif + g_return_if_fail (META_IS_SCREEN (screen)); - g_return_if_fail (monitor >= 0 && monitor < screen->n_logical_monitors); + g_return_if_fail (monitor >= 0 && monitor < n_logical_monitors); g_return_if_fail (geometry != NULL); - *geometry = screen->logical_monitors[monitor].rect; + logical_monitors = meta_monitor_manager_get_logical_monitors (monitor_manager, + NULL); + + *geometry = logical_monitors[monitor].rect; } #define _NET_WM_ORIENTATION_HORZ 0 @@ -2721,14 +2820,23 @@ static gboolean check_fullscreen_func (gpointer data) { MetaScreen *screen = data; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; MetaWindow *window; GSList *fullscreen_monitors = NULL; GSList *obscured_monitors = NULL; gboolean in_fullscreen_changed = FALSE; - int i; screen->check_fullscreen_later = 0; + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + /* We consider a monitor in fullscreen if it contains a fullscreen window; * however we make an exception for maximized windows above the fullscreen * one, as in that case window+chrome fully obscure the fullscreen window. @@ -2788,9 +2896,9 @@ check_fullscreen_func (gpointer data) g_slist_free (obscured_monitors); - for (i = 0; i < screen->n_logical_monitors; i++) + for (i = 0; i < n_logical_monitors; i++) { - MetaLogicalMonitor *logical_monitor = &screen->logical_monitors[i]; + MetaLogicalMonitor *logical_monitor = &logical_monitors[i]; gboolean in_fullscreen = g_slist_find (fullscreen_monitors, GINT_TO_POINTER (i + 1)) != NULL; if (in_fullscreen != logical_monitor->in_fullscreen) { @@ -2842,12 +2950,24 @@ gboolean meta_screen_get_monitor_in_fullscreen (MetaScreen *screen, int monitor) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; +#ifndef G_DISABLE_CHECKS + int n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); +#endif + g_return_val_if_fail (META_IS_SCREEN (screen), FALSE); g_return_val_if_fail (monitor >= 0 && - monitor < screen->n_logical_monitors, FALSE); + monitor < n_logical_monitors, FALSE); + + logical_monitors = meta_monitor_manager_get_logical_monitors (monitor_manager, + NULL); /* We use -1 as a flag to mean "not known yet" for notification purposes */ - return screen->logical_monitors[monitor].in_fullscreen == TRUE; + return logical_monitors[monitor].in_fullscreen == TRUE; } gboolean diff --git a/src/core/window.c b/src/core/window.c index ed0bef0df..03a645370 100644 --- a/src/core/window.c +++ b/src/core/window.c @@ -2798,16 +2798,25 @@ meta_window_is_fullscreen (MetaWindow *window) gint * meta_window_get_all_monitors (MetaWindow *window, gsize *length) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; GArray *monitors; MetaRectangle window_rect; - int i; + + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); monitors = g_array_new (FALSE, FALSE, sizeof (int)); meta_window_get_frame_rect (window, &window_rect); - for (i = 0; i < window->screen->n_logical_monitors; i++) + for (i = 0; i < n_logical_monitors; i++) { - MetaRectangle *monitor_rect = &window->screen->logical_monitors[i].rect; + MetaRectangle *monitor_rect = &logical_monitors[i].rect; if (meta_rectangle_overlap (&window_rect, monitor_rect)) g_array_append_val (monitors, i); @@ -3277,10 +3286,16 @@ meta_window_update_fullscreen_monitors (MetaWindow *window, unsigned long left, unsigned long right) { - if ((int) top < window->screen->n_logical_monitors && - (int) bottom < window->screen->n_logical_monitors && - (int) left < window->screen->n_logical_monitors && - (int) right < window->screen->n_logical_monitors) + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + int n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); + + if ((int) top < n_logical_monitors && + (int) bottom < n_logical_monitors && + (int) left < n_logical_monitors && + (int) right < n_logical_monitors) { window->fullscreen_monitors[0] = top; window->fullscreen_monitors[1] = bottom; @@ -3520,11 +3535,20 @@ static MetaLogicalMonitor * find_monitor_by_winsys_id (MetaWindow *window, guint winsys_id) { - int i; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; - for (i = 0; i < window->screen->n_logical_monitors; i++) + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + for (i = 0; i < n_logical_monitors; i++) { - MetaLogicalMonitor *logical_monitor = &window->screen->logical_monitors[i]; + MetaLogicalMonitor *logical_monitor = &logical_monitors[i]; if (logical_monitor->winsys_id == winsys_id) return logical_monitor; @@ -3538,6 +3562,12 @@ find_monitor_by_winsys_id (MetaWindow *window, void meta_window_update_for_monitors_changed (MetaWindow *window) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + int primary_monitor_index; const MetaLogicalMonitor *old, *new; if (window->fullscreen_monitors[0] != -1) @@ -3558,9 +3588,15 @@ meta_window_update_for_monitors_changed (MetaWindow *window) if (!new) new = find_monitor_by_winsys_id (window, old->winsys_id); + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + primary_monitor_index = + meta_monitor_manager_get_primary_index (monitor_manager); + /* Fall back to primary if everything else failed */ if (!new) - new = &window->screen->logical_monitors[window->screen->primary_monitor_index]; + new = &logical_monitors[primary_monitor_index]; if (window->tile_mode != META_TILE_NONE) window->tile_monitor_number = new->number; @@ -5690,14 +5726,20 @@ update_move (MetaWindow *window, else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) && window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + int n_logical_monitors; const MetaLogicalMonitor *wmonitor; MetaRectangle work_area; int monitor; window->tile_mode = META_TILE_NONE; wmonitor = window->monitor; + n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); - for (monitor = 0; monitor < window->screen->n_logical_monitors; monitor++) + for (monitor = 0; monitor < n_logical_monitors; monitor++) { meta_window_get_work_area_for_monitor (window, monitor, &work_area); @@ -6067,12 +6109,19 @@ get_work_area_monitor (MetaWindow *window, MetaRectangle *area, int which_monitor) { + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + MetaLogicalMonitor *logical_monitors; GList *tmp; g_assert (which_monitor >= 0); + logical_monitors = meta_monitor_manager_get_logical_monitors (monitor_manager, + NULL); + /* Initialize to the whole monitor */ - *area = window->screen->logical_monitors[which_monitor].rect; + *area = logical_monitors[which_monitor].rect; tmp = meta_window_get_workspaces (window); while (tmp != NULL) diff --git a/src/core/workspace.c b/src/core/workspace.c index 3aec3af88..5ea817b0c 100644 --- a/src/core/workspace.c +++ b/src/core/workspace.c @@ -32,6 +32,7 @@ */ #include +#include "backends/meta-backend-private.h" #include "screen-private.h" #include #include "workspace-private.h" @@ -265,15 +266,10 @@ assert_workspace_empty (MetaWorkspace *workspace) void meta_workspace_remove (MetaWorkspace *workspace) { - MetaScreen *screen; - int i; - g_return_if_fail (workspace != workspace->screen->active_workspace); assert_workspace_empty (workspace); - screen = workspace->screen; - workspace->screen->workspaces = g_list_remove (workspace->screen->workspaces, workspace); @@ -293,8 +289,10 @@ meta_workspace_remove (MetaWorkspace *workspace) if (!workspace->work_areas_invalid) { + int i; + workspace_free_all_struts (workspace); - for (i = 0; i < screen->n_logical_monitors; i++) + for (i = 0; i < workspace->n_monitor_regions; i++) meta_rectangle_free_list_and_elements (workspace->monitor_region[i]); g_free (workspace->monitor_region); meta_rectangle_free_list_and_elements (workspace->screen_region); @@ -679,8 +677,8 @@ meta_workspace_list_windows (MetaWorkspace *workspace) void meta_workspace_invalidate_work_area (MetaWorkspace *workspace) { - GList *windows, *l; int i; + GList *windows, *l; if (workspace->work_areas_invalid) { @@ -704,7 +702,7 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace) workspace_free_all_struts (workspace); - for (i = 0; i < workspace->screen->n_logical_monitors; i++) + for (i = 0; i < workspace->n_monitor_regions; i++) meta_rectangle_free_list_and_elements (workspace->monitor_region[i]); g_free (workspace->monitor_region); meta_rectangle_free_list_and_elements (workspace->screen_region); @@ -751,10 +749,15 @@ copy_strut_list(GSList *original) static void ensure_work_areas_validated (MetaWorkspace *workspace) { - GList *windows; - GList *tmp; - MetaRectangle work_area; - int i; /* C89 absolutely sucks... */ + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + GList *windows; + GList *tmp; + MetaLogicalMonitor *logical_monitors; + unsigned int n_logical_monitors; + unsigned int i; + MetaRectangle work_area; if (!workspace->work_areas_invalid) return; @@ -788,15 +791,20 @@ ensure_work_areas_validated (MetaWorkspace *workspace) g_assert (workspace->monitor_region == NULL); g_assert (workspace->screen_region == NULL); - workspace->monitor_region = g_new (GList*, - workspace->screen->n_logical_monitors); - for (i = 0; i < workspace->screen->n_logical_monitors; i++) + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager, + &n_logical_monitors); + + workspace->monitor_region = g_new (GList*, n_logical_monitors); + for (i = 0; i < n_logical_monitors; i++) { workspace->monitor_region[i] = meta_rectangle_get_minimal_spanning_set_for_region ( - &workspace->screen->logical_monitors[i].rect, + &logical_monitors[i].rect, workspace->all_struts); } + workspace->n_monitor_regions = (int) n_logical_monitors; + workspace->screen_region = meta_rectangle_get_minimal_spanning_set_for_region ( &workspace->screen->rect, @@ -860,12 +868,11 @@ ensure_work_areas_validated (MetaWorkspace *workspace) /* Now find the work areas for each monitor */ g_free (workspace->work_area_monitor); - workspace->work_area_monitor = g_new (MetaRectangle, - workspace->screen->n_logical_monitors); + workspace->work_area_monitor = g_new (MetaRectangle, n_logical_monitors); - for (i = 0; i < workspace->screen->n_logical_monitors; i++) + for (i = 0; i < n_logical_monitors; i++) { - work_area = workspace->screen->logical_monitors[i].rect; + work_area = logical_monitors[i].rect; if (workspace->monitor_region[i] == NULL) /* FIXME: constraints.c untested with this, but it might be nice for @@ -907,8 +914,8 @@ ensure_work_areas_validated (MetaWorkspace *workspace) meta_rectangle_find_onscreen_edges (&workspace->screen->rect, workspace->all_struts); tmp = NULL; - for (i = 0; i < workspace->screen->n_logical_monitors; i++) - tmp = g_list_prepend (tmp, &workspace->screen->logical_monitors[i].rect); + for (i = 0; i < n_logical_monitors; i++) + tmp = g_list_prepend (tmp, &logical_monitors[i].rect); workspace->monitor_edges = meta_rectangle_find_nonintersected_monitor_edges (tmp, workspace->all_struts); @@ -1013,10 +1020,18 @@ meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace, int which_monitor, MetaRectangle *area) { +#ifndef G_DISABLE_ASSERT + MetaBackend *backend = meta_get_backend(); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + int n_logical_monitors = + meta_monitor_manager_get_num_logical_monitors (monitor_manager); +#endif + g_assert (which_monitor >= 0); ensure_work_areas_validated (workspace); - g_assert (which_monitor < workspace->screen->n_logical_monitors); + g_assert (which_monitor < n_logical_monitors); *area = workspace->work_area_monitor[which_monitor]; }