isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-23 19:42:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refer to monitors as "monitors" rather than "xineramas"

Browse Source 
http://bugzilla.gnome.org/show_bug.cgi?id=593686
This commit is contained in:
Dan Winship 2009-08-31 09:52:16 -04:00
parent e83c24c91b
commit 3a1e492afc
17 changed files with 479 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/core/boxes.c
View File

@ -535,7 +535,7 @@ meta_rectangle_get_minimal_spanning_set_for_region (
* enough to make this worth bothering. Further, it is only called from * enough to make this worth bothering. Further, it is only called from
* workspace.c:ensure_work_areas_validated (at least as of the time of * workspace.c:ensure_work_areas_validated (at least as of the time of
* writing this comment), which in turn should only be called if the * writing this comment), which in turn should only be called if the
* strut list changes or the screen or xinerama size changes. If it ever * strut list changes or the screen or monitor size changes. If it ever
* does show up on profiles (most likely because people start using * does show up on profiles (most likely because people start using
* ridiculously huge numbers of partial struts), possible optimizations * ridiculously huge numbers of partial struts), possible optimizations
* include: * include:
@ -1792,14 +1792,14 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
} }
GList* GList*
meta_rectangle_find_nonintersected_xinerama_edges ( meta_rectangle_find_nonintersected_monitor_edges (
const GList *xinerama_rects, const GList *monitor_rects,
const GSList *all_struts) const GSList *all_struts)
{ {
/* This function cannot easily be merged with /* This function cannot easily be merged with
* meta_rectangle_find_onscreen_edges() because real screen edges * meta_rectangle_find_onscreen_edges() because real screen edges
* and strut edges both are of the type "there ain't anything * and strut edges both are of the type "there ain't anything
* immediately on the other side"; xinerama edges are different. * immediately on the other side"; monitor edges are different.
*/ */
GList *ret; GList *ret;
const GList *cur; const GList *cur;
@ -1808,14 +1808,14 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* Initialize the return list to be empty */ /* Initialize the return list to be empty */
ret = NULL; ret = NULL;
/* start of ret with all the edges of xineramas that are adjacent to /* start of ret with all the edges of monitors that are adjacent to
* another xinerama. * another monitor.
*/ */
cur = xinerama_rects; cur = monitor_rects;
while (cur) while (cur)
{ {
MetaRectangle *cur_rect = cur->data; MetaRectangle *cur_rect = cur->data;
const GList *compare = xinerama_rects; const GList *compare = monitor_rects;
while (compare) while (compare)
{ {
MetaRectangle *compare_rect = compare->data; MetaRectangle *compare_rect = compare->data;
@ -1849,15 +1849,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* If the rectangles really are adjacent */ /* If the rectangles really are adjacent */
if (x != INT_MIN) if (x != INT_MIN)
{ {
/* We need a left edge for the xinerama on the right, and /* We need a left edge for the monitor on the right, and
* a right edge for the xinerama on the left. Just fill * a right edge for the monitor on the left. Just fill
* up the edges and stick 'em on the list. * up the edges and stick 'em on the list.
*/ */
MetaEdge *new_edge = g_new (MetaEdge, 1); MetaEdge *new_edge = g_new (MetaEdge, 1);
new_edge->rect = meta_rect (x, y, width, height); new_edge->rect = meta_rect (x, y, width, height);
new_edge->side_type = side_type; new_edge->side_type = side_type;
new_edge->edge_type = META_EDGE_XINERAMA; new_edge->edge_type = META_EDGE_MONITOR;
ret = g_list_prepend (ret, new_edge); ret = g_list_prepend (ret, new_edge);
} }
@ -1892,15 +1892,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* If the rectangles really are adjacent */ /* If the rectangles really are adjacent */
if (y != INT_MIN) if (y != INT_MIN)
{ {
/* We need a top edge for the xinerama on the bottom, and /* We need a top edge for the monitor on the bottom, and
* a bottom edge for the xinerama on the top. Just fill * a bottom edge for the monitor on the top. Just fill
* up the edges and stick 'em on the list. * up the edges and stick 'em on the list.
*/ */
MetaEdge *new_edge = g_new (MetaEdge, 1); MetaEdge *new_edge = g_new (MetaEdge, 1);
new_edge->rect = meta_rect (x, y, width, height); new_edge->rect = meta_rect (x, y, width, height);
new_edge->side_type = side_type; new_edge->side_type = side_type;
new_edge->edge_type = META_EDGE_XINERAMA; new_edge->edge_type = META_EDGE_MONITOR;
ret = g_list_prepend (ret, new_edge); ret = g_list_prepend (ret, new_edge);
} }

164
src/core/constraints.c
View File

@ -93,7 +93,7 @@ typedef enum
{ {
PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */ PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
PRIORITY_ASPECT_RATIO = 0, PRIORITY_ASPECT_RATIO = 0,
PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA = 0, PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR = 0,
PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1, PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1,
PRIORITY_SIZE_HINTS_INCREMENTS = 1, PRIORITY_SIZE_HINTS_INCREMENTS = 1,
PRIORITY_MAXIMIZATION = 2, PRIORITY_MAXIMIZATION = 2,
@ -127,17 +127,17 @@ typedef struct
int resize_gravity; int resize_gravity;
FixedDirections fixed_directions; FixedDirections fixed_directions;
/* work_area_xinerama - current xinerama region minus struts /* work_area_monitor - current monitor region minus struts
* entire_xinerama - current xienrama, including strut regions * entire_monitor - current monitor, including strut regions
*/ */
MetaRectangle work_area_xinerama; MetaRectangle work_area_monitor;
MetaRectangle entire_xinerama; MetaRectangle entire_monitor;
/* Spanning rectangles for the non-covered (by struts) region of the /* Spanning rectangles for the non-covered (by struts) region of the
* screen and also for just the current xinerama * screen and also for just the current monitor
*/ */
GList *usable_screen_region; GList *usable_screen_region;
GList *usable_xinerama_region; GList *usable_monitor_region;
} ConstraintInfo; } ConstraintInfo;
static gboolean constrain_maximization (MetaWindow *window, static gboolean constrain_maximization (MetaWindow *window,
@ -160,7 +160,7 @@ static gboolean constrain_aspect_ratio (MetaWindow *window,
ConstraintInfo *info, ConstraintInfo *info,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only); gboolean check_only);
static gboolean constrain_to_single_xinerama (MetaWindow *window, static gboolean constrain_to_single_monitor (MetaWindow *window,
ConstraintInfo *info, ConstraintInfo *info,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only); gboolean check_only);
@ -214,7 +214,7 @@ static const Constraint all_constraints[] = {
{constrain_size_increments, "constrain_size_increments"}, {constrain_size_increments, "constrain_size_increments"},
{constrain_size_limits, "constrain_size_limits"}, {constrain_size_limits, "constrain_size_limits"},
{constrain_aspect_ratio, "constrain_aspect_ratio"}, {constrain_aspect_ratio, "constrain_aspect_ratio"},
{constrain_to_single_xinerama, "constrain_to_single_xinerama"}, {constrain_to_single_monitor, "constrain_to_single_monitor"},
{constrain_fully_onscreen, "constrain_fully_onscreen"}, {constrain_fully_onscreen, "constrain_fully_onscreen"},
{constrain_titlebar_visible, "constrain_titlebar_visible"}, {constrain_titlebar_visible, "constrain_titlebar_visible"},
{constrain_partially_onscreen, "constrain_partially_onscreen"}, {constrain_partially_onscreen, "constrain_partially_onscreen"},
@ -311,7 +311,7 @@ meta_window_constrain (MetaWindow *window,
*new = info.current; *new = info.current;
/* We may need to update window->require_fully_onscreen, /* We may need to update window->require_fully_onscreen,
* window->require_on_single_xinerama, and perhaps other quantities * window->require_on_single_monitor, and perhaps other quantities
* if this was a user move or user move-and-resize operation. * if this was a user move or user move-and-resize operation.
*/ */
update_onscreen_requirements (window, &info); update_onscreen_requirements (window, &info);
@ -333,7 +333,7 @@ setup_constraint_info (ConstraintInfo *info,
const MetaRectangle *orig, const MetaRectangle *orig,
MetaRectangle *new) MetaRectangle *new)
{ {
const MetaXineramaScreenInfo *xinerama_info; const MetaMonitorInfo *monitor_info;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
info->orig = *orig; info->orig = *orig;
@ -387,15 +387,15 @@ setup_constraint_info (ConstraintInfo *info,
if (!info->is_user_action) if (!info->is_user_action)
info->fixed_directions = FIXED_DIRECTION_NONE; info->fixed_directions = FIXED_DIRECTION_NONE;
xinerama_info = monitor_info =
meta_screen_get_xinerama_for_rect (window->screen, &info->current); meta_screen_get_monitor_for_rect (window->screen, &info->current);
meta_window_get_work_area_for_xinerama (window, meta_window_get_work_area_for_monitor (window,
xinerama_info->number, monitor_info->number,
&info->work_area_xinerama); &info->work_area_monitor);
if (!window->fullscreen || window->fullscreen_monitors[0] == -1) if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
{ {
info->entire_xinerama = xinerama_info->rect; info->entire_monitor = monitor_info->rect;
} }
else else
{ {
@ -403,28 +403,28 @@ setup_constraint_info (ConstraintInfo *info,
long monitor; long monitor;
monitor = window->fullscreen_monitors[i]; monitor = window->fullscreen_monitors[i];
info->entire_xinerama = info->entire_monitor =
window->screen->xinerama_infos[monitor].rect; window->screen->monitor_infos[monitor].rect;
for (i = 1; i <= 3; i++) for (i = 1; i <= 3; i++)
{ {
monitor = window->fullscreen_monitors[i]; monitor = window->fullscreen_monitors[i];
meta_rectangle_union (&info->entire_xinerama, meta_rectangle_union (&info->entire_monitor,
&window->screen->xinerama_infos[monitor].rect, &window->screen->monitor_infos[monitor].rect,
&info->entire_xinerama); &info->entire_monitor);
} }
} }
cur_workspace = window->screen->active_workspace; cur_workspace = window->screen->active_workspace;
info->usable_screen_region = info->usable_screen_region =
meta_workspace_get_onscreen_region (cur_workspace); meta_workspace_get_onscreen_region (cur_workspace);
info->usable_xinerama_region = info->usable_monitor_region =
meta_workspace_get_onxinerama_region (cur_workspace, meta_workspace_get_onmonitor_region (cur_workspace,
xinerama_info->number); monitor_info->number);
/* Workaround braindead legacy apps that don't know how to /* Workaround braindead legacy apps that don't know how to
* fullscreen themselves properly. * fullscreen themselves properly.
*/ */
if (meta_rectangle_equal (new, &xinerama_info->rect) && if (meta_rectangle_equal (new, &monitor_info->rect) &&
window->has_fullscreen_func && window->has_fullscreen_func &&
!window->fullscreen) !window->fullscreen)
{ {
@ -448,8 +448,8 @@ setup_constraint_info (ConstraintInfo *info,
" is_user_action : %s\n" " is_user_action : %s\n"
" resize_gravity : %s\n" " resize_gravity : %s\n"
" fixed_directions: %s\n" " fixed_directions: %s\n"
" work_area_xinerama: %d,%d +%d,%d\n" " work_area_monitor: %d,%d +%d,%d\n"
" entire_xinerama : %d,%d +%d,%d\n", " entire_monitor : %d,%d +%d,%d\n",
info->orig.x, info->orig.y, info->orig.width, info->orig.height, info->orig.x, info->orig.y, info->orig.width, info->orig.height,
info->current.x, info->current.y, info->current.x, info->current.y,
info->current.width, info->current.height, info->current.width, info->current.height,
@ -465,11 +465,11 @@ setup_constraint_info (ConstraintInfo *info,
(info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" : (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
(info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" : (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
"Freakin' Invalid Stupid", "Freakin' Invalid Stupid",
info->work_area_xinerama.x, info->work_area_xinerama.y, info->work_area_monitor.x, info->work_area_monitor.y,
info->work_area_xinerama.width, info->work_area_monitor.width,
info->work_area_xinerama.height, info->work_area_monitor.height,
info->entire_xinerama.x, info->entire_xinerama.y, info->entire_monitor.x, info->entire_monitor.y,
info->entire_xinerama.width, info->entire_xinerama.height); info->entire_monitor.width, info->entire_monitor.height);
} }
static void static void
@ -493,25 +493,25 @@ place_window_if_needed(MetaWindow *window,
{ {
MetaRectangle placed_rect = info->orig; MetaRectangle placed_rect = info->orig;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
const MetaXineramaScreenInfo *xinerama_info; const MetaMonitorInfo *monitor_info;
meta_window_place (window, info->fgeom, info->orig.x, info->orig.y, meta_window_place (window, info->fgeom, info->orig.x, info->orig.y,
&placed_rect.x, &placed_rect.y); &placed_rect.x, &placed_rect.y);
did_placement = TRUE; did_placement = TRUE;
/* placing the window may have changed the xinerama. Find the /* placing the window may have changed the monitor. Find the
* new xinerama and update the ConstraintInfo * new monitor and update the ConstraintInfo
*/ */
xinerama_info = monitor_info =
meta_screen_get_xinerama_for_rect (window->screen, &placed_rect); meta_screen_get_monitor_for_rect (window->screen, &placed_rect);
info->entire_xinerama = xinerama_info->rect; info->entire_monitor = monitor_info->rect;
meta_window_get_work_area_for_xinerama (window, meta_window_get_work_area_for_monitor (window,
xinerama_info->number, monitor_info->number,
&info->work_area_xinerama); &info->work_area_monitor);
cur_workspace = window->screen->active_workspace; cur_workspace = window->screen->active_workspace;
info->usable_xinerama_region = info->usable_monitor_region =
meta_workspace_get_onxinerama_region (cur_workspace, meta_workspace_get_onmonitor_region (cur_workspace,
xinerama_info->number); monitor_info->number);
info->current.x = placed_rect.x; info->current.x = placed_rect.x;
@ -531,17 +531,17 @@ place_window_if_needed(MetaWindow *window,
/* define a sane saved_rect so that the user can unmaximize to /* define a sane saved_rect so that the user can unmaximize to
* something reasonable. * something reasonable.
*/ */
if (info->current.width >= info->work_area_xinerama.width) if (info->current.width >= info->work_area_monitor.width)
{ {
info->current.width = .75 * info->work_area_xinerama.width; info->current.width = .75 * info->work_area_monitor.width;
info->current.x = info->work_area_xinerama.x + info->current.x = info->work_area_monitor.x +
.125 * info->work_area_xinerama.width; .125 * info->work_area_monitor.width;
} }
if (info->current.height >= info->work_area_xinerama.height) if (info->current.height >= info->work_area_monitor.height)
{ {
info->current.height = .75 * info->work_area_xinerama.height; info->current.height = .75 * info->work_area_monitor.height;
info->current.y = info->work_area_xinerama.y + info->current.y = info->work_area_monitor.y +
.083 * info->work_area_xinerama.height; .083 * info->work_area_monitor.height;
} }
if (window->maximize_horizontally_after_placement || if (window->maximize_horizontally_after_placement ||
@ -589,7 +589,7 @@ update_onscreen_requirements (MetaWindow *window,
return; return;
/* USABILITY NOTE: Naturally, I only want the require_fully_onscreen, /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen,
* require_on_single_xinerama, and require_titlebar_visible flags to * require_on_single_monitor, and require_titlebar_visible flags to
* *become false* due to user interactions (which is allowed since * *become false* due to user interactions (which is allowed since
* certain constraints are ignored for user interactions regardless of * certain constraints are ignored for user interactions regardless of
* the setting of these flags). However, whether to make these flags * the setting of these flags). However, whether to make these flags
@ -603,7 +603,7 @@ update_onscreen_requirements (MetaWindow *window,
* problematic case but this may need to be revisited. * problematic case but this may need to be revisited.
*/ */
/* The require onscreen/on-single-xinerama and titlebar_visible /* The require onscreen/on-single-monitor and titlebar_visible
* stuff is relative to the outer window, not the inner * stuff is relative to the outer window, not the inner
*/ */
extend_by_frame (&info->current, info->fgeom); extend_by_frame (&info->current, info->fgeom);
@ -622,17 +622,17 @@ update_onscreen_requirements (MetaWindow *window,
window->require_fully_onscreen ? "TRUE" : "FALSE"); window->require_fully_onscreen ? "TRUE" : "FALSE");
/* Update whether we want future constraint runs to require the /* Update whether we want future constraint runs to require the
* window to be on a single xinerama. * window to be on a single monitor.
*/ */
old = window->require_on_single_xinerama; old = window->require_on_single_monitor;
window->require_on_single_xinerama = window->require_on_single_monitor =
meta_rectangle_contained_in_region (info->usable_xinerama_region, meta_rectangle_contained_in_region (info->usable_monitor_region,
&info->current); &info->current);
if (old ^ window->require_on_single_xinerama) if (old ^ window->require_on_single_monitor)
meta_topic (META_DEBUG_GEOMETRY, meta_topic (META_DEBUG_GEOMETRY,
"require_on_single_xinerama for %s toggled to %s\n", "require_on_single_monitor for %s toggled to %s\n",
window->desc, window->desc,
window->require_on_single_xinerama ? "TRUE" : "FALSE"); window->require_on_single_monitor ? "TRUE" : "FALSE");
/* Update whether we want future constraint runs to require the /* Update whether we want future constraint runs to require the
* titlebar to be visible. * titlebar to be visible.
@ -735,7 +735,7 @@ constrain_maximization (MetaWindow *window,
/* Calculate target_size = maximized size of (window + frame) */ /* Calculate target_size = maximized size of (window + frame) */
if (window->maximized_horizontally && window->maximized_vertically) if (window->maximized_horizontally && window->maximized_vertically)
target_size = info->work_area_xinerama; target_size = info->work_area_monitor;
else else
{ {
/* Amount of maximization possible in a single direction depends /* Amount of maximization possible in a single direction depends
@ -757,7 +757,7 @@ constrain_maximization (MetaWindow *window,
target_size = info->current; target_size = info->current;
extend_by_frame (&target_size, info->fgeom); extend_by_frame (&target_size, info->fgeom);
meta_rectangle_expand_to_avoiding_struts (&target_size, meta_rectangle_expand_to_avoiding_struts (&target_size,
&info->entire_xinerama, &info->entire_monitor,
direction, direction,
active_workspace_struts); active_workspace_struts);
} }
@ -804,7 +804,7 @@ constrain_fullscreen (MetaWindow *window,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only) gboolean check_only)
{ {
MetaRectangle min_size, max_size, xinerama; MetaRectangle min_size, max_size, monitor;
gboolean too_big, too_small, constraint_already_satisfied; gboolean too_big, too_small, constraint_already_satisfied;
if (priority > PRIORITY_FULLSCREEN) if (priority > PRIORITY_FULLSCREEN)
@ -814,22 +814,22 @@ constrain_fullscreen (MetaWindow *window,
if (!window->fullscreen) if (!window->fullscreen)
return TRUE; return TRUE;
xinerama = info->entire_xinerama; monitor = info->entire_monitor;
get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size); get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
too_big = !meta_rectangle_could_fit_rect (&xinerama, &min_size); too_big = !meta_rectangle_could_fit_rect (&monitor, &min_size);
too_small = !meta_rectangle_could_fit_rect (&max_size, &xinerama); too_small = !meta_rectangle_could_fit_rect (&max_size, &monitor);
if (too_big || too_small) if (too_big || too_small)
return TRUE; return TRUE;
/* Determine whether constraint is already satisfied; exit if it is */ /* Determine whether constraint is already satisfied; exit if it is */
constraint_already_satisfied = constraint_already_satisfied =
meta_rectangle_equal (&info->current, &xinerama); meta_rectangle_equal (&info->current, &monitor);
if (check_only || constraint_already_satisfied) if (check_only || constraint_already_satisfied)
return constraint_already_satisfied; return constraint_already_satisfied;
/*** Enforce constraint ***/ /*** Enforce constraint ***/
info->current = xinerama; info->current = monitor;
return TRUE; return TRUE;
} }
@ -1091,7 +1091,7 @@ constrain_aspect_ratio (MetaWindow *window,
} }
static gboolean static gboolean
do_screen_and_xinerama_relative_constraints ( do_screen_and_monitor_relative_constraints (
MetaWindow *window, MetaWindow *window,
GList *region_spanning_rectangles, GList *region_spanning_rectangles,
ConstraintInfo *info, ConstraintInfo *info,
@ -1107,7 +1107,7 @@ do_screen_and_xinerama_relative_constraints (
char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)]; char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
meta_topic (META_DEBUG_GEOMETRY, meta_topic (META_DEBUG_GEOMETRY,
"screen/xinerama constraint; region_spanning_rectangles: %s\n", "screen/monitor constraint; region_spanning_rectangles: %s\n",
meta_rectangle_region_to_string (region_spanning_rectangles, ", ", meta_rectangle_region_to_string (region_spanning_rectangles, ", ",
spanning_region)); spanning_region));
} }
@ -1165,30 +1165,30 @@ do_screen_and_xinerama_relative_constraints (
} }
static gboolean static gboolean
constrain_to_single_xinerama (MetaWindow *window, constrain_to_single_monitor (MetaWindow *window,
ConstraintInfo *info, ConstraintInfo *info,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only) gboolean check_only)
{ {
if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA) if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR)
return TRUE; return TRUE;
/* Exit early if we know the constraint won't apply--note that this constraint /* Exit early if we know the constraint won't apply--note that this constraint
* is only meant for normal windows (e.g. we don't want docks to be shoved * is only meant for normal windows (e.g. we don't want docks to be shoved
* "onscreen" by their own strut) and we can't apply it to frameless windows * "onscreen" by their own strut) and we can't apply it to frameless windows
* or else users will be unable to move windows such as XMMS across xineramas. * or else users will be unable to move windows such as XMMS across monitors.
*/ */
if (window->type == META_WINDOW_DESKTOP || if (window->type == META_WINDOW_DESKTOP ||
window->type == META_WINDOW_DOCK || window->type == META_WINDOW_DOCK ||
window->screen->n_xinerama_infos == 1 || window->screen->n_monitor_infos == 1 ||
!window->require_on_single_xinerama || !window->require_on_single_monitor ||
!window->frame || !window->frame ||
info->is_user_action) info->is_user_action)
return TRUE; return TRUE;
/* Have a helper function handle the constraint for us */ /* Have a helper function handle the constraint for us */
return do_screen_and_xinerama_relative_constraints (window, return do_screen_and_monitor_relative_constraints (window,
info->usable_xinerama_region, info->usable_monitor_region,
info, info,
check_only); check_only);
} }
@ -1214,7 +1214,7 @@ constrain_fully_onscreen (MetaWindow *window,
return TRUE; return TRUE;
/* Have a helper function handle the constraint for us */ /* Have a helper function handle the constraint for us */
return do_screen_and_xinerama_relative_constraints (window, return do_screen_and_monitor_relative_constraints (window,
info->usable_screen_region, info->usable_screen_region,
info, info,
check_only); check_only);
@ -1290,7 +1290,7 @@ constrain_titlebar_visible (MetaWindow *window,
horiz_amount_onscreen, horiz_amount_onscreen,
vert_amount_onscreen); vert_amount_onscreen);
retval = retval =
do_screen_and_xinerama_relative_constraints (window, do_screen_and_monitor_relative_constraints (window,
info->usable_screen_region, info->usable_screen_region,
info, info,
check_only); check_only);
@ -1365,7 +1365,7 @@ constrain_partially_onscreen (MetaWindow *window,
horiz_amount_onscreen, horiz_amount_onscreen,
vert_amount_onscreen); vert_amount_onscreen);
retval = retval =
do_screen_and_xinerama_relative_constraints (window, do_screen_and_monitor_relative_constraints (window,
info->usable_screen_region, info->usable_screen_region,
info, info,
check_only); check_only);

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

@ -217,8 +217,8 @@ struct _MetaDisplay
MetaKeyCombo overlay_key_combo; MetaKeyCombo overlay_key_combo;
gboolean overlay_key_only_pressed; gboolean overlay_key_only_pressed;
/* Xinerama cache */ /* Monitor cache */
unsigned int xinerama_cache_invalidated : 1; unsigned int monitor_cache_invalidated : 1;
/* Opening the display */ /* Opening the display */
unsigned int display_opening : 1; unsigned int display_opening : 1;

4
src/core/display.c
View File

@ -483,7 +483,7 @@ meta_display_open (void)
the_display->leader_window = None; the_display->leader_window = None;
the_display->timestamp_pinging_window = None; the_display->timestamp_pinging_window = None;
the_display->xinerama_cache_invalidated = TRUE; the_display->monitor_cache_invalidated = TRUE;
the_display->groups_by_leader = NULL; the_display->groups_by_leader = NULL;
@ -1528,7 +1528,7 @@ event_callback (XEvent *event,
bypass_compositor = FALSE; bypass_compositor = FALSE;
filter_out_event = FALSE; filter_out_event = FALSE;
display->current_time = event_get_time (display, event); display->current_time = event_get_time (display, event);
display->xinerama_cache_invalidated = TRUE; display->monitor_cache_invalidated = TRUE;
modified = event_get_modified_window (display, event); modified = event_get_modified_window (display, event);

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

@ -340,12 +340,12 @@ apply_edge_resistance (MetaWindow *window,
const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW = 16; const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW = 16;
const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW = 0; const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW = 0;
const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA = 32; const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR = 32;
const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA = 0; const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR = 0;
const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN = 32; const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN = 32;
const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN = 0; const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN = 0;
const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW = 0; const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW = 0;
const int TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA = 0; const int TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR = 0;
const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN = 0; const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN = 0;
/* Quit if no movement was specified */ /* Quit if no movement was specified */
@ -423,8 +423,8 @@ apply_edge_resistance (MetaWindow *window,
case META_EDGE_WINDOW: case META_EDGE_WINDOW:
timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW; timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
break; break;
case META_EDGE_XINERAMA: case META_EDGE_MONITOR:
timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA; timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR;
break; break;
case META_EDGE_SCREEN: case META_EDGE_SCREEN:
timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN; timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
@ -468,11 +468,11 @@ apply_edge_resistance (MetaWindow *window,
else else
threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW; threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW;
break; break;
case META_EDGE_XINERAMA: case META_EDGE_MONITOR:
if (movement_towards_edge (edge->side_type, increment)) if (movement_towards_edge (edge->side_type, increment))
threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA; threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR;
else else
threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA; threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR;
break; break;
case META_EDGE_SCREEN: case META_EDGE_SCREEN:
if (movement_towards_edge (edge->side_type, increment)) if (movement_towards_edge (edge->side_type, increment))
@ -761,7 +761,7 @@ stupid_sort_requiring_extra_pointer_dereference (gconstpointer a,
static void static void
cache_edges (MetaDisplay *display, cache_edges (MetaDisplay *display,
GList *window_edges, GList *window_edges,
GList *xinerama_edges, GList *monitor_edges,
GList *screen_edges) GList *screen_edges)
{ {
MetaEdgeResistanceData *edge_data; MetaEdgeResistanceData *edge_data;
@ -776,7 +776,7 @@ cache_edges (MetaDisplay *display,
if (meta_is_verbose()) if (meta_is_verbose())
{ {
int max_edges = MAX (MAX( g_list_length (window_edges), int max_edges = MAX (MAX( g_list_length (window_edges),
g_list_length (xinerama_edges)), g_list_length (monitor_edges)),
g_list_length (screen_edges)); g_list_length (screen_edges));
char big_buffer[(EDGE_LENGTH+2)*max_edges]; char big_buffer[(EDGE_LENGTH+2)*max_edges];
@ -784,9 +784,9 @@ cache_edges (MetaDisplay *display,
meta_topic (META_DEBUG_EDGE_RESISTANCE, meta_topic (META_DEBUG_EDGE_RESISTANCE,
"Window edges for resistance : %s\n", big_buffer); "Window edges for resistance : %s\n", big_buffer);
meta_rectangle_edge_list_to_string (xinerama_edges, ", ", big_buffer); meta_rectangle_edge_list_to_string (monitor_edges, ", ", big_buffer);
meta_topic (META_DEBUG_EDGE_RESISTANCE, meta_topic (META_DEBUG_EDGE_RESISTANCE,
"Xinerama edges for resistance: %s\n", big_buffer); "Monitor edges for resistance: %s\n", big_buffer);
meta_rectangle_edge_list_to_string (screen_edges, ", ", big_buffer); meta_rectangle_edge_list_to_string (screen_edges, ", ", big_buffer);
meta_topic (META_DEBUG_EDGE_RESISTANCE, meta_topic (META_DEBUG_EDGE_RESISTANCE,
@ -807,7 +807,7 @@ cache_edges (MetaDisplay *display,
tmp = window_edges; tmp = window_edges;
break; break;
case 1: case 1:
tmp = xinerama_edges; tmp = monitor_edges;
break; break;
case 2: case 2:
tmp = screen_edges; tmp = screen_edges;
@ -875,7 +875,7 @@ cache_edges (MetaDisplay *display,
tmp = window_edges; tmp = window_edges;
break; break;
case 1: case 1:
tmp = xinerama_edges; tmp = monitor_edges;
break; break;
case 2: case 2:
tmp = screen_edges; tmp = screen_edges;
@ -1110,12 +1110,12 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
/* /*
* 5th: Cache the combination of these edges with the onscreen and * 5th: Cache the combination of these edges with the onscreen and
* xinerama edges in an array for quick access. Free the edges since * monitor edges in an array for quick access. Free the edges since
* they've been cached elsewhere. * they've been cached elsewhere.
*/ */
cache_edges (display, cache_edges (display,
edges, edges,
display->grab_screen->active_workspace->xinerama_edges, display->grab_screen->active_workspace->monitor_edges,
display->grab_screen->active_workspace->screen_edges); display->grab_screen->active_workspace->screen_edges);
g_list_free (edges); g_list_free (edges);

4
src/core/keybindings.c
View File

@ -2553,7 +2553,7 @@ handle_move_to_corner_backend (MetaDisplay *display,
int new_x, new_y; int new_x, new_y;
int frame_width, frame_height; int frame_width, frame_height;
meta_window_get_work_area_all_xineramas (window, &work_area); meta_window_get_work_area_all_monitors (window, &work_area);
meta_window_get_outer_rect (window, &outer); meta_window_get_outer_rect (window, &outer);
meta_window_get_position (window, &orig_x, &orig_y); meta_window_get_position (window, &orig_x, &orig_y);
@ -2685,7 +2685,7 @@ handle_move_to_center (MetaDisplay *display,
int orig_x, orig_y; int orig_x, orig_y;
int frame_width, frame_height; int frame_width, frame_height;
meta_window_get_work_area_all_xineramas (window, &work_area); meta_window_get_work_area_all_monitors (window, &work_area);
meta_window_get_outer_rect (window, &outer); meta_window_get_outer_rect (window, &outer);
meta_window_get_position (window, &orig_x, &orig_y); meta_window_get_position (window, &orig_x, &orig_y);

34
src/core/place.c
View File

@ -104,7 +104,7 @@ find_next_cascade (MetaWindow *window,
int window_width, window_height; int window_width, window_height;
int cascade_stage; int cascade_stage;
MetaRectangle work_area; MetaRectangle work_area;
const MetaXineramaScreenInfo* current; const MetaMonitorInfo* current;
sorted = g_list_copy (windows); sorted = g_list_copy (windows);
sorted = g_list_sort (sorted, northwestcmp); sorted = g_list_sort (sorted, northwestcmp);
@ -135,8 +135,8 @@ find_next_cascade (MetaWindow *window,
* of NW corner of window frame. * of NW corner of window frame.
*/ */
current = meta_screen_get_current_xinerama (window->screen); current = meta_screen_get_current_monitor (window->screen);
meta_window_get_work_area_for_xinerama (window, current->number, &work_area); meta_window_get_work_area_for_monitor (window, current->number, &work_area);
cascade_x = MAX (0, work_area.x); cascade_x = MAX (0, work_area.x);
cascade_y = MAX (0, work_area.y); cascade_y = MAX (0, work_area.y);
@ -257,7 +257,7 @@ find_most_freespace (MetaWindow *window,
frame_size_left = fgeom ? fgeom->left_width : 0; frame_size_left = fgeom ? fgeom->left_width : 0;
frame_size_top = fgeom ? fgeom->top_height : 0; frame_size_top = fgeom ? fgeom->top_height : 0;
meta_window_get_work_area_current_xinerama (focus_window, &work_area); meta_window_get_work_area_current_monitor (focus_window, &work_area);
meta_window_get_outer_rect (focus_window, &avoid); meta_window_get_outer_rect (focus_window, &avoid);
meta_window_get_outer_rect (window, &outer); meta_window_get_outer_rect (window, &outer);
@ -508,7 +508,7 @@ find_first_fit (MetaWindow *window,
MetaFrameGeometry *fgeom, MetaFrameGeometry *fgeom,
/* visible windows on relevant workspaces */ /* visible windows on relevant workspaces */
GList *windows, GList *windows,
int xinerama, int monitor,
int x, int x,
int y, int y,
int *new_x, int *new_x,
@ -551,16 +551,16 @@ find_first_fit (MetaWindow *window,
#ifdef WITH_VERBOSE_MODE #ifdef WITH_VERBOSE_MODE
{ {
char xinerama_location_string[RECT_LENGTH]; char monitor_location_string[RECT_LENGTH];
meta_rectangle_to_string (&window->screen->xinerama_infos[xinerama].rect, meta_rectangle_to_string (&window->screen->monitor_infos[monitor].rect,
xinerama_location_string); monitor_location_string);
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Natural xinerama is %s\n", "Natural monitor is %s\n",
xinerama_location_string); monitor_location_string);
} }
#endif #endif
meta_window_get_work_area_for_xinerama (window, xinerama, &work_area); meta_window_get_work_area_for_monitor (window, monitor, &work_area);
center_tile_rect_in_area (&rect, &work_area); center_tile_rect_in_area (&rect, &work_area);
@ -658,7 +658,7 @@ meta_window_place (MetaWindow *window,
int *new_y) int *new_y)
{ {
GList *windows; GList *windows;
const MetaXineramaScreenInfo *xi; const MetaMonitorInfo *xi;
/* frame member variables should NEVER be used in here, only /* frame member variables should NEVER be used in here, only
* MetaFrameGeometry. But remember fgeom == NULL * MetaFrameGeometry. But remember fgeom == NULL
@ -810,11 +810,11 @@ meta_window_place (MetaWindow *window,
window->type == META_WINDOW_MODAL_DIALOG || window->type == META_WINDOW_MODAL_DIALOG ||
window->type == META_WINDOW_SPLASHSCREEN) window->type == META_WINDOW_SPLASHSCREEN)
{ {
/* Center on current xinerama (i.e. on current monitor) */ /* Center on current monitor */
int w, h; int w, h;
/* Warning, this function is a round trip! */ /* Warning, this function is a round trip! */
xi = meta_screen_get_current_xinerama (window->screen); xi = meta_screen_get_current_monitor (window->screen);
w = xi->rect.width; w = xi->rect.width;
h = xi->rect.height; h = xi->rect.height;
@ -825,7 +825,7 @@ meta_window_place (MetaWindow *window,
x += xi->rect.x; x += xi->rect.x;
y += xi->rect.y; y += xi->rect.y;
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d xinerama %d\n", meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d monitor %d\n",
window->desc, window->screen->number, xi->number); window->desc, window->screen->number, xi->number);
goto done_check_denied_focus; goto done_check_denied_focus;
@ -859,7 +859,7 @@ meta_window_place (MetaWindow *window,
} }
/* Warning, this is a round trip! */ /* Warning, this is a round trip! */
xi = meta_screen_get_current_xinerama (window->screen); xi = meta_screen_get_current_monitor (window->screen);
/* "Origin" placement algorithm */ /* "Origin" placement algorithm */
x = xi->rect.x; x = xi->rect.x;
@ -880,7 +880,7 @@ meta_window_place (MetaWindow *window,
MetaRectangle workarea; MetaRectangle workarea;
MetaRectangle outer; MetaRectangle outer;
meta_window_get_work_area_for_xinerama (window, meta_window_get_work_area_for_monitor (window,
xi->number, xi->number,
&workarea); &workarea);
meta_window_get_outer_rect (window, &outer); meta_window_get_outer_rect (window, &outer);

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

@ -40,9 +40,9 @@
#include "alttabhandler.h" #include "alttabhandler.h"
#include "ui.h" #include "ui.h"
typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo; typedef struct _MetaMonitorInfo MetaMonitorInfo;
struct _MetaXineramaScreenInfo struct _MetaMonitorInfo
{ {
int number; int number;
MetaRectangle rect; MetaRectangle rect;
@ -105,11 +105,11 @@ struct _MetaScreen
Atom wm_sn_atom; Atom wm_sn_atom;
guint32 wm_sn_timestamp; guint32 wm_sn_timestamp;
MetaXineramaScreenInfo *xinerama_infos; MetaMonitorInfo *monitor_infos;
int n_xinerama_infos; int n_monitor_infos;
/* Cache the current Xinerama */ /* Cache the current monitor */
int last_xinerama_index; int last_monitor_index;
#ifdef HAVE_STARTUP_NOTIFICATION #ifdef HAVE_STARTUP_NOTIFICATION
SnMonitorContext *sn_context; SnMonitorContext *sn_context;
@ -185,19 +185,19 @@ void meta_screen_workspace_popup_destroy (MetaScreen *screen);
MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen, MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen,
MetaWindow *not_this_one); MetaWindow *not_this_one);
const MetaXineramaScreenInfo* meta_screen_get_current_xinerama (MetaScreen *screen); const MetaMonitorInfo* meta_screen_get_current_monitor (MetaScreen *screen);
const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect (MetaScreen *screen, const MetaMonitorInfo* meta_screen_get_monitor_for_rect (MetaScreen *screen,
MetaRectangle *rect); MetaRectangle *rect);
const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen *screen, const MetaMonitorInfo* meta_screen_get_monitor_for_window (MetaScreen *screen,
MetaWindow *window); MetaWindow *window);
const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen, const MetaMonitorInfo* meta_screen_get_monitor_neighbor (MetaScreen *screen,
int which_xinerama, int which_monitor,
MetaScreenDirection dir); MetaScreenDirection dir);
void meta_screen_get_natural_xinerama_list (MetaScreen *screen, void meta_screen_get_natural_monitor_list (MetaScreen *screen,
int** xineramas_list, int** monitors_list,
int* n_xineramas); int* n_monitors);
void meta_screen_update_workspace_layout (MetaScreen *screen); void meta_screen_update_workspace_layout (MetaScreen *screen);
void meta_screen_update_workspace_names (MetaScreen *screen); void meta_screen_update_workspace_names (MetaScreen *screen);

272
src/core/screen.c
View File

@ -299,7 +299,7 @@ set_wm_icon_size_hint (MetaScreen *screen)
} }
static void static void
reload_xinerama_infos (MetaScreen *screen) reload_monitor_infos (MetaScreen *screen)
{ {
MetaDisplay *display; MetaDisplay *display;
@ -319,35 +319,35 @@ reload_xinerama_infos (MetaScreen *screen)
display = screen->display; display = screen->display;
if (screen->xinerama_infos) if (screen->monitor_infos)
g_free (screen->xinerama_infos); g_free (screen->monitor_infos);
screen->xinerama_infos = NULL; screen->monitor_infos = NULL;
screen->n_xinerama_infos = 0; screen->n_monitor_infos = 0;
screen->last_xinerama_index = 0; screen->last_monitor_index = 0;
screen->display->xinerama_cache_invalidated = TRUE; screen->display->monitor_cache_invalidated = TRUE;
if (g_getenv ("MUTTER_DEBUG_XINERAMA")) if (g_getenv ("MUTTER_DEBUG_XINERAMA"))
{ {
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Pretending a single monitor has two Xinerama screens\n"); "Pretending a single monitor has two Xinerama screens\n");
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2); screen->monitor_infos = g_new (MetaMonitorInfo, 2);
screen->n_xinerama_infos = 2; screen->n_monitor_infos = 2;
screen->xinerama_infos[0].number = 0; screen->monitor_infos[0].number = 0;
screen->xinerama_infos[0].rect = screen->rect; screen->monitor_infos[0].rect = screen->rect;
screen->xinerama_infos[0].rect.width = screen->rect.width / 2; screen->monitor_infos[0].rect.width = screen->rect.width / 2;
screen->xinerama_infos[1].number = 1; screen->monitor_infos[1].number = 1;
screen->xinerama_infos[1].rect = screen->rect; screen->monitor_infos[1].rect = screen->rect;
screen->xinerama_infos[1].rect.x = screen->rect.width / 2; screen->monitor_infos[1].rect.x = screen->rect.width / 2;
screen->xinerama_infos[1].rect.width = screen->rect.width / 2; screen->monitor_infos[1].rect.width = screen->rect.width / 2;
} }
#ifdef HAVE_XFREE_XINERAMA #ifdef HAVE_XFREE_XINERAMA
if (screen->n_xinerama_infos == 0 && if (screen->n_monitor_infos == 0 &&
XineramaIsActive (display->xdisplay)) XineramaIsActive (display->xdisplay))
{ {
XineramaScreenInfo *infos; XineramaScreenInfo *infos;
@ -363,25 +363,25 @@ reload_xinerama_infos (MetaScreen *screen)
if (n_infos > 0) if (n_infos > 0)
{ {
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos); screen->monitor_infos = g_new (MetaMonitorInfo, n_infos);
screen->n_xinerama_infos = n_infos; screen->n_monitor_infos = n_infos;
i = 0; i = 0;
while (i < n_infos) while (i < n_infos)
{ {
screen->xinerama_infos[i].number = infos[i].screen_number; screen->monitor_infos[i].number = infos[i].screen_number;
screen->xinerama_infos[i].rect.x = infos[i].x_org; screen->monitor_infos[i].rect.x = infos[i].x_org;
screen->xinerama_infos[i].rect.y = infos[i].y_org; screen->monitor_infos[i].rect.y = infos[i].y_org;
screen->xinerama_infos[i].rect.width = infos[i].width; screen->monitor_infos[i].rect.width = infos[i].width;
screen->xinerama_infos[i].rect.height = infos[i].height; screen->monitor_infos[i].rect.height = infos[i].height;
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Xinerama %d is %d,%d %d x %d\n", "Monitor %d is %d,%d %d x %d\n",
screen->xinerama_infos[i].number, screen->monitor_infos[i].number,
screen->xinerama_infos[i].rect.x, screen->monitor_infos[i].rect.x,
screen->xinerama_infos[i].rect.y, screen->monitor_infos[i].rect.y,
screen->xinerama_infos[i].rect.width, screen->monitor_infos[i].rect.width,
screen->xinerama_infos[i].rect.height); screen->monitor_infos[i].rect.height);
++i; ++i;
} }
@ -389,7 +389,7 @@ reload_xinerama_infos (MetaScreen *screen)
meta_XFree (infos); meta_XFree (infos);
} }
else if (screen->n_xinerama_infos > 0) else if (screen->n_monitor_infos > 0)
{ {
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n", "No XFree86 Xinerama extension or XFree86 Xinerama inactive on display %s\n",
@ -402,7 +402,7 @@ reload_xinerama_infos (MetaScreen *screen)
#ifdef HAVE_SOLARIS_XINERAMA #ifdef HAVE_SOLARIS_XINERAMA
/* This code from GDK, Copyright (C) 2002 Sun Microsystems */ /* This code from GDK, Copyright (C) 2002 Sun Microsystems */
if (screen->n_xinerama_infos == 0 && if (screen->n_monitor_infos == 0 &&
XineramaGetState (screen->display->xdisplay, XineramaGetState (screen->display->xdisplay,
screen->number)) screen->number))
{ {
@ -424,31 +424,31 @@ reload_xinerama_infos (MetaScreen *screen)
{ {
g_assert (n_monitors > 0); g_assert (n_monitors > 0);
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors); screen->monitor_infos = g_new (MetaMonitorInfo, n_monitors);
screen->n_xinerama_infos = n_monitors; screen->n_monitor_infos = n_monitors;
i = 0; i = 0;
while (i < n_monitors) while (i < n_monitors)
{ {
screen->xinerama_infos[i].number = i; screen->monitor_infos[i].number = i;
screen->xinerama_infos[i].rect.x = monitors[i].x; screen->monitor_infos[i].rect.x = monitors[i].x;
screen->xinerama_infos[i].rect.y = monitors[i].y; screen->monitor_infos[i].rect.y = monitors[i].y;
screen->xinerama_infos[i].rect.width = monitors[i].width; screen->monitor_infos[i].rect.width = monitors[i].width;
screen->xinerama_infos[i].rect.height = monitors[i].height; screen->monitor_infos[i].rect.height = monitors[i].height;
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Xinerama %d is %d,%d %d x %d\n", "Monitor %d is %d,%d %d x %d\n",
screen->xinerama_infos[i].number, screen->monitor_infos[i].number,
screen->xinerama_infos[i].rect.x, screen->monitor_infos[i].rect.x,
screen->xinerama_infos[i].rect.y, screen->monitor_infos[i].rect.y,
screen->xinerama_infos[i].rect.width, screen->monitor_infos[i].rect.width,
screen->xinerama_infos[i].rect.height); screen->monitor_infos[i].rect.height);
++i; ++i;
} }
} }
} }
else if (screen->n_xinerama_infos == 0) else if (screen->n_monitor_infos == 0)
{ {
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n", "No Solaris Xinerama extension or Solaris Xinerama inactive on display %s\n",
@ -463,20 +463,20 @@ reload_xinerama_infos (MetaScreen *screen)
/* If no Xinerama, fill in the single screen info so /* If no Xinerama, fill in the single screen info so
* we can use the field unconditionally * we can use the field unconditionally
*/ */
if (screen->n_xinerama_infos == 0) if (screen->n_monitor_infos == 0)
{ {
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"No Xinerama screens, using default screen info\n"); "No Xinerama screens, using default screen info\n");
screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1); screen->monitor_infos = g_new (MetaMonitorInfo, 1);
screen->n_xinerama_infos = 1; screen->n_monitor_infos = 1;
screen->xinerama_infos[0].number = 0; screen->monitor_infos[0].number = 0;
screen->xinerama_infos[0].rect = screen->rect; screen->monitor_infos[0].rect = screen->rect;
} }
g_assert (screen->n_xinerama_infos > 0); g_assert (screen->n_monitor_infos > 0);
g_assert (screen->xinerama_infos != NULL); g_assert (screen->monitor_infos != NULL);
} }
/* The guard window allows us to leave minimized windows mapped so /* The guard window allows us to leave minimized windows mapped so
@ -727,11 +727,11 @@ meta_screen_new (MetaDisplay *display,
&gc_values); &gc_values);
} }
screen->xinerama_infos = NULL; screen->monitor_infos = NULL;
screen->n_xinerama_infos = 0; screen->n_monitor_infos = 0;
screen->last_xinerama_index = 0; screen->last_monitor_index = 0;
reload_xinerama_infos (screen); reload_monitor_infos (screen);
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT); meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
@ -890,8 +890,8 @@ meta_screen_free (MetaScreen *screen,
XFreeGC (screen->display->xdisplay, XFreeGC (screen->display->xdisplay,
screen->root_xor_gc); screen->root_xor_gc);
if (screen->xinerama_infos) if (screen->monitor_infos)
g_free (screen->xinerama_infos); g_free (screen->monitor_infos);
g_free (screen->screen_name); g_free (screen->screen_name);
@ -1703,61 +1703,61 @@ meta_screen_get_mouse_window (MetaScreen *screen,
return window; return window;
} }
const MetaXineramaScreenInfo* const MetaMonitorInfo*
meta_screen_get_xinerama_for_rect (MetaScreen *screen, meta_screen_get_monitor_for_rect (MetaScreen *screen,
MetaRectangle *rect) MetaRectangle *rect)
{ {
int i; int i;
int best_xinerama, xinerama_score; int best_monitor, monitor_score;
if (screen->n_xinerama_infos == 1) if (screen->n_monitor_infos == 1)
return &screen->xinerama_infos[0]; return &screen->monitor_infos[0];
best_xinerama = 0; best_monitor = 0;
xinerama_score = 0; monitor_score = 0;
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
{ {
MetaRectangle dest; MetaRectangle dest;
if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect, if (meta_rectangle_intersect (&screen->monitor_infos[i].rect,
rect, rect,
&dest)) &dest))
{ {
int cur = meta_rectangle_area (&dest); int cur = meta_rectangle_area (&dest);
if (cur > xinerama_score) if (cur > monitor_score)
{ {
xinerama_score = cur; monitor_score = cur;
best_xinerama = i; best_monitor = i;
} }
} }
} }
return &screen->xinerama_infos[best_xinerama]; return &screen->monitor_infos[best_monitor];
} }
const MetaXineramaScreenInfo* const MetaMonitorInfo*
meta_screen_get_xinerama_for_window (MetaScreen *screen, meta_screen_get_monitor_for_window (MetaScreen *screen,
MetaWindow *window) MetaWindow *window)
{ {
MetaRectangle window_rect; MetaRectangle window_rect;
meta_window_get_outer_rect (window, &window_rect); meta_window_get_outer_rect (window, &window_rect);
return meta_screen_get_xinerama_for_rect (screen, &window_rect); return meta_screen_get_monitor_for_rect (screen, &window_rect);
} }
const MetaXineramaScreenInfo* const MetaMonitorInfo*
meta_screen_get_xinerama_neighbor (MetaScreen *screen, meta_screen_get_monitor_neighbor (MetaScreen *screen,
int which_xinerama, int which_monitor,
MetaScreenDirection direction) MetaScreenDirection direction)
{ {
MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama; MetaMonitorInfo* input = screen->monitor_infos + which_monitor;
MetaXineramaScreenInfo* current; MetaMonitorInfo* current;
int i; int i;
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
{ {
current = screen->xinerama_infos + i; current = screen->monitor_infos + i;
if ((direction == META_SCREEN_RIGHT && if ((direction == META_SCREEN_RIGHT &&
current->rect.x == input->rect.x + input->rect.width && current->rect.x == input->rect.x + input->rect.width &&
@ -1780,110 +1780,110 @@ meta_screen_get_xinerama_neighbor (MetaScreen *screen,
} }
void void
meta_screen_get_natural_xinerama_list (MetaScreen *screen, meta_screen_get_natural_monitor_list (MetaScreen *screen,
int** xineramas_list, int** monitors_list,
int* n_xineramas) int* n_monitors)
{ {
const MetaXineramaScreenInfo* current; const MetaMonitorInfo* current;
const MetaXineramaScreenInfo* tmp; const MetaMonitorInfo* tmp;
GQueue* xinerama_queue; GQueue* monitor_queue;
int* visited; int* visited;
int cur = 0; int cur = 0;
int i; int i;
*n_xineramas = screen->n_xinerama_infos; *n_monitors = screen->n_monitor_infos;
*xineramas_list = g_new (int, screen->n_xinerama_infos); *monitors_list = g_new (int, screen->n_monitor_infos);
/* we calculate a natural ordering by which to choose xineramas for /* we calculate a natural ordering by which to choose monitors for
* window placement. We start at the current xinerama, and perform * window placement. We start at the current monitor, and perform
* a breadth-first search of the xineramas starting from that * a breadth-first search of the monitors starting from that
* xinerama. We choose preferentially left, then right, then down, * monitor. We choose preferentially left, then right, then down,
* then up. The visitation order produced by this traversal is the * then up. The visitation order produced by this traversal is the
* natural xinerama ordering. * natural monitor ordering.
*/ */
visited = g_new (int, screen->n_xinerama_infos); visited = g_new (int, screen->n_monitor_infos);
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
{ {
visited[i] = FALSE; visited[i] = FALSE;
} }
current = meta_screen_get_current_xinerama (screen); current = meta_screen_get_current_monitor (screen);
xinerama_queue = g_queue_new (); monitor_queue = g_queue_new ();
g_queue_push_tail (xinerama_queue, (gpointer) current); g_queue_push_tail (monitor_queue, (gpointer) current);
visited[current->number] = TRUE; visited[current->number] = TRUE;
while (!g_queue_is_empty (xinerama_queue)) while (!g_queue_is_empty (monitor_queue))
{ {
current = (const MetaXineramaScreenInfo*) current = (const MetaMonitorInfo*)
g_queue_pop_head (xinerama_queue); g_queue_pop_head (monitor_queue);
(*xineramas_list)[cur++] = current->number; (*monitors_list)[cur++] = current->number;
/* enqueue each of the directions */ /* enqueue each of the directions */
tmp = meta_screen_get_xinerama_neighbor (screen, tmp = meta_screen_get_monitor_neighbor (screen,
current->number, current->number,
META_SCREEN_LEFT); META_SCREEN_LEFT);
if (tmp && !visited[tmp->number]) if (tmp && !visited[tmp->number])
{ {
g_queue_push_tail (xinerama_queue, g_queue_push_tail (monitor_queue,
(MetaXineramaScreenInfo*) tmp); (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE; visited[tmp->number] = TRUE;
} }
tmp = meta_screen_get_xinerama_neighbor (screen, tmp = meta_screen_get_monitor_neighbor (screen,
current->number, current->number,
META_SCREEN_RIGHT); META_SCREEN_RIGHT);
if (tmp && !visited[tmp->number]) if (tmp && !visited[tmp->number])
{ {
g_queue_push_tail (xinerama_queue, g_queue_push_tail (monitor_queue,
(MetaXineramaScreenInfo*) tmp); (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE; visited[tmp->number] = TRUE;
} }
tmp = meta_screen_get_xinerama_neighbor (screen, tmp = meta_screen_get_monitor_neighbor (screen,
current->number, current->number,
META_SCREEN_UP); META_SCREEN_UP);
if (tmp && !visited[tmp->number]) if (tmp && !visited[tmp->number])
{ {
g_queue_push_tail (xinerama_queue, g_queue_push_tail (monitor_queue,
(MetaXineramaScreenInfo*) tmp); (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE; visited[tmp->number] = TRUE;
} }
tmp = meta_screen_get_xinerama_neighbor (screen, tmp = meta_screen_get_monitor_neighbor (screen,
current->number, current->number,
META_SCREEN_DOWN); META_SCREEN_DOWN);
if (tmp && !visited[tmp->number]) if (tmp && !visited[tmp->number])
{ {
g_queue_push_tail (xinerama_queue, g_queue_push_tail (monitor_queue,
(MetaXineramaScreenInfo*) tmp); (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE; visited[tmp->number] = TRUE;
} }
} }
/* in case we somehow missed some set of xineramas, go through the /* in case we somehow missed some set of monitors, go through the
* visited list and add in any xineramas that were missed * visited list and add in any monitors that were missed
*/ */
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
{ {
if (visited[i] == FALSE) if (visited[i] == FALSE)
{ {
(*xineramas_list)[cur++] = i; (*monitors_list)[cur++] = i;
} }
} }
g_free (visited); g_free (visited);
g_queue_free (xinerama_queue); g_queue_free (monitor_queue);
} }
const MetaXineramaScreenInfo* const MetaMonitorInfo*
meta_screen_get_current_xinerama (MetaScreen *screen) meta_screen_get_current_monitor (MetaScreen *screen)
{ {
if (screen->n_xinerama_infos == 1) if (screen->n_monitor_infos == 1)
return &screen->xinerama_infos[0]; return &screen->monitor_infos[0];
/* Sadly, we have to do it this way. Yuck. /* Sadly, we have to do it this way. Yuck.
*/ */
if (screen->display->xinerama_cache_invalidated) if (screen->display->monitor_cache_invalidated)
{ {
Window root_return, child_return; Window root_return, child_return;
int win_x_return, win_y_return; int win_x_return, win_y_return;
@ -1891,7 +1891,7 @@ meta_screen_get_current_xinerama (MetaScreen *screen)
int i; int i;
MetaRectangle pointer_position; MetaRectangle pointer_position;
screen->display->xinerama_cache_invalidated = FALSE; screen->display->monitor_cache_invalidated = FALSE;
pointer_position.width = pointer_position.height = 1; pointer_position.width = pointer_position.height = 1;
XQueryPointer (screen->display->xdisplay, XQueryPointer (screen->display->xdisplay,
@ -1904,23 +1904,23 @@ meta_screen_get_current_xinerama (MetaScreen *screen)
&win_y_return, &win_y_return,
&mask_return); &mask_return);
screen->last_xinerama_index = 0; screen->last_monitor_index = 0;
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
{ {
if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect, if (meta_rectangle_contains_rect (&screen->monitor_infos[i].rect,
&pointer_position)) &pointer_position))
{ {
screen->last_xinerama_index = i; screen->last_monitor_index = i;
break; break;
} }
} }
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Rechecked current Xinerama, now %d\n", "Rechecked current monitor, now %d\n",
screen->last_xinerama_index); screen->last_monitor_index);
} }
return &screen->xinerama_infos[screen->last_xinerama_index]; return &screen->monitor_infos[screen->last_monitor_index];
} }
#define _NET_WM_ORIENTATION_HORZ 0 #define _NET_WM_ORIENTATION_HORZ 0
@ -2145,7 +2145,7 @@ set_work_area_hint (MetaScreen *screen)
if (workspace->screen == screen) if (workspace->screen == screen)
{ {
meta_workspace_get_work_area_all_xineramas (workspace, &area); meta_workspace_get_work_area_all_monitors (workspace, &area);
tmp[0] = area.x; tmp[0] = area.x;
tmp[1] = area.y; tmp[1] = area.y;
tmp[2] = area.width; tmp[2] = area.width;
@ -2513,7 +2513,7 @@ meta_screen_resize (MetaScreen *screen,
screen->rect.width = width; screen->rect.width = width;
screen->rect.height = height; screen->rect.height = height;
reload_xinerama_infos (screen); reload_monitor_infos (screen);
set_desktop_geometry_hint (screen); set_desktop_geometry_hint (screen);
if (screen->display->compositor) if (screen->display->compositor)

8
src/core/stack.c
View File

@ -224,14 +224,14 @@ is_focused_foreach (MetaWindow *window,
} }
static gboolean static gboolean
windows_on_different_xinerama (MetaWindow *a, windows_on_different_monitor (MetaWindow *a,
MetaWindow *b) MetaWindow *b)
{ {
if (a->screen != b->screen) if (a->screen != b->screen)
return TRUE; return TRUE;
return meta_screen_get_xinerama_for_window (a->screen, a) != return meta_screen_get_monitor_for_window (a->screen, a) !=
meta_screen_get_xinerama_for_window (b->screen, b); meta_screen_get_monitor_for_window (b->screen, b);
} }
/* Get layer ignoring any transient or group relationships */ /* Get layer ignoring any transient or group relationships */
@ -275,7 +275,7 @@ get_standalone_layer (MetaWindow *window)
window == window->display->expected_focus_window || window == window->display->expected_focus_window ||
window->display->expected_focus_window == NULL || window->display->expected_focus_window == NULL ||
(window->display->expected_focus_window != NULL && (window->display->expected_focus_window != NULL &&
windows_on_different_xinerama (window, windows_on_different_monitor (window,
window->display->expected_focus_window)))) window->display->expected_focus_window))))
layer = META_LAYER_FULLSCREEN; layer = META_LAYER_FULLSCREEN;
else if (window->wm_state_above) else if (window->wm_state_above)

66
src/core/testboxes.c
View File

@ -85,7 +85,7 @@ new_screen_edge (int x, int y, int width, int height, int side_type)
} }
static MetaEdge* static MetaEdge*
new_xinerama_edge (int x, int y, int width, int height, int side_type) new_monitor_edge (int x, int y, int width, int height, int side_type)
{ {
MetaEdge* temporary; MetaEdge* temporary;
temporary = g_new (MetaEdge, 1); temporary = g_new (MetaEdge, 1);
@ -94,7 +94,7 @@ new_xinerama_edge (int x, int y, int width, int height, int side_type)
temporary->rect.width = width; temporary->rect.width = width;
temporary->rect.height = height; temporary->rect.height = height;
temporary->side_type = side_type; temporary->side_type = side_type;
temporary->edge_type = META_EDGE_XINERAMA; temporary->edge_type = META_EDGE_MONITOR;
return temporary; return temporary;
} }
@ -317,15 +317,15 @@ get_screen_edges (int which)
} }
static GList* static GList*
get_xinerama_edges (int which_xinerama_set, int which_strut_set) get_monitor_edges (int which_monitor_set, int which_strut_set)
{ {
GList *ret; GList *ret;
GSList *struts; GSList *struts;
GList *xins; GList *xins;
xins = NULL; xins = NULL;
g_assert (which_xinerama_set >=0 && which_xinerama_set <= 3); g_assert (which_monitor_set >=0 && which_monitor_set <= 3);
switch (which_xinerama_set) switch (which_monitor_set)
{ {
case 0: case 0:
xins = g_list_prepend (xins, new_meta_rect ( 0, 0, 1600, 1200)); xins = g_list_prepend (xins, new_meta_rect ( 0, 0, 1600, 1200));
@ -348,7 +348,7 @@ get_xinerama_edges (int which_xinerama_set, int which_strut_set)
ret = NULL; ret = NULL;
struts = get_strut_list (which_strut_set); struts = get_strut_list (which_strut_set);
ret = meta_rectangle_find_nonintersected_xinerama_edges (xins, struts); ret = meta_rectangle_find_nonintersected_monitor_edges (xins, struts);
free_strut_list (struts); free_strut_list (struts);
meta_rectangle_free_list_and_elements (xins); meta_rectangle_free_list_and_elements (xins);
@ -1145,7 +1145,7 @@ test_find_onscreen_edges ()
} }
static void static void
test_find_nonintersected_xinerama_edges () test_find_nonintersected_monitor_edges ()
{ {
GList* edges; GList* edges;
GList* tmp; GList* tmp;
@ -1156,32 +1156,32 @@ test_find_nonintersected_xinerama_edges ()
int bottom = META_DIRECTION_BOTTOM; int bottom = META_DIRECTION_BOTTOM;
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 0 for with region 0 has the correct edges */ /* Make sure test monitor set 0 for with region 0 has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (0, 0); edges = get_monitor_edges (0, 0);
tmp = NULL; tmp = NULL;
verify_edge_lists_are_equal (edges, tmp); verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp); meta_rectangle_free_list_and_elements (tmp);
meta_rectangle_free_list_and_elements (edges); meta_rectangle_free_list_and_elements (edges);
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 2 for with region 1 has the correct edges */ /* Make sure test monitor set 2 for with region 1 has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (2, 1); edges = get_monitor_edges (2, 1);
tmp = NULL; tmp = NULL;
tmp = g_list_prepend (tmp, new_xinerama_edge ( 0, 600, 1600, 0, bottom)); tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 1600, 0, bottom));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 0, 600, 1600, 0, top)); tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 1600, 0, top));
verify_edge_lists_are_equal (edges, tmp); verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp); meta_rectangle_free_list_and_elements (tmp);
meta_rectangle_free_list_and_elements (edges); meta_rectangle_free_list_and_elements (edges);
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 1 for with region 2 has the correct edges */ /* Make sure test monitor set 1 for with region 2 has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (1, 2); edges = get_monitor_edges (1, 2);
tmp = NULL; tmp = NULL;
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 20, 0, 1080, right)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 20, 0, 1080, right));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 20, 0, 1180, left)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 20, 0, 1180, left));
#if 0 #if 0
#define FUDGE 50 #define FUDGE 50
char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE]; char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
@ -1195,36 +1195,36 @@ test_find_nonintersected_xinerama_edges ()
meta_rectangle_free_list_and_elements (edges); meta_rectangle_free_list_and_elements (edges);
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 3 for with region 3 has the correct edges */ /* Make sure test monitor set 3 for with region 3 has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (3, 3); edges = get_monitor_edges (3, 3);
tmp = NULL; tmp = NULL;
tmp = g_list_prepend (tmp, new_xinerama_edge ( 900, 600, 700, 0, bottom)); tmp = g_list_prepend (tmp, new_monitor_edge ( 900, 600, 700, 0, bottom));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 0, 600, 700, 0, bottom)); tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 700, 0, bottom));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 900, 600, 700, 0, top)); tmp = g_list_prepend (tmp, new_monitor_edge ( 900, 600, 700, 0, top));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 0, 600, 700, 0, top)); tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 700, 0, top));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 675, 0, 425, right)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 675, 0, 425, right));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 675, 0, 525, left)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 675, 0, 525, left));
verify_edge_lists_are_equal (edges, tmp); verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp); meta_rectangle_free_list_and_elements (tmp);
meta_rectangle_free_list_and_elements (edges); meta_rectangle_free_list_and_elements (edges);
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 3 for with region 4 has the correct edges */ /* Make sure test monitor set 3 for with region 4 has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (3, 4); edges = get_monitor_edges (3, 4);
tmp = NULL; tmp = NULL;
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 600, 800, 0, bottom)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 800, 0, bottom));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 600, 800, 0, top)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 800, 0, top));
tmp = g_list_prepend (tmp, new_xinerama_edge ( 800, 600, 0, 600, right)); tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 0, 600, right));
verify_edge_lists_are_equal (edges, tmp); verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp); meta_rectangle_free_list_and_elements (tmp);
meta_rectangle_free_list_and_elements (edges); meta_rectangle_free_list_and_elements (edges);
/*************************************************************************/ /*************************************************************************/
/* Make sure test xinerama set 3 for with region 5has the correct edges */ /* Make sure test monitor set 3 for with region 5has the correct edges */
/*************************************************************************/ /*************************************************************************/
edges = get_xinerama_edges (3, 5); edges = get_monitor_edges (3, 5);
tmp = NULL; tmp = NULL;
verify_edge_lists_are_equal (edges, tmp); verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp); meta_rectangle_free_list_and_elements (tmp);
@ -1405,7 +1405,7 @@ main()
/* And now the functions dealing with edges more than boxes */ /* And now the functions dealing with edges more than boxes */
test_find_onscreen_edges (); test_find_onscreen_edges ();
test_find_nonintersected_xinerama_edges (); test_find_nonintersected_monitor_edges ();
/* And now the misfit functions that don't quite fit in anywhere else... */ /* And now the misfit functions that don't quite fit in anywhere else... */
test_gravity_resize (); test_gravity_resize ();

12
src/core/window-private.h
View File

@ -139,8 +139,8 @@ struct _MetaWindow
/* Whether we're trying to constrain the window to be fully onscreen */ /* Whether we're trying to constrain the window to be fully onscreen */
guint require_fully_onscreen : 1; guint require_fully_onscreen : 1;
/* Whether we're trying to constrain the window to be on a single xinerama */ /* Whether we're trying to constrain the window to be on a single monitor */
guint require_on_single_xinerama : 1; guint require_on_single_monitor : 1;
/* Whether we're trying to constrain the window's titlebar to be onscreen */ /* Whether we're trying to constrain the window's titlebar to be onscreen */
guint require_titlebar_visible : 1; guint require_titlebar_visible : 1;
@ -544,12 +544,12 @@ GList* meta_window_get_workspaces (MetaWindow *window);
gboolean meta_window_located_on_workspace (MetaWindow *window, gboolean meta_window_located_on_workspace (MetaWindow *window,
MetaWorkspace *workspace); MetaWorkspace *workspace);
void meta_window_get_work_area_current_xinerama (MetaWindow *window, void meta_window_get_work_area_current_monitor (MetaWindow *window,
MetaRectangle *area); MetaRectangle *area);
void meta_window_get_work_area_for_xinerama (MetaWindow *window, void meta_window_get_work_area_for_monitor (MetaWindow *window,
int which_xinerama, int which_monitor,
MetaRectangle *area); MetaRectangle *area);
void meta_window_get_work_area_all_xineramas (MetaWindow *window, void meta_window_get_work_area_all_monitors (MetaWindow *window,
MetaRectangle *area); MetaRectangle *area);

70
src/core/window.c
View File

@ -675,7 +675,7 @@ meta_window_new_with_attrs (MetaDisplay *display,
window->fullscreen = FALSE; window->fullscreen = FALSE;
window->fullscreen_monitors[0] = -1; window->fullscreen_monitors[0] = -1;
window->require_fully_onscreen = TRUE; window->require_fully_onscreen = TRUE;
window->require_on_single_xinerama = TRUE; window->require_on_single_monitor = TRUE;
window->require_titlebar_visible = TRUE; window->require_titlebar_visible = TRUE;
window->on_all_workspaces = FALSE; window->on_all_workspaces = FALSE;
window->shaded = FALSE; window->shaded = FALSE;
@ -3241,10 +3241,10 @@ meta_window_update_fullscreen_monitors (MetaWindow *window,
unsigned long left, unsigned long left,
unsigned long right) unsigned long right)
{ {
if ((int)top < window->screen->n_xinerama_infos && if ((int)top < window->screen->n_monitor_infos &&
(int)bottom < window->screen->n_xinerama_infos && (int)bottom < window->screen->n_monitor_infos &&
(int)left < window->screen->n_xinerama_infos && (int)left < window->screen->n_monitor_infos &&
(int)right < window->screen->n_xinerama_infos) (int)right < window->screen->n_monitor_infos)
{ {
window->fullscreen_monitors[0] = top; window->fullscreen_monitors[0] = top;
window->fullscreen_monitors[1] = bottom; window->fullscreen_monitors[1] = bottom;
@ -6788,7 +6788,7 @@ recalc_window_features (MetaWindow *window)
/* don't allow fullscreen if we can't resize, unless the size /* don't allow fullscreen if we can't resize, unless the size
* is entire screen size (kind of broken, because we * is entire screen size (kind of broken, because we
* actually fullscreen to xinerama head 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->screen->rect.width &&
window->size_hints.min_height == window->screen->rect.height) window->size_hints.min_height == window->screen->rect.height)
@ -7449,22 +7449,22 @@ update_move (MetaWindow *window,
return; return;
} }
/* remaximize window on an other xinerama monitor if window has /* remaximize window on another monitor if window has been shaken
* been shaken loose or it is still maximized (then move straight) * loose or it is still maximized (then move straight)
*/ */
else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window)) else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window))
{ {
const MetaXineramaScreenInfo *wxinerama; const MetaMonitorInfo *wmonitor;
MetaRectangle work_area; MetaRectangle work_area;
int monitor; int monitor;
wxinerama = meta_screen_get_xinerama_for_window (window->screen, window); wmonitor = meta_screen_get_monitor_for_window (window->screen, window);
for (monitor = 0; monitor < window->screen->n_xinerama_infos; monitor++) for (monitor = 0; monitor < window->screen->n_monitor_infos; monitor++)
{ {
meta_window_get_work_area_for_xinerama (window, monitor, &work_area); meta_window_get_work_area_for_monitor (window, monitor, &work_area);
/* check if cursor is near the top of a xinerama work area */ /* check if cursor is near the top of a monitor work area */
if (x >= work_area.x && if (x >= work_area.x &&
x < (work_area.x + work_area.width) && x < (work_area.x + work_area.width) &&
y >= work_area.y && y >= work_area.y &&
@ -7473,7 +7473,7 @@ update_move (MetaWindow *window,
/* move the saved rect if window will become maximized on an /* move the saved rect if window will become maximized on an
* other monitor so user isn't surprised on a later unmaximize * other monitor so user isn't surprised on a later unmaximize
*/ */
if (wxinerama->number != monitor) if (wmonitor->number != monitor)
{ {
window->saved_rect.x = work_area.x; window->saved_rect.x = work_area.x;
window->saved_rect.y = work_area.y; window->saved_rect.y = work_area.y;
@ -7955,23 +7955,23 @@ meta_window_set_gravity (MetaWindow *window,
} }
static void static void
get_work_area_xinerama (MetaWindow *window, get_work_area_monitor (MetaWindow *window,
MetaRectangle *area, MetaRectangle *area,
int which_xinerama) int which_monitor)
{ {
GList *tmp; GList *tmp;
g_assert (which_xinerama >= 0); g_assert (which_monitor >= 0);
/* Initialize to the whole xinerama */ /* Initialize to the whole monitor */
*area = window->screen->xinerama_infos[which_xinerama].rect; *area = window->screen->monitor_infos[which_monitor].rect;
tmp = meta_window_get_workspaces (window); tmp = meta_window_get_workspaces (window);
while (tmp != NULL) while (tmp != NULL)
{ {
MetaRectangle workspace_work_area; MetaRectangle workspace_work_area;
meta_workspace_get_work_area_for_xinerama (tmp->data, meta_workspace_get_work_area_for_monitor (tmp->data,
which_xinerama, which_monitor,
&workspace_work_area); &workspace_work_area);
meta_rectangle_intersect (area, meta_rectangle_intersect (area,
&workspace_work_area, &workspace_work_area,
@ -7980,38 +7980,38 @@ get_work_area_xinerama (MetaWindow *window,
} }
meta_topic (META_DEBUG_WORKAREA, meta_topic (META_DEBUG_WORKAREA,
"Window %s xinerama %d has work area %d,%d %d x %d\n", "Window %s monitor %d has work area %d,%d %d x %d\n",
window->desc, which_xinerama, window->desc, which_monitor,
area->x, area->y, area->width, area->height); area->x, area->y, area->width, area->height);
} }
void void
meta_window_get_work_area_current_xinerama (MetaWindow *window, meta_window_get_work_area_current_monitor (MetaWindow *window,
MetaRectangle *area) MetaRectangle *area)
{ {
const MetaXineramaScreenInfo *xinerama = NULL; const MetaMonitorInfo *monitor = NULL;
xinerama = meta_screen_get_xinerama_for_window (window->screen, monitor = meta_screen_get_monitor_for_window (window->screen,
window); window);
meta_window_get_work_area_for_xinerama (window, meta_window_get_work_area_for_monitor (window,
xinerama->number, monitor->number,
area); area);
} }
void void
meta_window_get_work_area_for_xinerama (MetaWindow *window, meta_window_get_work_area_for_monitor (MetaWindow *window,
int which_xinerama, int which_monitor,
MetaRectangle *area) MetaRectangle *area)
{ {
g_return_if_fail (which_xinerama >= 0); g_return_if_fail (which_monitor >= 0);
get_work_area_xinerama (window, get_work_area_monitor (window,
area, area,
which_xinerama); which_monitor);
} }
void void
meta_window_get_work_area_all_xineramas (MetaWindow *window, meta_window_get_work_area_all_monitors (MetaWindow *window,
MetaRectangle *area) MetaRectangle *area)
{ {
GList *tmp; GList *tmp;
@ -8023,7 +8023,7 @@ meta_window_get_work_area_all_xineramas (MetaWindow *window,
while (tmp != NULL) while (tmp != NULL)
{ {
MetaRectangle workspace_work_area; MetaRectangle workspace_work_area;
meta_workspace_get_work_area_all_xineramas (tmp->data, meta_workspace_get_work_area_all_monitors (tmp->data,
&workspace_work_area); &workspace_work_area);
meta_rectangle_intersect (area, meta_rectangle_intersect (area,
&workspace_work_area, &workspace_work_area,

18
src/core/workspace-private.h
View File

@ -47,12 +47,12 @@ struct _MetaWorkspace
GList *list_containing_self; GList *list_containing_self;
MetaRectangle work_area_screen; MetaRectangle work_area_screen;
MetaRectangle *work_area_xinerama; MetaRectangle *work_area_monitor;
GList *screen_region; GList *screen_region;
GList **xinerama_region; GList **monitor_region;
gint n_xinerama_regions; gint n_monitor_regions;
GList *screen_edges; GList *screen_edges;
GList *xinerama_edges; GList *monitor_edges;
GSList *builtin_struts; GSList *builtin_struts;
GSList *all_struts; GSList *all_struts;
guint work_areas_invalid : 1; guint work_areas_invalid : 1;
@ -77,14 +77,12 @@ void meta_workspace_relocate_windows (MetaWorkspace *workspace,
void meta_workspace_invalidate_work_area (MetaWorkspace *workspace); void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);
void meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace, void meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
int which_xinerama, int which_monitor,
MetaRectangle *area); MetaRectangle *area);
GList* meta_workspace_get_onscreen_region (MetaWorkspace *workspace); GList* meta_workspace_get_onscreen_region (MetaWorkspace *workspace);
GList* meta_workspace_get_onxinerama_region (MetaWorkspace *workspace, GList* meta_workspace_get_onmonitor_region (MetaWorkspace *workspace,
int which_xinerama); int which_monitor);
void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
MetaRectangle *area);
void meta_workspace_focus_default_window (MetaWorkspace *workspace, void meta_workspace_focus_default_window (MetaWorkspace *workspace,
MetaWindow *not_this_one, MetaWindow *not_this_one,

110
src/core/workspace.c
View File

@ -170,16 +170,16 @@ meta_workspace_new (MetaScreen *screen)
meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list); meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list);
workspace->work_areas_invalid = TRUE; workspace->work_areas_invalid = TRUE;
workspace->work_area_xinerama = NULL; workspace->work_area_monitor = NULL;
workspace->work_area_screen.x = 0; workspace->work_area_screen.x = 0;
workspace->work_area_screen.y = 0; workspace->work_area_screen.y = 0;
workspace->work_area_screen.width = 0; workspace->work_area_screen.width = 0;
workspace->work_area_screen.height = 0; workspace->work_area_screen.height = 0;
workspace->screen_region = NULL; workspace->screen_region = NULL;
workspace->xinerama_region = NULL; workspace->monitor_region = NULL;
workspace->screen_edges = NULL; workspace->screen_edges = NULL;
workspace->xinerama_edges = NULL; workspace->monitor_edges = NULL;
workspace->list_containing_self = g_list_prepend (NULL, workspace); workspace->list_containing_self = g_list_prepend (NULL, workspace);
workspace->builtin_struts = NULL; workspace->builtin_struts = NULL;
@ -263,7 +263,7 @@ meta_workspace_remove (MetaWorkspace *workspace)
workspace->screen->workspaces = workspace->screen->workspaces =
g_list_remove (workspace->screen->workspaces, workspace); g_list_remove (workspace->screen->workspaces, workspace);
g_free (workspace->work_area_xinerama); g_free (workspace->work_area_monitor);
g_list_free (workspace->mru_list); g_list_free (workspace->mru_list);
g_list_free (workspace->list_containing_self); g_list_free (workspace->list_containing_self);
@ -280,12 +280,12 @@ meta_workspace_remove (MetaWorkspace *workspace)
if (!workspace->work_areas_invalid) if (!workspace->work_areas_invalid)
{ {
workspace_free_all_struts (workspace); workspace_free_all_struts (workspace);
for (i = 0; i < screen->n_xinerama_infos; i++) for (i = 0; i < screen->n_monitor_infos; i++)
meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]); meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
g_free (workspace->xinerama_region); g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region); meta_rectangle_free_list_and_elements (workspace->screen_region);
meta_rectangle_free_list_and_elements (workspace->screen_edges); meta_rectangle_free_list_and_elements (workspace->screen_edges);
meta_rectangle_free_list_and_elements (workspace->xinerama_edges); meta_rectangle_free_list_and_elements (workspace->monitor_edges);
} }
g_object_unref (workspace); g_object_unref (workspace);
@ -713,21 +713,21 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
"Invalidating work area for workspace %d\n", "Invalidating work area for workspace %d\n",
meta_workspace_index (workspace)); meta_workspace_index (workspace));
g_free (workspace->work_area_xinerama); g_free (workspace->work_area_monitor);
workspace->work_area_xinerama = NULL; workspace->work_area_monitor = NULL;
workspace_free_all_struts (workspace); workspace_free_all_struts (workspace);
for (i = 0; i < workspace->screen->n_xinerama_infos; i++) for (i = 0; i < workspace->screen->n_monitor_infos; i++)
meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]); meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
g_free (workspace->xinerama_region); g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region); meta_rectangle_free_list_and_elements (workspace->screen_region);
meta_rectangle_free_list_and_elements (workspace->screen_edges); meta_rectangle_free_list_and_elements (workspace->screen_edges);
meta_rectangle_free_list_and_elements (workspace->xinerama_edges); meta_rectangle_free_list_and_elements (workspace->monitor_edges);
workspace->xinerama_region = NULL; workspace->monitor_region = NULL;
workspace->screen_region = NULL; workspace->screen_region = NULL;
workspace->screen_edges = NULL; workspace->screen_edges = NULL;
workspace->xinerama_edges = NULL; workspace->monitor_edges = NULL;
workspace->work_areas_invalid = TRUE; workspace->work_areas_invalid = TRUE;
@ -780,10 +780,10 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
return; return;
g_assert (workspace->all_struts == NULL); g_assert (workspace->all_struts == NULL);
g_assert (workspace->xinerama_region == NULL); g_assert (workspace->monitor_region == NULL);
g_assert (workspace->screen_region == NULL); g_assert (workspace->screen_region == NULL);
g_assert (workspace->screen_edges == NULL); g_assert (workspace->screen_edges == NULL);
g_assert (workspace->xinerama_edges == NULL); g_assert (workspace->monitor_edges == NULL);
/* STEP 1: Get the list of struts */ /* STEP 1: Get the list of struts */
@ -803,18 +803,18 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
g_list_free (windows); g_list_free (windows);
/* STEP 2: Get the maximal/spanning rects for the onscreen and /* STEP 2: Get the maximal/spanning rects for the onscreen and
* on-single-xinerama regions * on-single-monitor regions
*/ */
g_assert (workspace->xinerama_region == NULL); g_assert (workspace->monitor_region == NULL);
g_assert (workspace->screen_region == NULL); g_assert (workspace->screen_region == NULL);
workspace->xinerama_region = g_new (GList*, workspace->monitor_region = g_new (GList*,
workspace->screen->n_xinerama_infos); workspace->screen->n_monitor_infos);
for (i = 0; i < workspace->screen->n_xinerama_infos; i++) for (i = 0; i < workspace->screen->n_monitor_infos; i++)
{ {
workspace->xinerama_region[i] = workspace->monitor_region[i] =
meta_rectangle_get_minimal_spanning_set_for_region ( meta_rectangle_get_minimal_spanning_set_for_region (
&workspace->screen->xinerama_infos[i].rect, &workspace->screen->monitor_infos[i].rect,
workspace->all_struts); workspace->all_struts);
} }
workspace->screen_region = workspace->screen_region =
@ -823,7 +823,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
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
* xineramas. * monitors.
*/ */
work_area = workspace->screen->rect; /* start with the screen */ work_area = workspace->screen->rect; /* start with the screen */
if (workspace->screen_region == NULL) if (workspace->screen_region == NULL)
@ -878,35 +878,35 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
workspace->work_area_screen.width, workspace->work_area_screen.width,
workspace->work_area_screen.height); workspace->work_area_screen.height);
/* Now find the work areas for each xinerama */ /* Now find the work areas for each monitor */
g_free (workspace->work_area_xinerama); g_free (workspace->work_area_monitor);
workspace->work_area_xinerama = g_new (MetaRectangle, workspace->work_area_monitor = g_new (MetaRectangle,
workspace->screen->n_xinerama_infos); workspace->screen->n_monitor_infos);
for (i = 0; i < workspace->screen->n_xinerama_infos; i++) for (i = 0; i < workspace->screen->n_monitor_infos; i++)
{ {
work_area = workspace->screen->xinerama_infos[i].rect; work_area = workspace->screen->monitor_infos[i].rect;
if (workspace->xinerama_region[i] == NULL) if (workspace->monitor_region[i] == NULL)
/* FIXME: constraints.c untested with this, but it might be nice for /* FIXME: constraints.c untested with this, but it might be nice for
* a screen reader or magnifier. * a screen reader or magnifier.
*/ */
work_area = meta_rect (work_area.x, work_area.y, -1, -1); work_area = meta_rect (work_area.x, work_area.y, -1, -1);
else else
meta_rectangle_clip_to_region (workspace->xinerama_region[i], meta_rectangle_clip_to_region (workspace->monitor_region[i],
FIXED_DIRECTION_NONE, FIXED_DIRECTION_NONE,
&work_area); &work_area);
workspace->work_area_xinerama[i] = work_area; workspace->work_area_monitor[i] = work_area;
meta_topic (META_DEBUG_WORKAREA, meta_topic (META_DEBUG_WORKAREA,
"Computed work area for workspace %d " "Computed work area for workspace %d "
"xinerama %d: %d,%d %d x %d\n", "monitor %d: %d,%d %d x %d\n",
meta_workspace_index (workspace), meta_workspace_index (workspace),
i, i,
workspace->work_area_xinerama[i].x, workspace->work_area_monitor[i].x,
workspace->work_area_xinerama[i].y, workspace->work_area_monitor[i].y,
workspace->work_area_xinerama[i].width, workspace->work_area_monitor[i].width,
workspace->work_area_xinerama[i].height); workspace->work_area_monitor[i].height);
} }
/* STEP 4: Make sure the screen_region is nonempty (separate from step 2 /* STEP 4: Make sure the screen_region is nonempty (separate from step 2
@ -920,17 +920,17 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
workspace->screen_region = g_list_prepend (NULL, nonempty_region); workspace->screen_region = g_list_prepend (NULL, nonempty_region);
} }
/* STEP 5: Cache screen and xinerama edges for edge resistance and snapping */ /* STEP 5: Cache screen and monitor edges for edge resistance and snapping */
g_assert (workspace->screen_edges == NULL); g_assert (workspace->screen_edges == NULL);
g_assert (workspace->xinerama_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->rect,
workspace->all_struts); workspace->all_struts);
tmp = NULL; tmp = NULL;
for (i = 0; i < workspace->screen->n_xinerama_infos; i++) for (i = 0; i < workspace->screen->n_monitor_infos; i++)
tmp = g_list_prepend (tmp, &workspace->screen->xinerama_infos[i].rect); tmp = g_list_prepend (tmp, &workspace->screen->monitor_infos[i].rect);
workspace->xinerama_edges = workspace->monitor_edges =
meta_rectangle_find_nonintersected_xinerama_edges (tmp, meta_rectangle_find_nonintersected_monitor_edges (tmp,
workspace->all_struts); workspace->all_struts);
g_list_free (tmp); g_list_free (tmp);
@ -970,20 +970,20 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
} }
void void
meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace, meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
int which_xinerama, int which_monitor,
MetaRectangle *area) MetaRectangle *area)
{ {
g_assert (which_xinerama >= 0); g_assert (which_monitor >= 0);
ensure_work_areas_validated (workspace); ensure_work_areas_validated (workspace);
g_assert (which_xinerama < workspace->screen->n_xinerama_infos); g_assert (which_monitor < workspace->screen->n_monitor_infos);
*area = workspace->work_area_xinerama[which_xinerama]; *area = workspace->work_area_monitor[which_monitor];
} }
void void
meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace, meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
MetaRectangle *area) MetaRectangle *area)
{ {
ensure_work_areas_validated (workspace); ensure_work_areas_validated (workspace);
@ -1000,12 +1000,12 @@ meta_workspace_get_onscreen_region (MetaWorkspace *workspace)
} }
GList* GList*
meta_workspace_get_onxinerama_region (MetaWorkspace *workspace, meta_workspace_get_onmonitor_region (MetaWorkspace *workspace,
int which_xinerama) int which_monitor)
{ {
ensure_work_areas_validated (workspace); ensure_work_areas_validated (workspace);
return workspace->xinerama_region[which_xinerama]; return workspace->monitor_region[which_monitor];
} }
#ifdef WITH_VERBOSE_MODE #ifdef WITH_VERBOSE_MODE

10
src/include/boxes.h
View File

@ -58,7 +58,7 @@ typedef enum
typedef enum typedef enum
{ {
META_EDGE_WINDOW, META_EDGE_WINDOW,
META_EDGE_XINERAMA, META_EDGE_MONITOR,
META_EDGE_SCREEN META_EDGE_SCREEN
} MetaEdgeType; } MetaEdgeType;
@ -193,7 +193,7 @@ void meta_rectangle_expand_to_avoiding_struts (
* or * or
* meta_rectangle_find_onscreen_edges () * meta_rectangle_find_onscreen_edges ()
* or * or
* meta_rectangle_find_nonintersected_xinerama_edges() * meta_rectangle_find_nonintersected_monitor_edges()
*/ */
void meta_rectangle_free_list_and_elements (GList *filled_list); void meta_rectangle_free_list_and_elements (GList *filled_list);
@ -280,11 +280,11 @@ GList* meta_rectangle_remove_intersections_with_boxes_from_edges (
GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect, GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
const GSList *all_struts); const GSList *all_struts);
/* Finds edges between adjacent xineramas which are not covered by the given /* Finds edges between adjacent monitors which are not covered by the given
* struts. * struts.
*/ */
GList* meta_rectangle_find_nonintersected_xinerama_edges ( GList* meta_rectangle_find_nonintersected_monitor_edges (
const GList *xinerama_rects, const GList *monitor_rects,
const GSList *all_struts); const GSList *all_struts);
#endif /* META_BOXES_H */ #endif /* META_BOXES_H */

2
src/include/workspace.h
View File

@ -51,7 +51,7 @@ GType meta_workspace_get_type (void);
int meta_workspace_index (MetaWorkspace *workspace); int meta_workspace_index (MetaWorkspace *workspace);
MetaScreen *meta_workspace_get_screen (MetaWorkspace *workspace); MetaScreen *meta_workspace_get_screen (MetaWorkspace *workspace);
GList* meta_workspace_list_windows (MetaWorkspace *workspace); GList* meta_workspace_list_windows (MetaWorkspace *workspace);
void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace, void meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
MetaRectangle *area); MetaRectangle *area);
void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp); void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp);
void meta_workspace_activate_with_focus (MetaWorkspace *workspace, void meta_workspace_activate_with_focus (MetaWorkspace *workspace,