From 3a1e492afc5036c65a5184b70f769a6a22f5291c Mon Sep 17 00:00:00 2001 From: Dan Winship Date: Mon, 31 Aug 2009 09:52:16 -0400 Subject: [PATCH] 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 dda283aaf..bc596bd68 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 a8308cbb3..a6b334421 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 5fbb1323c..aca7791d9 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 b84f16fcb..9fcdd22f2 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 2dcb415c0..8409ff8b2 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 9ba062dac..f098f8ae0 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 5c1bc6a60..6edba5328 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 66adf7dec..64cfb0802 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 c078544af..aac82308e 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 869a621fc..706e85b6d 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 93f430cbe..596990b3c 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 044acbe4f..0e7fb9819 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 82ced0220..5f5e62b78 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 84469c184..1a8b9771a 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 b875147bf..add3618dd 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 5c76ed6b0..11fd8bd07 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 f44aa09d7..21ebf9e11 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,