isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-26 01:50:42 -05:00
Code Issues Packages Projects Releases Wiki Activity

MetaScreen: Remove redundant copy of logical monitors array

Browse Source 
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
This commit is contained in:
Jonas Ådahl 2016-11-28 20:11:24 +08:00
parent 103df63023
commit e22bbd4b14
8 changed files with 320 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/backends/meta-monitor-manager-private.h
View File

@ -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);

9
src/backends/meta-monitor-manager.c
View File

@ -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;
}

20
src/core/constraints.c
View File

@ -27,6 +27,8 @@
#include "workspace-private.h"
#include "place.h"
#include <meta/prefs.h>
#include "backends/meta-backend-private.h"
#include "backends/meta-monitor-manager-private.h"
#include <stdlib.h>
#include <math.h>
@ -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 ||

12
src/core/place.c
View File

@ -26,6 +26,8 @@
#include "boxes-private.h"
#include "place.h"
#include "backends/meta-backend-private.h"
#include <meta/meta-backend.h>
#include <meta/workspace.h>
#include <meta/prefs.h>
#include <gdk/gdk.h>
@ -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",

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

@ -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 */

246
src/core/screen.c
View File

@ -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

75
src/core/window.c
View File

@ -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)

61
src/core/workspace.c
View File

@ -32,6 +32,7 @@
*/
#include <config.h>
#include "backends/meta-backend-private.h"
#include "screen-private.h"
#include <meta/workspace.h>
#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];
}