[mutter] Refer to monitors as "monitors" rather than "xineramas"
- From: Dan Winship <danw src gnome org>
- To: svn-commits-list gnome org
- Cc:
- Subject: [mutter] Refer to monitors as "monitors" rather than "xineramas"
- Date: Mon, 31 Aug 2009 18:40:21 +0000 (UTC)
commit 3a1e492afc5036c65a5184b70f769a6a22f5291c
Author: Dan Winship <danw gnome org>
Date: Mon Aug 31 09:52:16 2009 -0400
Refer to monitors as "monitors" rather than "xineramas"
http://bugzilla.gnome.org/show_bug.cgi?id=593686
src/core/boxes.c | 28 ++--
src/core/constraints.c | 192 ++++++++++++++--------------
src/core/display-private.h | 4 +-
src/core/display.c | 4 +-
src/core/edge-resistance.c | 32 +++---
src/core/keybindings.c | 4 +-
src/core/place.c | 38 +++---
src/core/screen-private.h | 34 +++---
src/core/screen.c | 294 +++++++++++++++++++++---------------------
src/core/stack.c | 12 +-
src/core/testboxes.c | 66 +++++-----
src/core/window-private.h | 18 ++--
src/core/window.c | 88 +++++++-------
src/core/workspace-private.h | 18 +--
src/core/workspace.c | 114 ++++++++--------
src/include/boxes.h | 10 +-
src/include/workspace.h | 4 +-
17 files changed, 479 insertions(+), 481 deletions(-)
---
diff --git a/src/core/boxes.c b/src/core/boxes.c
index dda283a..bc596bd 100644
--- a/src/core/boxes.c
+++ b/src/core/boxes.c
@@ -535,7 +535,7 @@ meta_rectangle_get_minimal_spanning_set_for_region (
* 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
* 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
* ridiculously huge numbers of partial struts), possible optimizations
* include:
@@ -1792,14 +1792,14 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
}
GList*
-meta_rectangle_find_nonintersected_xinerama_edges (
- const GList *xinerama_rects,
+meta_rectangle_find_nonintersected_monitor_edges (
+ const GList *monitor_rects,
const GSList *all_struts)
{
/* This function cannot easily be merged with
* meta_rectangle_find_onscreen_edges() because real screen edges
* 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;
const GList *cur;
@@ -1808,14 +1808,14 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* Initialize the return list to be empty */
ret = NULL;
- /* start of ret with all the edges of xineramas that are adjacent to
- * another xinerama.
+ /* start of ret with all the edges of monitors that are adjacent to
+ * another monitor.
*/
- cur = xinerama_rects;
+ cur = monitor_rects;
while (cur)
{
MetaRectangle *cur_rect = cur->data;
- const GList *compare = xinerama_rects;
+ const GList *compare = monitor_rects;
while (compare)
{
MetaRectangle *compare_rect = compare->data;
@@ -1849,15 +1849,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* If the rectangles really are adjacent */
if (x != INT_MIN)
{
- /* We need a left edge for the xinerama on the right, and
- * a right edge for the xinerama on the left. Just fill
+ /* We need a left edge for the monitor on the right, and
+ * a right edge for the monitor on the left. Just fill
* up the edges and stick 'em on the list.
*/
MetaEdge *new_edge = g_new (MetaEdge, 1);
new_edge->rect = meta_rect (x, y, width, height);
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);
}
@@ -1892,15 +1892,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
/* If the rectangles really are adjacent */
if (y != INT_MIN)
{
- /* We need a top edge for the xinerama on the bottom, and
- * a bottom edge for the xinerama on the top. Just fill
+ /* We need a top edge for the monitor on the bottom, and
+ * a bottom edge for the monitor on the top. Just fill
* up the edges and stick 'em on the list.
*/
MetaEdge *new_edge = g_new (MetaEdge, 1);
new_edge->rect = meta_rect (x, y, width, height);
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);
}
diff --git a/src/core/constraints.c b/src/core/constraints.c
index a8308cb..a6b3344 100644
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -93,7 +93,7 @@ typedef enum
{
PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
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_SIZE_HINTS_INCREMENTS = 1,
PRIORITY_MAXIMIZATION = 2,
@@ -127,17 +127,17 @@ typedef struct
int resize_gravity;
FixedDirections fixed_directions;
- /* work_area_xinerama - current xinerama region minus struts
- * entire_xinerama - current xienrama, including strut regions
+ /* work_area_monitor - current monitor region minus struts
+ * entire_monitor - current monitor, including strut regions
*/
- MetaRectangle work_area_xinerama;
- MetaRectangle entire_xinerama;
+ MetaRectangle work_area_monitor;
+ MetaRectangle entire_monitor;
/* 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_xinerama_region;
+ GList *usable_monitor_region;
} ConstraintInfo;
static gboolean constrain_maximization (MetaWindow *window,
@@ -160,7 +160,7 @@ static gboolean constrain_aspect_ratio (MetaWindow *window,
ConstraintInfo *info,
ConstraintPriority priority,
gboolean check_only);
-static gboolean constrain_to_single_xinerama (MetaWindow *window,
+static gboolean constrain_to_single_monitor (MetaWindow *window,
ConstraintInfo *info,
ConstraintPriority priority,
gboolean check_only);
@@ -214,7 +214,7 @@ static const Constraint all_constraints[] = {
{constrain_size_increments, "constrain_size_increments"},
{constrain_size_limits, "constrain_size_limits"},
{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_titlebar_visible, "constrain_titlebar_visible"},
{constrain_partially_onscreen, "constrain_partially_onscreen"},
@@ -311,7 +311,7 @@ meta_window_constrain (MetaWindow *window,
*new = info.current;
/* 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.
*/
update_onscreen_requirements (window, &info);
@@ -333,7 +333,7 @@ setup_constraint_info (ConstraintInfo *info,
const MetaRectangle *orig,
MetaRectangle *new)
{
- const MetaXineramaScreenInfo *xinerama_info;
+ const MetaMonitorInfo *monitor_info;
MetaWorkspace *cur_workspace;
info->orig = *orig;
@@ -387,15 +387,15 @@ setup_constraint_info (ConstraintInfo *info,
if (!info->is_user_action)
info->fixed_directions = FIXED_DIRECTION_NONE;
- xinerama_info =
- meta_screen_get_xinerama_for_rect (window->screen, &info->current);
- meta_window_get_work_area_for_xinerama (window,
- xinerama_info->number,
- &info->work_area_xinerama);
+ monitor_info =
+ meta_screen_get_monitor_for_rect (window->screen, &info->current);
+ meta_window_get_work_area_for_monitor (window,
+ monitor_info->number,
+ &info->work_area_monitor);
if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
{
- info->entire_xinerama = xinerama_info->rect;
+ info->entire_monitor = monitor_info->rect;
}
else
{
@@ -403,28 +403,28 @@ setup_constraint_info (ConstraintInfo *info,
long monitor;
monitor = window->fullscreen_monitors[i];
- info->entire_xinerama =
- window->screen->xinerama_infos[monitor].rect;
+ info->entire_monitor =
+ window->screen->monitor_infos[monitor].rect;
for (i = 1; i <= 3; i++)
{
monitor = window->fullscreen_monitors[i];
- meta_rectangle_union (&info->entire_xinerama,
- &window->screen->xinerama_infos[monitor].rect,
- &info->entire_xinerama);
+ meta_rectangle_union (&info->entire_monitor,
+ &window->screen->monitor_infos[monitor].rect,
+ &info->entire_monitor);
}
}
cur_workspace = window->screen->active_workspace;
info->usable_screen_region =
meta_workspace_get_onscreen_region (cur_workspace);
- info->usable_xinerama_region =
- meta_workspace_get_onxinerama_region (cur_workspace,
- xinerama_info->number);
+ info->usable_monitor_region =
+ meta_workspace_get_onmonitor_region (cur_workspace,
+ monitor_info->number);
/* Workaround braindead legacy apps that don't know how to
* fullscreen themselves properly.
*/
- if (meta_rectangle_equal (new, &xinerama_info->rect) &&
+ if (meta_rectangle_equal (new, &monitor_info->rect) &&
window->has_fullscreen_func &&
!window->fullscreen)
{
@@ -448,8 +448,8 @@ setup_constraint_info (ConstraintInfo *info,
" is_user_action : %s\n"
" resize_gravity : %s\n"
" fixed_directions: %s\n"
- " work_area_xinerama: %d,%d +%d,%d\n"
- " entire_xinerama : %d,%d +%d,%d\n",
+ " work_area_monitor: %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->current.x, info->current.y,
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_Y) ? "Y fixed" :
"Freakin' Invalid Stupid",
- info->work_area_xinerama.x, info->work_area_xinerama.y,
- info->work_area_xinerama.width,
- info->work_area_xinerama.height,
- info->entire_xinerama.x, info->entire_xinerama.y,
- info->entire_xinerama.width, info->entire_xinerama.height);
+ info->work_area_monitor.x, info->work_area_monitor.y,
+ info->work_area_monitor.width,
+ info->work_area_monitor.height,
+ info->entire_monitor.x, info->entire_monitor.y,
+ info->entire_monitor.width, info->entire_monitor.height);
}
static void
@@ -493,25 +493,25 @@ place_window_if_needed(MetaWindow *window,
{
MetaRectangle placed_rect = info->orig;
MetaWorkspace *cur_workspace;
- const MetaXineramaScreenInfo *xinerama_info;
+ const MetaMonitorInfo *monitor_info;
meta_window_place (window, info->fgeom, info->orig.x, info->orig.y,
&placed_rect.x, &placed_rect.y);
did_placement = TRUE;
- /* placing the window may have changed the xinerama. Find the
- * new xinerama and update the ConstraintInfo
+ /* placing the window may have changed the monitor. Find the
+ * new monitor and update the ConstraintInfo
*/
- xinerama_info =
- meta_screen_get_xinerama_for_rect (window->screen, &placed_rect);
- info->entire_xinerama = xinerama_info->rect;
- meta_window_get_work_area_for_xinerama (window,
- xinerama_info->number,
- &info->work_area_xinerama);
+ monitor_info =
+ meta_screen_get_monitor_for_rect (window->screen, &placed_rect);
+ info->entire_monitor = monitor_info->rect;
+ meta_window_get_work_area_for_monitor (window,
+ monitor_info->number,
+ &info->work_area_monitor);
cur_workspace = window->screen->active_workspace;
- info->usable_xinerama_region =
- meta_workspace_get_onxinerama_region (cur_workspace,
- xinerama_info->number);
+ info->usable_monitor_region =
+ meta_workspace_get_onmonitor_region (cur_workspace,
+ monitor_info->number);
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
* 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.x = info->work_area_xinerama.x +
- .125 * info->work_area_xinerama.width;
+ info->current.width = .75 * info->work_area_monitor.width;
+ info->current.x = info->work_area_monitor.x +
+ .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.y = info->work_area_xinerama.y +
- .083 * info->work_area_xinerama.height;
+ info->current.height = .75 * info->work_area_monitor.height;
+ info->current.y = info->work_area_monitor.y +
+ .083 * info->work_area_monitor.height;
}
if (window->maximize_horizontally_after_placement ||
@@ -589,7 +589,7 @@ update_onscreen_requirements (MetaWindow *window,
return;
/* 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
* certain constraints are ignored for user interactions regardless of
* 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.
*/
- /* 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
*/
extend_by_frame (&info->current, info->fgeom);
@@ -622,17 +622,17 @@ update_onscreen_requirements (MetaWindow *window,
window->require_fully_onscreen ? "TRUE" : "FALSE");
/* 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;
- window->require_on_single_xinerama =
- meta_rectangle_contained_in_region (info->usable_xinerama_region,
+ old = window->require_on_single_monitor;
+ window->require_on_single_monitor =
+ meta_rectangle_contained_in_region (info->usable_monitor_region,
&info->current);
- if (old ^ window->require_on_single_xinerama)
+ if (old ^ window->require_on_single_monitor)
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->require_on_single_xinerama ? "TRUE" : "FALSE");
+ window->require_on_single_monitor ? "TRUE" : "FALSE");
/* Update whether we want future constraint runs to require the
* titlebar to be visible.
@@ -735,7 +735,7 @@ constrain_maximization (MetaWindow *window,
/* Calculate target_size = maximized size of (window + frame) */
if (window->maximized_horizontally && window->maximized_vertically)
- target_size = info->work_area_xinerama;
+ target_size = info->work_area_monitor;
else
{
/* Amount of maximization possible in a single direction depends
@@ -757,7 +757,7 @@ constrain_maximization (MetaWindow *window,
target_size = info->current;
extend_by_frame (&target_size, info->fgeom);
meta_rectangle_expand_to_avoiding_struts (&target_size,
- &info->entire_xinerama,
+ &info->entire_monitor,
direction,
active_workspace_struts);
}
@@ -804,7 +804,7 @@ constrain_fullscreen (MetaWindow *window,
ConstraintPriority priority,
gboolean check_only)
{
- MetaRectangle min_size, max_size, xinerama;
+ MetaRectangle min_size, max_size, monitor;
gboolean too_big, too_small, constraint_already_satisfied;
if (priority > PRIORITY_FULLSCREEN)
@@ -814,22 +814,22 @@ constrain_fullscreen (MetaWindow *window,
if (!window->fullscreen)
return TRUE;
- xinerama = info->entire_xinerama;
+ monitor = info->entire_monitor;
get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
- too_big = !meta_rectangle_could_fit_rect (&xinerama, &min_size);
- too_small = !meta_rectangle_could_fit_rect (&max_size, &xinerama);
+ too_big = !meta_rectangle_could_fit_rect (&monitor, &min_size);
+ too_small = !meta_rectangle_could_fit_rect (&max_size, &monitor);
if (too_big || too_small)
return TRUE;
/* Determine whether constraint is already satisfied; exit if it is */
constraint_already_satisfied =
- meta_rectangle_equal (&info->current, &xinerama);
+ meta_rectangle_equal (&info->current, &monitor);
if (check_only || constraint_already_satisfied)
return constraint_already_satisfied;
/*** Enforce constraint ***/
- info->current = xinerama;
+ info->current = monitor;
return TRUE;
}
@@ -1091,7 +1091,7 @@ constrain_aspect_ratio (MetaWindow *window,
}
static gboolean
-do_screen_and_xinerama_relative_constraints (
+do_screen_and_monitor_relative_constraints (
MetaWindow *window,
GList *region_spanning_rectangles,
ConstraintInfo *info,
@@ -1107,7 +1107,7 @@ do_screen_and_xinerama_relative_constraints (
char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
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, ", ",
spanning_region));
}
@@ -1165,32 +1165,32 @@ do_screen_and_xinerama_relative_constraints (
}
static gboolean
-constrain_to_single_xinerama (MetaWindow *window,
- ConstraintInfo *info,
- ConstraintPriority priority,
- gboolean check_only)
+constrain_to_single_monitor (MetaWindow *window,
+ ConstraintInfo *info,
+ ConstraintPriority priority,
+ gboolean check_only)
{
- if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA)
+ if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR)
return TRUE;
/* 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
* "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 ||
window->type == META_WINDOW_DOCK ||
- window->screen->n_xinerama_infos == 1 ||
- !window->require_on_single_xinerama ||
+ window->screen->n_monitor_infos == 1 ||
+ !window->require_on_single_monitor ||
!window->frame ||
info->is_user_action)
return TRUE;
/* Have a helper function handle the constraint for us */
- return do_screen_and_xinerama_relative_constraints (window,
- info->usable_xinerama_region,
- info,
- check_only);
+ return do_screen_and_monitor_relative_constraints (window,
+ info->usable_monitor_region,
+ info,
+ check_only);
}
static gboolean
@@ -1214,10 +1214,10 @@ constrain_fully_onscreen (MetaWindow *window,
return TRUE;
/* Have a helper function handle the constraint for us */
- return do_screen_and_xinerama_relative_constraints (window,
- info->usable_screen_region,
- info,
- check_only);
+ return do_screen_and_monitor_relative_constraints (window,
+ info->usable_screen_region,
+ info,
+ check_only);
}
static gboolean
@@ -1290,10 +1290,10 @@ constrain_titlebar_visible (MetaWindow *window,
horiz_amount_onscreen,
vert_amount_onscreen);
retval =
- do_screen_and_xinerama_relative_constraints (window,
- info->usable_screen_region,
- info,
- check_only);
+ do_screen_and_monitor_relative_constraints (window,
+ info->usable_screen_region,
+ info,
+ check_only);
meta_rectangle_expand_region_conditionally (info->usable_screen_region,
-horiz_amount_offscreen,
-horiz_amount_offscreen,
@@ -1365,10 +1365,10 @@ constrain_partially_onscreen (MetaWindow *window,
horiz_amount_onscreen,
vert_amount_onscreen);
retval =
- do_screen_and_xinerama_relative_constraints (window,
- info->usable_screen_region,
- info,
- check_only);
+ do_screen_and_monitor_relative_constraints (window,
+ info->usable_screen_region,
+ info,
+ check_only);
meta_rectangle_expand_region_conditionally (info->usable_screen_region,
-horiz_amount_offscreen,
-horiz_amount_offscreen,
diff --git a/src/core/display-private.h b/src/core/display-private.h
index 5fbb132..aca7791 100644
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -217,8 +217,8 @@ struct _MetaDisplay
MetaKeyCombo overlay_key_combo;
gboolean overlay_key_only_pressed;
- /* Xinerama cache */
- unsigned int xinerama_cache_invalidated : 1;
+ /* Monitor cache */
+ unsigned int monitor_cache_invalidated : 1;
/* Opening the display */
unsigned int display_opening : 1;
diff --git a/src/core/display.c b/src/core/display.c
index b84f16f..9fcdd22 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -483,7 +483,7 @@ meta_display_open (void)
the_display->leader_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;
@@ -1528,7 +1528,7 @@ event_callback (XEvent *event,
bypass_compositor = FALSE;
filter_out_event = FALSE;
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);
diff --git a/src/core/edge-resistance.c b/src/core/edge-resistance.c
index 2dcb415..8409ff8 100644
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -340,12 +340,12 @@ apply_edge_resistance (MetaWindow *window,
const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW = 16;
const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW = 0;
- const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA = 32;
- const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA = 0;
+ const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR = 32;
+ const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR = 0;
const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN = 32;
const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN = 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;
/* Quit if no movement was specified */
@@ -423,8 +423,8 @@ apply_edge_resistance (MetaWindow *window,
case META_EDGE_WINDOW:
timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
break;
- case META_EDGE_XINERAMA:
- timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA;
+ case META_EDGE_MONITOR:
+ timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR;
break;
case META_EDGE_SCREEN:
timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
@@ -468,11 +468,11 @@ apply_edge_resistance (MetaWindow *window,
else
threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW;
break;
- case META_EDGE_XINERAMA:
+ case META_EDGE_MONITOR:
if (movement_towards_edge (edge->side_type, increment))
- threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA;
+ threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR;
else
- threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA;
+ threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR;
break;
case META_EDGE_SCREEN:
if (movement_towards_edge (edge->side_type, increment))
@@ -761,7 +761,7 @@ stupid_sort_requiring_extra_pointer_dereference (gconstpointer a,
static void
cache_edges (MetaDisplay *display,
GList *window_edges,
- GList *xinerama_edges,
+ GList *monitor_edges,
GList *screen_edges)
{
MetaEdgeResistanceData *edge_data;
@@ -776,7 +776,7 @@ cache_edges (MetaDisplay *display,
if (meta_is_verbose())
{
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));
char big_buffer[(EDGE_LENGTH+2)*max_edges];
@@ -784,9 +784,9 @@ cache_edges (MetaDisplay *display,
meta_topic (META_DEBUG_EDGE_RESISTANCE,
"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,
- "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_topic (META_DEBUG_EDGE_RESISTANCE,
@@ -807,7 +807,7 @@ cache_edges (MetaDisplay *display,
tmp = window_edges;
break;
case 1:
- tmp = xinerama_edges;
+ tmp = monitor_edges;
break;
case 2:
tmp = screen_edges;
@@ -875,7 +875,7 @@ cache_edges (MetaDisplay *display,
tmp = window_edges;
break;
case 1:
- tmp = xinerama_edges;
+ tmp = monitor_edges;
break;
case 2:
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
- * 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.
*/
cache_edges (display,
edges,
- display->grab_screen->active_workspace->xinerama_edges,
+ display->grab_screen->active_workspace->monitor_edges,
display->grab_screen->active_workspace->screen_edges);
g_list_free (edges);
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index 9ba062d..f098f8a 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -2553,7 +2553,7 @@ handle_move_to_corner_backend (MetaDisplay *display,
int new_x, new_y;
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_position (window, &orig_x, &orig_y);
@@ -2685,7 +2685,7 @@ handle_move_to_center (MetaDisplay *display,
int orig_x, orig_y;
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_position (window, &orig_x, &orig_y);
diff --git a/src/core/place.c b/src/core/place.c
index 5c1bc6a..6edba53 100644
--- a/src/core/place.c
+++ b/src/core/place.c
@@ -104,7 +104,7 @@ find_next_cascade (MetaWindow *window,
int window_width, window_height;
int cascade_stage;
MetaRectangle work_area;
- const MetaXineramaScreenInfo* current;
+ const MetaMonitorInfo* current;
sorted = g_list_copy (windows);
sorted = g_list_sort (sorted, northwestcmp);
@@ -135,8 +135,8 @@ find_next_cascade (MetaWindow *window,
* of NW corner of window frame.
*/
- current = meta_screen_get_current_xinerama (window->screen);
- meta_window_get_work_area_for_xinerama (window, current->number, &work_area);
+ current = meta_screen_get_current_monitor (window->screen);
+ meta_window_get_work_area_for_monitor (window, current->number, &work_area);
cascade_x = MAX (0, work_area.x);
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_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 (window, &outer);
@@ -508,7 +508,7 @@ find_first_fit (MetaWindow *window,
MetaFrameGeometry *fgeom,
/* visible windows on relevant workspaces */
GList *windows,
- int xinerama,
+ int monitor,
int x,
int y,
int *new_x,
@@ -551,16 +551,16 @@ find_first_fit (MetaWindow *window,
#ifdef WITH_VERBOSE_MODE
{
- char xinerama_location_string[RECT_LENGTH];
- meta_rectangle_to_string (&window->screen->xinerama_infos[xinerama].rect,
- xinerama_location_string);
+ char monitor_location_string[RECT_LENGTH];
+ meta_rectangle_to_string (&window->screen->monitor_infos[monitor].rect,
+ monitor_location_string);
meta_topic (META_DEBUG_XINERAMA,
- "Natural xinerama is %s\n",
- xinerama_location_string);
+ "Natural monitor is %s\n",
+ monitor_location_string);
}
#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);
@@ -658,7 +658,7 @@ meta_window_place (MetaWindow *window,
int *new_y)
{
GList *windows;
- const MetaXineramaScreenInfo *xi;
+ const MetaMonitorInfo *xi;
/* frame member variables should NEVER be used in here, only
* MetaFrameGeometry. But remember fgeom == NULL
@@ -810,11 +810,11 @@ meta_window_place (MetaWindow *window,
window->type == META_WINDOW_MODAL_DIALOG ||
window->type == META_WINDOW_SPLASHSCREEN)
{
- /* Center on current xinerama (i.e. on current monitor) */
+ /* Center on current monitor */
int w, h;
/* 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;
h = xi->rect.height;
@@ -825,7 +825,7 @@ meta_window_place (MetaWindow *window,
x += xi->rect.x;
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);
goto done_check_denied_focus;
@@ -859,7 +859,7 @@ meta_window_place (MetaWindow *window,
}
/* 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 */
x = xi->rect.x;
@@ -880,9 +880,9 @@ meta_window_place (MetaWindow *window,
MetaRectangle workarea;
MetaRectangle outer;
- meta_window_get_work_area_for_xinerama (window,
- xi->number,
- &workarea);
+ meta_window_get_work_area_for_monitor (window,
+ xi->number,
+ &workarea);
meta_window_get_outer_rect (window, &outer);
/* If the window is bigger than the screen, then automaximize. Do NOT
diff --git a/src/core/screen-private.h b/src/core/screen-private.h
index 66adf7d..64cfb08 100644
--- a/src/core/screen-private.h
+++ b/src/core/screen-private.h
@@ -40,9 +40,9 @@
#include "alttabhandler.h"
#include "ui.h"
-typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo;
+typedef struct _MetaMonitorInfo MetaMonitorInfo;
-struct _MetaXineramaScreenInfo
+struct _MetaMonitorInfo
{
int number;
MetaRectangle rect;
@@ -105,11 +105,11 @@ struct _MetaScreen
Atom wm_sn_atom;
guint32 wm_sn_timestamp;
- MetaXineramaScreenInfo *xinerama_infos;
- int n_xinerama_infos;
+ MetaMonitorInfo *monitor_infos;
+ int n_monitor_infos;
- /* Cache the current Xinerama */
- int last_xinerama_index;
+ /* Cache the current monitor */
+ int last_monitor_index;
#ifdef HAVE_STARTUP_NOTIFICATION
SnMonitorContext *sn_context;
@@ -185,19 +185,19 @@ void meta_screen_workspace_popup_destroy (MetaScreen *screen);
MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen,
MetaWindow *not_this_one);
-const MetaXineramaScreenInfo* meta_screen_get_current_xinerama (MetaScreen *screen);
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect (MetaScreen *screen,
- MetaRectangle *rect);
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen *screen,
- MetaWindow *window);
+const MetaMonitorInfo* meta_screen_get_current_monitor (MetaScreen *screen);
+const MetaMonitorInfo* meta_screen_get_monitor_for_rect (MetaScreen *screen,
+ MetaRectangle *rect);
+const MetaMonitorInfo* meta_screen_get_monitor_for_window (MetaScreen *screen,
+ MetaWindow *window);
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen,
- int which_xinerama,
- MetaScreenDirection dir);
-void meta_screen_get_natural_xinerama_list (MetaScreen *screen,
- int** xineramas_list,
- int* n_xineramas);
+const MetaMonitorInfo* meta_screen_get_monitor_neighbor (MetaScreen *screen,
+ int which_monitor,
+ MetaScreenDirection dir);
+void meta_screen_get_natural_monitor_list (MetaScreen *screen,
+ int** monitors_list,
+ int* n_monitors);
void meta_screen_update_workspace_layout (MetaScreen *screen);
void meta_screen_update_workspace_names (MetaScreen *screen);
diff --git a/src/core/screen.c b/src/core/screen.c
index c078544..aac8230 100644
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -299,7 +299,7 @@ set_wm_icon_size_hint (MetaScreen *screen)
}
static void
-reload_xinerama_infos (MetaScreen *screen)
+reload_monitor_infos (MetaScreen *screen)
{
MetaDisplay *display;
@@ -319,35 +319,35 @@ reload_xinerama_infos (MetaScreen *screen)
display = screen->display;
- if (screen->xinerama_infos)
- g_free (screen->xinerama_infos);
+ if (screen->monitor_infos)
+ g_free (screen->monitor_infos);
- screen->xinerama_infos = NULL;
- screen->n_xinerama_infos = 0;
- screen->last_xinerama_index = 0;
+ screen->monitor_infos = NULL;
+ screen->n_monitor_infos = 0;
+ screen->last_monitor_index = 0;
- screen->display->xinerama_cache_invalidated = TRUE;
+ screen->display->monitor_cache_invalidated = TRUE;
if (g_getenv ("MUTTER_DEBUG_XINERAMA"))
{
meta_topic (META_DEBUG_XINERAMA,
"Pretending a single monitor has two Xinerama screens\n");
- screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 2);
- screen->n_xinerama_infos = 2;
+ screen->monitor_infos = g_new (MetaMonitorInfo, 2);
+ screen->n_monitor_infos = 2;
- screen->xinerama_infos[0].number = 0;
- screen->xinerama_infos[0].rect = screen->rect;
- screen->xinerama_infos[0].rect.width = screen->rect.width / 2;
+ screen->monitor_infos[0].number = 0;
+ screen->monitor_infos[0].rect = screen->rect;
+ screen->monitor_infos[0].rect.width = screen->rect.width / 2;
- screen->xinerama_infos[1].number = 1;
- screen->xinerama_infos[1].rect = screen->rect;
- screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
- screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
+ screen->monitor_infos[1].number = 1;
+ screen->monitor_infos[1].rect = screen->rect;
+ screen->monitor_infos[1].rect.x = screen->rect.width / 2;
+ screen->monitor_infos[1].rect.width = screen->rect.width / 2;
}
#ifdef HAVE_XFREE_XINERAMA
- if (screen->n_xinerama_infos == 0 &&
+ if (screen->n_monitor_infos == 0 &&
XineramaIsActive (display->xdisplay))
{
XineramaScreenInfo *infos;
@@ -363,25 +363,25 @@ reload_xinerama_infos (MetaScreen *screen)
if (n_infos > 0)
{
- screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_infos);
- screen->n_xinerama_infos = n_infos;
+ screen->monitor_infos = g_new (MetaMonitorInfo, n_infos);
+ screen->n_monitor_infos = n_infos;
i = 0;
while (i < n_infos)
{
- screen->xinerama_infos[i].number = infos[i].screen_number;
- screen->xinerama_infos[i].rect.x = infos[i].x_org;
- screen->xinerama_infos[i].rect.y = infos[i].y_org;
- screen->xinerama_infos[i].rect.width = infos[i].width;
- screen->xinerama_infos[i].rect.height = infos[i].height;
+ screen->monitor_infos[i].number = infos[i].screen_number;
+ screen->monitor_infos[i].rect.x = infos[i].x_org;
+ screen->monitor_infos[i].rect.y = infos[i].y_org;
+ screen->monitor_infos[i].rect.width = infos[i].width;
+ screen->monitor_infos[i].rect.height = infos[i].height;
meta_topic (META_DEBUG_XINERAMA,
- "Xinerama %d is %d,%d %d x %d\n",
- screen->xinerama_infos[i].number,
- screen->xinerama_infos[i].rect.x,
- screen->xinerama_infos[i].rect.y,
- screen->xinerama_infos[i].rect.width,
- screen->xinerama_infos[i].rect.height);
+ "Monitor %d is %d,%d %d x %d\n",
+ screen->monitor_infos[i].number,
+ screen->monitor_infos[i].rect.x,
+ screen->monitor_infos[i].rect.y,
+ screen->monitor_infos[i].rect.width,
+ screen->monitor_infos[i].rect.height);
++i;
}
@@ -389,7 +389,7 @@ reload_xinerama_infos (MetaScreen *screen)
meta_XFree (infos);
}
- else if (screen->n_xinerama_infos > 0)
+ else if (screen->n_monitor_infos > 0)
{
meta_topic (META_DEBUG_XINERAMA,
"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
/* 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,
screen->number))
{
@@ -424,31 +424,31 @@ reload_xinerama_infos (MetaScreen *screen)
{
g_assert (n_monitors > 0);
- screen->xinerama_infos = g_new (MetaXineramaScreenInfo, n_monitors);
- screen->n_xinerama_infos = n_monitors;
+ screen->monitor_infos = g_new (MetaMonitorInfo, n_monitors);
+ screen->n_monitor_infos = n_monitors;
i = 0;
while (i < n_monitors)
{
- screen->xinerama_infos[i].number = i;
- screen->xinerama_infos[i].rect.x = monitors[i].x;
- screen->xinerama_infos[i].rect.y = monitors[i].y;
- screen->xinerama_infos[i].rect.width = monitors[i].width;
- screen->xinerama_infos[i].rect.height = monitors[i].height;
+ screen->monitor_infos[i].number = i;
+ screen->monitor_infos[i].rect.x = monitors[i].x;
+ screen->monitor_infos[i].rect.y = monitors[i].y;
+ screen->monitor_infos[i].rect.width = monitors[i].width;
+ screen->monitor_infos[i].rect.height = monitors[i].height;
meta_topic (META_DEBUG_XINERAMA,
- "Xinerama %d is %d,%d %d x %d\n",
- screen->xinerama_infos[i].number,
- screen->xinerama_infos[i].rect.x,
- screen->xinerama_infos[i].rect.y,
- screen->xinerama_infos[i].rect.width,
- screen->xinerama_infos[i].rect.height);
+ "Monitor %d is %d,%d %d x %d\n",
+ screen->monitor_infos[i].number,
+ screen->monitor_infos[i].rect.x,
+ screen->monitor_infos[i].rect.y,
+ screen->monitor_infos[i].rect.width,
+ screen->monitor_infos[i].rect.height);
++i;
}
}
}
- else if (screen->n_xinerama_infos == 0)
+ else if (screen->n_monitor_infos == 0)
{
meta_topic (META_DEBUG_XINERAMA,
"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
* we can use the field unconditionally
*/
- if (screen->n_xinerama_infos == 0)
+ if (screen->n_monitor_infos == 0)
{
meta_topic (META_DEBUG_XINERAMA,
"No Xinerama screens, using default screen info\n");
- screen->xinerama_infos = g_new (MetaXineramaScreenInfo, 1);
- screen->n_xinerama_infos = 1;
+ screen->monitor_infos = g_new (MetaMonitorInfo, 1);
+ screen->n_monitor_infos = 1;
- screen->xinerama_infos[0].number = 0;
- screen->xinerama_infos[0].rect = screen->rect;
+ screen->monitor_infos[0].number = 0;
+ screen->monitor_infos[0].rect = screen->rect;
}
- g_assert (screen->n_xinerama_infos > 0);
- g_assert (screen->xinerama_infos != NULL);
+ g_assert (screen->n_monitor_infos > 0);
+ g_assert (screen->monitor_infos != NULL);
}
/* The guard window allows us to leave minimized windows mapped so
@@ -727,11 +727,11 @@ meta_screen_new (MetaDisplay *display,
&gc_values);
}
- screen->xinerama_infos = NULL;
- screen->n_xinerama_infos = 0;
- screen->last_xinerama_index = 0;
+ screen->monitor_infos = NULL;
+ screen->n_monitor_infos = 0;
+ screen->last_monitor_index = 0;
- reload_xinerama_infos (screen);
+ reload_monitor_infos (screen);
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
@@ -890,8 +890,8 @@ meta_screen_free (MetaScreen *screen,
XFreeGC (screen->display->xdisplay,
screen->root_xor_gc);
- if (screen->xinerama_infos)
- g_free (screen->xinerama_infos);
+ if (screen->monitor_infos)
+ g_free (screen->monitor_infos);
g_free (screen->screen_name);
@@ -1703,61 +1703,61 @@ meta_screen_get_mouse_window (MetaScreen *screen,
return window;
}
-const MetaXineramaScreenInfo*
-meta_screen_get_xinerama_for_rect (MetaScreen *screen,
- MetaRectangle *rect)
+const MetaMonitorInfo*
+meta_screen_get_monitor_for_rect (MetaScreen *screen,
+ MetaRectangle *rect)
{
int i;
- int best_xinerama, xinerama_score;
+ int best_monitor, monitor_score;
- if (screen->n_xinerama_infos == 1)
- return &screen->xinerama_infos[0];
+ if (screen->n_monitor_infos == 1)
+ return &screen->monitor_infos[0];
- best_xinerama = 0;
- xinerama_score = 0;
+ best_monitor = 0;
+ monitor_score = 0;
- for (i = 0; i < screen->n_xinerama_infos; i++)
+ for (i = 0; i < screen->n_monitor_infos; i++)
{
MetaRectangle dest;
- if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
+ if (meta_rectangle_intersect (&screen->monitor_infos[i].rect,
rect,
&dest))
{
int cur = meta_rectangle_area (&dest);
- if (cur > xinerama_score)
+ if (cur > monitor_score)
{
- xinerama_score = cur;
- best_xinerama = i;
+ monitor_score = cur;
+ best_monitor = i;
}
}
}
- return &screen->xinerama_infos[best_xinerama];
+ return &screen->monitor_infos[best_monitor];
}
-const MetaXineramaScreenInfo*
-meta_screen_get_xinerama_for_window (MetaScreen *screen,
- MetaWindow *window)
+const MetaMonitorInfo*
+meta_screen_get_monitor_for_window (MetaScreen *screen,
+ MetaWindow *window)
{
MetaRectangle 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*
-meta_screen_get_xinerama_neighbor (MetaScreen *screen,
- int which_xinerama,
- MetaScreenDirection direction)
+const MetaMonitorInfo*
+meta_screen_get_monitor_neighbor (MetaScreen *screen,
+ int which_monitor,
+ MetaScreenDirection direction)
{
- MetaXineramaScreenInfo* input = screen->xinerama_infos + which_xinerama;
- MetaXineramaScreenInfo* current;
+ MetaMonitorInfo* input = screen->monitor_infos + which_monitor;
+ MetaMonitorInfo* current;
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 &&
current->rect.x == input->rect.x + input->rect.width &&
@@ -1780,110 +1780,110 @@ meta_screen_get_xinerama_neighbor (MetaScreen *screen,
}
void
-meta_screen_get_natural_xinerama_list (MetaScreen *screen,
- int** xineramas_list,
- int* n_xineramas)
+meta_screen_get_natural_monitor_list (MetaScreen *screen,
+ int** monitors_list,
+ int* n_monitors)
{
- const MetaXineramaScreenInfo* current;
- const MetaXineramaScreenInfo* tmp;
- GQueue* xinerama_queue;
+ const MetaMonitorInfo* current;
+ const MetaMonitorInfo* tmp;
+ GQueue* monitor_queue;
int* visited;
int cur = 0;
int i;
- *n_xineramas = screen->n_xinerama_infos;
- *xineramas_list = g_new (int, screen->n_xinerama_infos);
+ *n_monitors = screen->n_monitor_infos;
+ *monitors_list = g_new (int, screen->n_monitor_infos);
- /* we calculate a natural ordering by which to choose xineramas for
- * window placement. We start at the current xinerama, and perform
- * a breadth-first search of the xineramas starting from that
- * xinerama. We choose preferentially left, then right, then down,
+ /* we calculate a natural ordering by which to choose monitors for
+ * window placement. We start at the current monitor, and perform
+ * a breadth-first search of the monitors starting from that
+ * monitor. We choose preferentially left, then right, then down,
* 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);
- for (i = 0; i < screen->n_xinerama_infos; i++)
+ visited = g_new (int, screen->n_monitor_infos);
+ for (i = 0; i < screen->n_monitor_infos; i++)
{
visited[i] = FALSE;
}
- current = meta_screen_get_current_xinerama (screen);
- xinerama_queue = g_queue_new ();
- g_queue_push_tail (xinerama_queue, (gpointer) current);
+ current = meta_screen_get_current_monitor (screen);
+ monitor_queue = g_queue_new ();
+ g_queue_push_tail (monitor_queue, (gpointer) current);
visited[current->number] = TRUE;
- while (!g_queue_is_empty (xinerama_queue))
+ while (!g_queue_is_empty (monitor_queue))
{
- current = (const MetaXineramaScreenInfo*)
- g_queue_pop_head (xinerama_queue);
+ current = (const MetaMonitorInfo*)
+ g_queue_pop_head (monitor_queue);
- (*xineramas_list)[cur++] = current->number;
+ (*monitors_list)[cur++] = current->number;
/* enqueue each of the directions */
- tmp = meta_screen_get_xinerama_neighbor (screen,
- current->number,
- META_SCREEN_LEFT);
+ tmp = meta_screen_get_monitor_neighbor (screen,
+ current->number,
+ META_SCREEN_LEFT);
if (tmp && !visited[tmp->number])
{
- g_queue_push_tail (xinerama_queue,
- (MetaXineramaScreenInfo*) tmp);
+ g_queue_push_tail (monitor_queue,
+ (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE;
}
- tmp = meta_screen_get_xinerama_neighbor (screen,
- current->number,
- META_SCREEN_RIGHT);
+ tmp = meta_screen_get_monitor_neighbor (screen,
+ current->number,
+ META_SCREEN_RIGHT);
if (tmp && !visited[tmp->number])
{
- g_queue_push_tail (xinerama_queue,
- (MetaXineramaScreenInfo*) tmp);
+ g_queue_push_tail (monitor_queue,
+ (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE;
}
- tmp = meta_screen_get_xinerama_neighbor (screen,
- current->number,
- META_SCREEN_UP);
+ tmp = meta_screen_get_monitor_neighbor (screen,
+ current->number,
+ META_SCREEN_UP);
if (tmp && !visited[tmp->number])
{
- g_queue_push_tail (xinerama_queue,
- (MetaXineramaScreenInfo*) tmp);
+ g_queue_push_tail (monitor_queue,
+ (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE;
}
- tmp = meta_screen_get_xinerama_neighbor (screen,
- current->number,
- META_SCREEN_DOWN);
+ tmp = meta_screen_get_monitor_neighbor (screen,
+ current->number,
+ META_SCREEN_DOWN);
if (tmp && !visited[tmp->number])
{
- g_queue_push_tail (xinerama_queue,
- (MetaXineramaScreenInfo*) tmp);
+ g_queue_push_tail (monitor_queue,
+ (MetaMonitorInfo*) tmp);
visited[tmp->number] = TRUE;
}
}
- /* in case we somehow missed some set of xineramas, go through the
- * visited list and add in any xineramas that were missed
+ /* in case we somehow missed some set of monitors, go through the
+ * 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)
{
- (*xineramas_list)[cur++] = i;
+ (*monitors_list)[cur++] = i;
}
}
g_free (visited);
- g_queue_free (xinerama_queue);
+ g_queue_free (monitor_queue);
}
-const MetaXineramaScreenInfo*
-meta_screen_get_current_xinerama (MetaScreen *screen)
+const MetaMonitorInfo*
+meta_screen_get_current_monitor (MetaScreen *screen)
{
- if (screen->n_xinerama_infos == 1)
- return &screen->xinerama_infos[0];
+ if (screen->n_monitor_infos == 1)
+ return &screen->monitor_infos[0];
/* 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;
int win_x_return, win_y_return;
@@ -1891,7 +1891,7 @@ meta_screen_get_current_xinerama (MetaScreen *screen)
int i;
MetaRectangle pointer_position;
- screen->display->xinerama_cache_invalidated = FALSE;
+ screen->display->monitor_cache_invalidated = FALSE;
pointer_position.width = pointer_position.height = 1;
XQueryPointer (screen->display->xdisplay,
@@ -1904,23 +1904,23 @@ meta_screen_get_current_xinerama (MetaScreen *screen)
&win_y_return,
&mask_return);
- screen->last_xinerama_index = 0;
- for (i = 0; i < screen->n_xinerama_infos; i++)
+ screen->last_monitor_index = 0;
+ 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))
{
- screen->last_xinerama_index = i;
+ screen->last_monitor_index = i;
break;
}
}
meta_topic (META_DEBUG_XINERAMA,
- "Rechecked current Xinerama, now %d\n",
- screen->last_xinerama_index);
+ "Rechecked current monitor, now %d\n",
+ 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
@@ -2145,7 +2145,7 @@ set_work_area_hint (MetaScreen *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[1] = area.y;
tmp[2] = area.width;
@@ -2513,7 +2513,7 @@ meta_screen_resize (MetaScreen *screen,
screen->rect.width = width;
screen->rect.height = height;
- reload_xinerama_infos (screen);
+ reload_monitor_infos (screen);
set_desktop_geometry_hint (screen);
if (screen->display->compositor)
diff --git a/src/core/stack.c b/src/core/stack.c
index 869a621..706e85b 100644
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -224,14 +224,14 @@ is_focused_foreach (MetaWindow *window,
}
static gboolean
-windows_on_different_xinerama (MetaWindow *a,
- MetaWindow *b)
+windows_on_different_monitor (MetaWindow *a,
+ MetaWindow *b)
{
if (a->screen != b->screen)
return TRUE;
- return meta_screen_get_xinerama_for_window (a->screen, a) !=
- meta_screen_get_xinerama_for_window (b->screen, b);
+ return meta_screen_get_monitor_for_window (a->screen, a) !=
+ meta_screen_get_monitor_for_window (b->screen, b);
}
/* Get layer ignoring any transient or group relationships */
@@ -275,8 +275,8 @@ get_standalone_layer (MetaWindow *window)
window == window->display->expected_focus_window ||
window->display->expected_focus_window == NULL ||
(window->display->expected_focus_window != NULL &&
- windows_on_different_xinerama (window,
- window->display->expected_focus_window))))
+ windows_on_different_monitor (window,
+ window->display->expected_focus_window))))
layer = META_LAYER_FULLSCREEN;
else if (window->wm_state_above)
layer = META_LAYER_TOP;
diff --git a/src/core/testboxes.c b/src/core/testboxes.c
index 93f430c..596990b 100644
--- a/src/core/testboxes.c
+++ b/src/core/testboxes.c
@@ -85,7 +85,7 @@ new_screen_edge (int x, int y, int width, int height, int side_type)
}
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;
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.height = height;
temporary->side_type = side_type;
- temporary->edge_type = META_EDGE_XINERAMA;
+ temporary->edge_type = META_EDGE_MONITOR;
return temporary;
}
@@ -317,15 +317,15 @@ get_screen_edges (int which)
}
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;
GSList *struts;
GList *xins;
xins = NULL;
- g_assert (which_xinerama_set >=0 && which_xinerama_set <= 3);
- switch (which_xinerama_set)
+ g_assert (which_monitor_set >=0 && which_monitor_set <= 3);
+ switch (which_monitor_set)
{
case 0:
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;
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);
meta_rectangle_free_list_and_elements (xins);
@@ -1145,7 +1145,7 @@ test_find_onscreen_edges ()
}
static void
-test_find_nonintersected_xinerama_edges ()
+test_find_nonintersected_monitor_edges ()
{
GList* edges;
GList* tmp;
@@ -1156,32 +1156,32 @@ test_find_nonintersected_xinerama_edges ()
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;
verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp);
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 = g_list_prepend (tmp, new_xinerama_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, bottom));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 1600, 0, top));
verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp);
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 = g_list_prepend (tmp, new_xinerama_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, 1080, right));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 20, 0, 1180, left));
#if 0
#define FUDGE 50
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);
/*************************************************************************/
- /* 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 = g_list_prepend (tmp, new_xinerama_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_xinerama_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_xinerama_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 ( 900, 600, 700, 0, bottom));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 700, 0, bottom));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 900, 600, 700, 0, top));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 0, 600, 700, 0, top));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 675, 0, 425, right));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 675, 0, 525, left));
verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp);
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 = g_list_prepend (tmp, new_xinerama_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_xinerama_edge ( 800, 600, 0, 600, right));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 800, 0, bottom));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 800, 0, top));
+ tmp = g_list_prepend (tmp, new_monitor_edge ( 800, 600, 0, 600, right));
verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp);
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;
verify_edge_lists_are_equal (edges, tmp);
meta_rectangle_free_list_and_elements (tmp);
@@ -1405,7 +1405,7 @@ main()
/* And now the functions dealing with edges more than boxes */
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... */
test_gravity_resize ();
diff --git a/src/core/window-private.h b/src/core/window-private.h
index 044acbe..0e7fb98 100644
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -139,8 +139,8 @@ struct _MetaWindow
/* Whether we're trying to constrain the window to be fully onscreen */
guint require_fully_onscreen : 1;
- /* Whether we're trying to constrain the window to be on a single xinerama */
- guint require_on_single_xinerama : 1;
+ /* Whether we're trying to constrain the window to be on a single monitor */
+ guint require_on_single_monitor : 1;
/* Whether we're trying to constrain the window's titlebar to be onscreen */
guint require_titlebar_visible : 1;
@@ -544,13 +544,13 @@ GList* meta_window_get_workspaces (MetaWindow *window);
gboolean meta_window_located_on_workspace (MetaWindow *window,
MetaWorkspace *workspace);
-void meta_window_get_work_area_current_xinerama (MetaWindow *window,
- MetaRectangle *area);
-void meta_window_get_work_area_for_xinerama (MetaWindow *window,
- int which_xinerama,
- MetaRectangle *area);
-void meta_window_get_work_area_all_xineramas (MetaWindow *window,
- MetaRectangle *area);
+void meta_window_get_work_area_current_monitor (MetaWindow *window,
+ MetaRectangle *area);
+void meta_window_get_work_area_for_monitor (MetaWindow *window,
+ int which_monitor,
+ MetaRectangle *area);
+void meta_window_get_work_area_all_monitors (MetaWindow *window,
+ MetaRectangle *area);
gboolean meta_window_same_application (MetaWindow *window,
diff --git a/src/core/window.c b/src/core/window.c
index 82ced02..5f5e62b 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -675,7 +675,7 @@ meta_window_new_with_attrs (MetaDisplay *display,
window->fullscreen = FALSE;
window->fullscreen_monitors[0] = -1;
window->require_fully_onscreen = TRUE;
- window->require_on_single_xinerama = TRUE;
+ window->require_on_single_monitor = TRUE;
window->require_titlebar_visible = TRUE;
window->on_all_workspaces = FALSE;
window->shaded = FALSE;
@@ -3241,10 +3241,10 @@ meta_window_update_fullscreen_monitors (MetaWindow *window,
unsigned long left,
unsigned long right)
{
- if ((int)top < window->screen->n_xinerama_infos &&
- (int)bottom < window->screen->n_xinerama_infos &&
- (int)left < window->screen->n_xinerama_infos &&
- (int)right < window->screen->n_xinerama_infos)
+ if ((int)top < window->screen->n_monitor_infos &&
+ (int)bottom < window->screen->n_monitor_infos &&
+ (int)left < window->screen->n_monitor_infos &&
+ (int)right < window->screen->n_monitor_infos)
{
window->fullscreen_monitors[0] = top;
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
* 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 &&
window->size_hints.min_height == window->screen->rect.height)
@@ -7449,22 +7449,22 @@ update_move (MetaWindow *window,
return;
}
- /* remaximize window on an other xinerama monitor if window has
- * been shaken loose or it is still maximized (then move straight)
+ /* remaximize window on another monitor if window has been shaken
+ * loose or it is still maximized (then move straight)
*/
else if (window->shaken_loose || META_WINDOW_MAXIMIZED (window))
{
- const MetaXineramaScreenInfo *wxinerama;
+ const MetaMonitorInfo *wmonitor;
MetaRectangle work_area;
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 &&
x < (work_area.x + work_area.width) &&
y >= work_area.y &&
@@ -7473,7 +7473,7 @@ update_move (MetaWindow *window,
/* move the saved rect if window will become maximized on an
* 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.y = work_area.y;
@@ -7955,24 +7955,24 @@ meta_window_set_gravity (MetaWindow *window,
}
static void
-get_work_area_xinerama (MetaWindow *window,
- MetaRectangle *area,
- int which_xinerama)
+get_work_area_monitor (MetaWindow *window,
+ MetaRectangle *area,
+ int which_monitor)
{
GList *tmp;
- g_assert (which_xinerama >= 0);
+ g_assert (which_monitor >= 0);
- /* Initialize to the whole xinerama */
- *area = window->screen->xinerama_infos[which_xinerama].rect;
+ /* Initialize to the whole monitor */
+ *area = window->screen->monitor_infos[which_monitor].rect;
tmp = meta_window_get_workspaces (window);
while (tmp != NULL)
{
MetaRectangle workspace_work_area;
- meta_workspace_get_work_area_for_xinerama (tmp->data,
- which_xinerama,
- &workspace_work_area);
+ meta_workspace_get_work_area_for_monitor (tmp->data,
+ which_monitor,
+ &workspace_work_area);
meta_rectangle_intersect (area,
&workspace_work_area,
area);
@@ -7980,39 +7980,39 @@ get_work_area_xinerama (MetaWindow *window,
}
meta_topic (META_DEBUG_WORKAREA,
- "Window %s xinerama %d has work area %d,%d %d x %d\n",
- window->desc, which_xinerama,
+ "Window %s monitor %d has work area %d,%d %d x %d\n",
+ window->desc, which_monitor,
area->x, area->y, area->width, area->height);
}
void
-meta_window_get_work_area_current_xinerama (MetaWindow *window,
- MetaRectangle *area)
+meta_window_get_work_area_current_monitor (MetaWindow *window,
+ MetaRectangle *area)
{
- const MetaXineramaScreenInfo *xinerama = NULL;
- xinerama = meta_screen_get_xinerama_for_window (window->screen,
- window);
+ const MetaMonitorInfo *monitor = NULL;
+ monitor = meta_screen_get_monitor_for_window (window->screen,
+ window);
- meta_window_get_work_area_for_xinerama (window,
- xinerama->number,
- area);
+ meta_window_get_work_area_for_monitor (window,
+ monitor->number,
+ area);
}
void
-meta_window_get_work_area_for_xinerama (MetaWindow *window,
- int which_xinerama,
- MetaRectangle *area)
+meta_window_get_work_area_for_monitor (MetaWindow *window,
+ int which_monitor,
+ MetaRectangle *area)
{
- g_return_if_fail (which_xinerama >= 0);
+ g_return_if_fail (which_monitor >= 0);
- get_work_area_xinerama (window,
- area,
- which_xinerama);
+ get_work_area_monitor (window,
+ area,
+ which_monitor);
}
void
-meta_window_get_work_area_all_xineramas (MetaWindow *window,
- MetaRectangle *area)
+meta_window_get_work_area_all_monitors (MetaWindow *window,
+ MetaRectangle *area)
{
GList *tmp;
@@ -8023,8 +8023,8 @@ meta_window_get_work_area_all_xineramas (MetaWindow *window,
while (tmp != NULL)
{
MetaRectangle workspace_work_area;
- meta_workspace_get_work_area_all_xineramas (tmp->data,
- &workspace_work_area);
+ meta_workspace_get_work_area_all_monitors (tmp->data,
+ &workspace_work_area);
meta_rectangle_intersect (area,
&workspace_work_area,
area);
diff --git a/src/core/workspace-private.h b/src/core/workspace-private.h
index 84469c1..1a8b977 100644
--- a/src/core/workspace-private.h
+++ b/src/core/workspace-private.h
@@ -47,12 +47,12 @@ struct _MetaWorkspace
GList *list_containing_self;
MetaRectangle work_area_screen;
- MetaRectangle *work_area_xinerama;
+ MetaRectangle *work_area_monitor;
GList *screen_region;
- GList **xinerama_region;
- gint n_xinerama_regions;
+ GList **monitor_region;
+ gint n_monitor_regions;
GList *screen_edges;
- GList *xinerama_edges;
+ GList *monitor_edges;
GSList *builtin_struts;
GSList *all_struts;
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_get_work_area_for_xinerama (MetaWorkspace *workspace,
- int which_xinerama,
+void meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
+ int which_monitor,
MetaRectangle *area);
GList* meta_workspace_get_onscreen_region (MetaWorkspace *workspace);
-GList* meta_workspace_get_onxinerama_region (MetaWorkspace *workspace,
- int which_xinerama);
-void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
- MetaRectangle *area);
+GList* meta_workspace_get_onmonitor_region (MetaWorkspace *workspace,
+ int which_monitor);
void meta_workspace_focus_default_window (MetaWorkspace *workspace,
MetaWindow *not_this_one,
diff --git a/src/core/workspace.c b/src/core/workspace.c
index b875147..add3618 100644
--- a/src/core/workspace.c
+++ b/src/core/workspace.c
@@ -170,16 +170,16 @@ meta_workspace_new (MetaScreen *screen)
meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list);
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.y = 0;
workspace->work_area_screen.width = 0;
workspace->work_area_screen.height = 0;
workspace->screen_region = NULL;
- workspace->xinerama_region = NULL;
+ workspace->monitor_region = NULL;
workspace->screen_edges = NULL;
- workspace->xinerama_edges = NULL;
+ workspace->monitor_edges = NULL;
workspace->list_containing_self = g_list_prepend (NULL, workspace);
workspace->builtin_struts = NULL;
@@ -263,7 +263,7 @@ meta_workspace_remove (MetaWorkspace *workspace)
workspace->screen->workspaces =
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->list_containing_self);
@@ -280,12 +280,12 @@ meta_workspace_remove (MetaWorkspace *workspace)
if (!workspace->work_areas_invalid)
{
workspace_free_all_struts (workspace);
- for (i = 0; i < screen->n_xinerama_infos; i++)
- meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
- g_free (workspace->xinerama_region);
+ for (i = 0; i < screen->n_monitor_infos; i++)
+ meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
+ g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region);
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);
@@ -713,21 +713,21 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
"Invalidating work area for workspace %d\n",
meta_workspace_index (workspace));
- g_free (workspace->work_area_xinerama);
- workspace->work_area_xinerama = NULL;
+ g_free (workspace->work_area_monitor);
+ workspace->work_area_monitor = NULL;
workspace_free_all_struts (workspace);
- for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
- meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
- g_free (workspace->xinerama_region);
+ for (i = 0; i < workspace->screen->n_monitor_infos; i++)
+ meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
+ g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region);
meta_rectangle_free_list_and_elements (workspace->screen_edges);
- meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
- workspace->xinerama_region = NULL;
+ meta_rectangle_free_list_and_elements (workspace->monitor_edges);
+ workspace->monitor_region = NULL;
workspace->screen_region = NULL;
workspace->screen_edges = NULL;
- workspace->xinerama_edges = NULL;
+ workspace->monitor_edges = NULL;
workspace->work_areas_invalid = TRUE;
@@ -780,10 +780,10 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
return;
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_edges == NULL);
- g_assert (workspace->xinerama_edges == NULL);
+ g_assert (workspace->monitor_edges == NULL);
/* STEP 1: Get the list of struts */
@@ -803,18 +803,18 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
g_list_free (windows);
/* 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);
- workspace->xinerama_region = g_new (GList*,
- workspace->screen->n_xinerama_infos);
- for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+ workspace->monitor_region = g_new (GList*,
+ workspace->screen->n_monitor_infos);
+ 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 (
- &workspace->screen->xinerama_infos[i].rect,
+ &workspace->screen->monitor_infos[i].rect,
workspace->all_struts);
}
workspace->screen_region =
@@ -823,7 +823,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
workspace->all_struts);
/* 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 */
if (workspace->screen_region == NULL)
@@ -878,35 +878,35 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
workspace->work_area_screen.width,
workspace->work_area_screen.height);
- /* Now find the work areas for each xinerama */
- g_free (workspace->work_area_xinerama);
- workspace->work_area_xinerama = g_new (MetaRectangle,
- workspace->screen->n_xinerama_infos);
+ /* Now find the work areas for each monitor */
+ g_free (workspace->work_area_monitor);
+ workspace->work_area_monitor = g_new (MetaRectangle,
+ 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
* a screen reader or magnifier.
*/
work_area = meta_rect (work_area.x, work_area.y, -1, -1);
else
- meta_rectangle_clip_to_region (workspace->xinerama_region[i],
+ meta_rectangle_clip_to_region (workspace->monitor_region[i],
FIXED_DIRECTION_NONE,
&work_area);
- workspace->work_area_xinerama[i] = work_area;
+ workspace->work_area_monitor[i] = work_area;
meta_topic (META_DEBUG_WORKAREA,
"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),
i,
- workspace->work_area_xinerama[i].x,
- workspace->work_area_xinerama[i].y,
- workspace->work_area_xinerama[i].width,
- workspace->work_area_xinerama[i].height);
+ workspace->work_area_monitor[i].x,
+ workspace->work_area_monitor[i].y,
+ workspace->work_area_monitor[i].width,
+ workspace->work_area_monitor[i].height);
}
/* 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);
}
- /* 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->xinerama_edges == NULL);
+ g_assert (workspace->monitor_edges == NULL);
workspace->screen_edges =
meta_rectangle_find_onscreen_edges (&workspace->screen->rect,
workspace->all_struts);
tmp = NULL;
- for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
- tmp = g_list_prepend (tmp, &workspace->screen->xinerama_infos[i].rect);
- workspace->xinerama_edges =
- meta_rectangle_find_nonintersected_xinerama_edges (tmp,
+ for (i = 0; i < workspace->screen->n_monitor_infos; i++)
+ tmp = g_list_prepend (tmp, &workspace->screen->monitor_infos[i].rect);
+ workspace->monitor_edges =
+ meta_rectangle_find_nonintersected_monitor_edges (tmp,
workspace->all_struts);
g_list_free (tmp);
@@ -970,21 +970,21 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
}
void
-meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace,
- int which_xinerama,
- MetaRectangle *area)
+meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
+ int which_monitor,
+ MetaRectangle *area)
{
- g_assert (which_xinerama >= 0);
+ g_assert (which_monitor >= 0);
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
-meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
- MetaRectangle *area)
+meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
+ MetaRectangle *area)
{
ensure_work_areas_validated (workspace);
@@ -1000,12 +1000,12 @@ meta_workspace_get_onscreen_region (MetaWorkspace *workspace)
}
GList*
-meta_workspace_get_onxinerama_region (MetaWorkspace *workspace,
- int which_xinerama)
+meta_workspace_get_onmonitor_region (MetaWorkspace *workspace,
+ int which_monitor)
{
ensure_work_areas_validated (workspace);
- return workspace->xinerama_region[which_xinerama];
+ return workspace->monitor_region[which_monitor];
}
#ifdef WITH_VERBOSE_MODE
diff --git a/src/include/boxes.h b/src/include/boxes.h
index 5c76ed6..11fd8bd 100644
--- a/src/include/boxes.h
+++ b/src/include/boxes.h
@@ -58,7 +58,7 @@ typedef enum
typedef enum
{
META_EDGE_WINDOW,
- META_EDGE_XINERAMA,
+ META_EDGE_MONITOR,
META_EDGE_SCREEN
} MetaEdgeType;
@@ -193,7 +193,7 @@ void meta_rectangle_expand_to_avoiding_struts (
* or
* meta_rectangle_find_onscreen_edges ()
* or
- * meta_rectangle_find_nonintersected_xinerama_edges()
+ * meta_rectangle_find_nonintersected_monitor_edges()
*/
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,
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.
*/
-GList* meta_rectangle_find_nonintersected_xinerama_edges (
- const GList *xinerama_rects,
+GList* meta_rectangle_find_nonintersected_monitor_edges (
+ const GList *monitor_rects,
const GSList *all_struts);
#endif /* META_BOXES_H */
diff --git a/src/include/workspace.h b/src/include/workspace.h
index f44aa09..21ebf9e 100644
--- a/src/include/workspace.h
+++ b/src/include/workspace.h
@@ -51,8 +51,8 @@ GType meta_workspace_get_type (void);
int meta_workspace_index (MetaWorkspace *workspace);
MetaScreen *meta_workspace_get_screen (MetaWorkspace *workspace);
GList* meta_workspace_list_windows (MetaWorkspace *workspace);
-void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
- MetaRectangle *area);
+void meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
+ MetaRectangle *area);
void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp);
void meta_workspace_activate_with_focus (MetaWorkspace *workspace,
MetaWindow *focus_this,
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
