f2acdda740
2005-10-23 Elijah Newren <newren@gmail.com> Fix edge snapping for multi-screen (non-xinerama) setups. #319425 * src/place.c (get_windows_showing_on_same_screen, get_vertical_edges, get_horizontal_edges): rename get_windows_on_same_workspace() to get_windows_showing_on_same_screen() * src/place.c (get_windows_showing_on_same_screen): exclude windows in the list that are on a different screen
1585 lines
41 KiB
C
1585 lines
41 KiB
C
/* Metacity window placement */
|
|
|
|
/*
|
|
* Copyright (C) 2001 Havoc Pennington
|
|
* Copyright (C) 2002, 2003 Red Hat, Inc.
|
|
* Copyright (C) 2003 Rob Adams
|
|
* Copyright (C) 2005 Elijah Newren
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
* 02111-1307, USA.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "place.h"
|
|
#include "workspace.h"
|
|
#include "prefs.h"
|
|
#include <gdk/gdkregion.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
typedef enum
|
|
{
|
|
META_LEFT,
|
|
META_RIGHT,
|
|
META_TOP,
|
|
META_BOTTOM
|
|
} MetaWindowDirection;
|
|
|
|
static gint
|
|
northwestcmp (gconstpointer a, gconstpointer b)
|
|
{
|
|
MetaWindow *aw = (gpointer) a;
|
|
MetaWindow *bw = (gpointer) b;
|
|
int from_origin_a;
|
|
int from_origin_b;
|
|
int ax, ay, bx, by;
|
|
|
|
/* we're interested in the frame position for cascading,
|
|
* not meta_window_get_position()
|
|
*/
|
|
if (aw->frame)
|
|
{
|
|
ax = aw->frame->rect.x;
|
|
ay = aw->frame->rect.y;
|
|
}
|
|
else
|
|
{
|
|
ax = aw->rect.x;
|
|
ay = aw->rect.y;
|
|
}
|
|
|
|
if (bw->frame)
|
|
{
|
|
bx = bw->frame->rect.x;
|
|
by = bw->frame->rect.y;
|
|
}
|
|
else
|
|
{
|
|
bx = bw->rect.x;
|
|
by = bw->rect.y;
|
|
}
|
|
|
|
/* probably there's a fast good-enough-guess we could use here. */
|
|
from_origin_a = sqrt (ax * ax + ay * ay);
|
|
from_origin_b = sqrt (bx * bx + by * by);
|
|
|
|
if (from_origin_a < from_origin_b)
|
|
return -1;
|
|
else if (from_origin_a > from_origin_b)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
find_next_cascade (MetaWindow *window,
|
|
MetaFrameGeometry *fgeom,
|
|
/* visible windows on relevant workspaces */
|
|
GList *windows,
|
|
int x,
|
|
int y,
|
|
int *new_x,
|
|
int *new_y)
|
|
{
|
|
GList *tmp;
|
|
GList *sorted;
|
|
int cascade_x, cascade_y;
|
|
int x_threshold, y_threshold;
|
|
int window_width, window_height;
|
|
int cascade_stage;
|
|
MetaRectangle work_area;
|
|
const MetaXineramaScreenInfo* current;
|
|
|
|
sorted = g_list_copy (windows);
|
|
sorted = g_list_sort (sorted, northwestcmp);
|
|
|
|
/* This is a "fuzzy" cascade algorithm.
|
|
* For each window in the list, we find where we'd cascade a
|
|
* new window after it. If a window is already nearly at that
|
|
* position, we move on.
|
|
*/
|
|
|
|
/* arbitrary-ish threshold, honors user attempts to
|
|
* manually cascade.
|
|
*/
|
|
#define CASCADE_FUZZ 15
|
|
if (fgeom)
|
|
{
|
|
x_threshold = MAX (fgeom->left_width, CASCADE_FUZZ);
|
|
y_threshold = MAX (fgeom->top_height, CASCADE_FUZZ);
|
|
}
|
|
else
|
|
{
|
|
x_threshold = CASCADE_FUZZ;
|
|
y_threshold = CASCADE_FUZZ;
|
|
}
|
|
|
|
/* Find furthest-SE origin of all workspaces.
|
|
* cascade_x, cascade_y are the target position
|
|
* 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);
|
|
|
|
cascade_x = MAX (0, work_area.x);
|
|
cascade_y = MAX (0, work_area.y);
|
|
|
|
/* Find first cascade position that's not used. */
|
|
|
|
window_width = window->frame ? window->frame->rect.width : window->rect.width;
|
|
window_height = window->frame ? window->frame->rect.height : window->rect.height;
|
|
|
|
cascade_stage = 0;
|
|
tmp = sorted;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w;
|
|
int wx, wy;
|
|
|
|
w = tmp->data;
|
|
|
|
/* we want frame position, not window position */
|
|
if (w->frame)
|
|
{
|
|
wx = w->frame->rect.x;
|
|
wy = w->frame->rect.y;
|
|
}
|
|
else
|
|
{
|
|
wx = w->rect.x;
|
|
wy = w->rect.y;
|
|
}
|
|
|
|
if (ABS (wx - cascade_x) < x_threshold &&
|
|
ABS (wy - cascade_y) < y_threshold)
|
|
{
|
|
/* This window is "in the way", move to next cascade
|
|
* point. The new window frame should go at the origin
|
|
* of the client window we're stacking above.
|
|
*/
|
|
meta_window_get_position (w, &wx, &wy);
|
|
cascade_x = wx;
|
|
cascade_y = wy;
|
|
|
|
/* If we go off the screen, start over with a new cascade */
|
|
if (((cascade_x + window_width) >
|
|
(work_area.x + work_area.width)) ||
|
|
((cascade_y + window_height) >
|
|
(work_area.y + work_area.height)))
|
|
{
|
|
cascade_x = MAX (0, work_area.x);
|
|
cascade_y = MAX (0, work_area.y);
|
|
|
|
#define CASCADE_INTERVAL 50 /* space between top-left corners of cascades */
|
|
cascade_stage += 1;
|
|
cascade_x += CASCADE_INTERVAL * cascade_stage;
|
|
|
|
/* start over with a new cascade translated to the right, unless
|
|
* we are out of space
|
|
*/
|
|
if ((cascade_x + window_width) <
|
|
(work_area.x + work_area.width))
|
|
{
|
|
tmp = sorted;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
/* All out of space, this cascade_x won't work */
|
|
cascade_x = MAX (0, work_area.x);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Keep searching for a further-down-the-diagonal window. */
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
/* cascade_x and cascade_y will match the last window in the list
|
|
* that was "in the way" (in the approximate cascade diagonal)
|
|
*/
|
|
|
|
g_list_free (sorted);
|
|
|
|
/* Convert coords to position of window, not position of frame. */
|
|
if (fgeom == NULL)
|
|
{
|
|
*new_x = cascade_x;
|
|
*new_y = cascade_y;
|
|
}
|
|
else
|
|
{
|
|
*new_x = cascade_x + fgeom->left_width;
|
|
*new_y = cascade_y + fgeom->top_height;
|
|
}
|
|
}
|
|
|
|
static void
|
|
find_most_freespace (MetaWindow *window,
|
|
MetaFrameGeometry *fgeom,
|
|
/* visible windows on relevant workspaces */
|
|
MetaWindow *focus_window,
|
|
int x,
|
|
int y,
|
|
int *new_x,
|
|
int *new_y)
|
|
{
|
|
MetaWindowDirection side;
|
|
int max_area;
|
|
int max_width, max_height, left, right, top, bottom;
|
|
int left_space, right_space, top_space, bottom_space;
|
|
int frame_size_left, frame_size_top;
|
|
MetaRectangle work_area;
|
|
MetaRectangle avoid;
|
|
MetaRectangle outer;
|
|
|
|
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_outer_rect (focus_window, &avoid);
|
|
meta_window_get_outer_rect (window, &outer);
|
|
|
|
/* Find the areas of choosing the various sides of the focus window */
|
|
max_width = MIN (avoid.width, outer.width);
|
|
max_height = MIN (avoid.height, outer.height);
|
|
left_space = avoid.x - work_area.x;
|
|
right_space = work_area.width - (avoid.x + avoid.width - work_area.x);
|
|
top_space = avoid.y - work_area.y;
|
|
bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
|
|
left = MIN (left_space, outer.width);
|
|
right = MIN (right_space, outer.width);
|
|
top = MIN (top_space, outer.height);
|
|
bottom = MIN (bottom_space, outer.height);
|
|
|
|
/* Find out which side of the focus_window can show the most of the window */
|
|
side = META_LEFT;
|
|
max_area = left*max_height;
|
|
if (right*max_height > max_area)
|
|
{
|
|
side = META_RIGHT;
|
|
max_area = right*max_height;
|
|
}
|
|
if (top*max_width > max_area)
|
|
{
|
|
side = META_TOP;
|
|
max_area = top*max_width;
|
|
}
|
|
if (bottom*max_width > max_area)
|
|
{
|
|
side = META_BOTTOM;
|
|
max_area = bottom*max_width;
|
|
}
|
|
|
|
/* Give up if there's no where to put it (i.e. focus window is maximized) */
|
|
if (max_area == 0)
|
|
return;
|
|
|
|
/* Place the window on the relevant side; if the whole window fits,
|
|
* make it adjacent to the focus window; if not, make sure the
|
|
* window doesn't go off the edge of the screen.
|
|
*/
|
|
switch (side)
|
|
{
|
|
case META_LEFT:
|
|
*new_y = avoid.y + frame_size_top;
|
|
if (left_space > outer.width)
|
|
*new_x = avoid.x - outer.width + frame_size_left;
|
|
else
|
|
*new_x = work_area.x + frame_size_left;
|
|
break;
|
|
case META_RIGHT:
|
|
*new_y = avoid.y + frame_size_top;
|
|
if (right_space > outer.width)
|
|
*new_x = avoid.x + avoid.width + frame_size_left;
|
|
else
|
|
*new_x = work_area.x + work_area.width - outer.width + frame_size_left;
|
|
break;
|
|
case META_TOP:
|
|
*new_x = avoid.x + frame_size_left;
|
|
if (top_space > outer.height)
|
|
*new_y = avoid.y - outer.height + frame_size_top;
|
|
else
|
|
*new_y = work_area.y + frame_size_top;
|
|
break;
|
|
case META_BOTTOM:
|
|
*new_x = avoid.x + frame_size_left;
|
|
if (bottom_space > outer.height)
|
|
*new_y = avoid.y + avoid.height + frame_size_top;
|
|
else
|
|
*new_y = work_area.y + work_area.height - outer.height + frame_size_top;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
|
|
MetaFrameGeometry *fgeom,
|
|
int *x,
|
|
int *y)
|
|
{
|
|
/* We can't center this dialog if it was denied focus and it
|
|
* overlaps with the focus window and this dialog is modal and this
|
|
* dialog is in the same app as the focus window (*phew*...please
|
|
* don't make me say that ten times fast). See bug 307875 comment 11
|
|
* and 12 for details, but basically it means this is probably a
|
|
* second modal dialog for some app while the focus window is the
|
|
* first modal dialog. We should probably make them simultaneously
|
|
* visible in general, but it becomes mandatory to do so due to
|
|
* buggy apps (e.g. those using gtk+ *sigh*) because in those cases
|
|
* this second modal dialog also happens to be modal to the first
|
|
* dialog in addition to the main window, while it has only let us
|
|
* know about the modal-to-the-main-window part.
|
|
*/
|
|
|
|
MetaWindow *focus_window;
|
|
MetaRectangle overlap;
|
|
|
|
focus_window = window->display->focus_window;
|
|
|
|
if (window->denied_focus_and_not_transient &&
|
|
window->wm_state_modal && /* FIXME: Maybe do this for all transients? */
|
|
meta_window_same_application (window, focus_window) &&
|
|
meta_rectangle_intersect (&window->rect,
|
|
&focus_window->rect,
|
|
&overlap))
|
|
{
|
|
find_most_freespace (window, fgeom, focus_window, *x, *y, x, y);
|
|
meta_topic (META_DEBUG_PLACEMENT,
|
|
"Dialog window %s was denied focus but may be modal "
|
|
"to the focus window; had to move it to avoid the "
|
|
"focus window\n",
|
|
window->desc);
|
|
}
|
|
}
|
|
|
|
static int
|
|
intcmp (const void* a, const void* b)
|
|
{
|
|
const int *ai = a;
|
|
const int *bi = b;
|
|
|
|
if (*ai < *bi)
|
|
return -1;
|
|
else if (*ai > *bi)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
window_get_edges (MetaWindow *w,
|
|
int *left,
|
|
int *right,
|
|
int *top,
|
|
int *bottom)
|
|
{
|
|
int left_edge;
|
|
int right_edge;
|
|
int top_edge;
|
|
int bottom_edge;
|
|
MetaRectangle rect;
|
|
|
|
meta_window_get_outer_rect (w, &rect);
|
|
|
|
left_edge = rect.x;
|
|
right_edge = rect.x + rect.width;
|
|
top_edge = rect.y;
|
|
bottom_edge = rect.y + rect.height;
|
|
|
|
if (left)
|
|
*left = left_edge;
|
|
if (right)
|
|
*right = right_edge;
|
|
if (top)
|
|
*top = top_edge;
|
|
if (bottom)
|
|
*bottom = bottom_edge;
|
|
}
|
|
|
|
static gboolean
|
|
rectangle_overlaps_some_window (MetaRectangle *rect,
|
|
GList *windows)
|
|
{
|
|
GList *tmp;
|
|
MetaRectangle dest;
|
|
|
|
tmp = windows;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *other = tmp->data;
|
|
MetaRectangle other_rect;
|
|
|
|
switch (other->type)
|
|
{
|
|
case META_WINDOW_DOCK:
|
|
case META_WINDOW_SPLASHSCREEN:
|
|
case META_WINDOW_DESKTOP:
|
|
case META_WINDOW_DIALOG:
|
|
case META_WINDOW_MODAL_DIALOG:
|
|
break;
|
|
|
|
case META_WINDOW_NORMAL:
|
|
case META_WINDOW_UTILITY:
|
|
case META_WINDOW_TOOLBAR:
|
|
case META_WINDOW_MENU:
|
|
meta_window_get_outer_rect (other, &other_rect);
|
|
|
|
if (meta_rectangle_intersect (rect, &other_rect, &dest))
|
|
return TRUE;
|
|
break;
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
leftmost_cmp (gconstpointer a, gconstpointer b)
|
|
{
|
|
MetaWindow *aw = (gpointer) a;
|
|
MetaWindow *bw = (gpointer) b;
|
|
int ax, bx;
|
|
|
|
/* we're interested in the frame position for cascading,
|
|
* not meta_window_get_position()
|
|
*/
|
|
if (aw->frame)
|
|
ax = aw->frame->rect.x;
|
|
else
|
|
ax = aw->rect.x;
|
|
|
|
if (bw->frame)
|
|
bx = bw->frame->rect.x;
|
|
else
|
|
bx = bw->rect.x;
|
|
|
|
if (ax < bx)
|
|
return -1;
|
|
else if (ax > bx)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static gint
|
|
topmost_cmp (gconstpointer a, gconstpointer b)
|
|
{
|
|
MetaWindow *aw = (gpointer) a;
|
|
MetaWindow *bw = (gpointer) b;
|
|
int ay, by;
|
|
|
|
/* we're interested in the frame position for cascading,
|
|
* not meta_window_get_position()
|
|
*/
|
|
if (aw->frame)
|
|
ay = aw->frame->rect.y;
|
|
else
|
|
ay = aw->rect.y;
|
|
|
|
if (bw->frame)
|
|
by = bw->frame->rect.y;
|
|
else
|
|
by = bw->rect.y;
|
|
|
|
if (ay < by)
|
|
return -1;
|
|
else if (ay > by)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
center_tile_rect_in_area (MetaRectangle *rect,
|
|
MetaRectangle *work_area)
|
|
{
|
|
int fluff;
|
|
|
|
/* The point here is to tile a window such that "extra"
|
|
* space is equal on either side (i.e. so a full screen
|
|
* of windows tiled this way would center the windows
|
|
* as a group)
|
|
*/
|
|
|
|
fluff = (work_area->width % (rect->width+1)) / 2;
|
|
rect->x = work_area->x + fluff;
|
|
fluff = (work_area->height % (rect->height+1)) / 3;
|
|
rect->y = work_area->y + fluff;
|
|
}
|
|
|
|
static gboolean
|
|
rect_fits_in_work_area (MetaRectangle *work_area,
|
|
MetaRectangle *rect)
|
|
{
|
|
return ((rect->x >= work_area->x) &&
|
|
(rect->y >= work_area->y) &&
|
|
(rect->x + rect->width <= work_area->x + work_area->width) &&
|
|
(rect->y + rect->height <= work_area->y + work_area->height));
|
|
}
|
|
|
|
/* Find the leftmost, then topmost, empty area on the workspace
|
|
* that can contain the new window.
|
|
*
|
|
* Cool feature to have: if we can't fit the current window size,
|
|
* try shrinking the window (within geometry constraints). But
|
|
* beware windows such as Emacs with no sane minimum size, we
|
|
* don't want to create a 1x1 Emacs.
|
|
*/
|
|
static gboolean
|
|
find_first_fit (MetaWindow *window,
|
|
MetaFrameGeometry *fgeom,
|
|
/* visible windows on relevant workspaces */
|
|
GList *windows,
|
|
int* xineramas_list,
|
|
int n_xineramas,
|
|
int x,
|
|
int y,
|
|
int *new_x,
|
|
int *new_y)
|
|
{
|
|
/* This algorithm is limited - it just brute-force tries
|
|
* to fit the window in a small number of locations that are aligned
|
|
* with existing windows. It tries to place the window on
|
|
* the bottom of each existing window, and then to the right
|
|
* of each existing window, aligned with the left/top of the
|
|
* existing window in each of those cases.
|
|
*/
|
|
int retval;
|
|
GList *below_sorted;
|
|
GList *right_sorted;
|
|
GList *tmp;
|
|
MetaRectangle rect;
|
|
MetaRectangle work_area;
|
|
int i;
|
|
|
|
retval = FALSE;
|
|
|
|
/* Below each window */
|
|
below_sorted = g_list_copy (windows);
|
|
below_sorted = g_list_sort (below_sorted, leftmost_cmp);
|
|
below_sorted = g_list_sort (below_sorted, topmost_cmp);
|
|
|
|
/* To the right of each window */
|
|
right_sorted = g_list_copy (windows);
|
|
right_sorted = g_list_sort (right_sorted, topmost_cmp);
|
|
right_sorted = g_list_sort (right_sorted, leftmost_cmp);
|
|
|
|
rect.width = window->rect.width;
|
|
rect.height = window->rect.height;
|
|
|
|
if (fgeom)
|
|
{
|
|
rect.width += fgeom->left_width + fgeom->right_width;
|
|
rect.height += fgeom->top_height + fgeom->bottom_height;
|
|
}
|
|
|
|
for (i = 0; i < n_xineramas; i++)
|
|
{
|
|
meta_topic (META_DEBUG_XINERAMA,
|
|
"Natural xinerama %d is %d,%d %dx%d\n",
|
|
i,
|
|
window->screen->xinerama_infos[xineramas_list[i]].x_origin,
|
|
window->screen->xinerama_infos[xineramas_list[i]].y_origin,
|
|
window->screen->xinerama_infos[xineramas_list[i]].width,
|
|
window->screen->xinerama_infos[xineramas_list[i]].height);
|
|
}
|
|
|
|
/* try each xinerama in the natural ordering in turn */
|
|
i = 0;
|
|
while (i < n_xineramas)
|
|
{
|
|
meta_window_get_work_area_for_xinerama (window, xineramas_list[i], &work_area);
|
|
|
|
center_tile_rect_in_area (&rect, &work_area);
|
|
|
|
if (rect_fits_in_work_area (&work_area, &rect) &&
|
|
!rectangle_overlaps_some_window (&rect, windows))
|
|
{
|
|
*new_x = rect.x;
|
|
*new_y = rect.y;
|
|
if (fgeom)
|
|
{
|
|
*new_x += fgeom->left_width;
|
|
*new_y += fgeom->top_height;
|
|
}
|
|
|
|
retval = TRUE;
|
|
|
|
goto out;
|
|
}
|
|
|
|
/* try below each window */
|
|
tmp = below_sorted;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
MetaRectangle outer_rect;
|
|
|
|
meta_window_get_outer_rect (w, &outer_rect);
|
|
|
|
rect.x = outer_rect.x;
|
|
rect.y = outer_rect.y + outer_rect.height;
|
|
|
|
if (rect_fits_in_work_area (&work_area, &rect) &&
|
|
!rectangle_overlaps_some_window (&rect, below_sorted))
|
|
{
|
|
*new_x = rect.x;
|
|
*new_y = rect.y;
|
|
if (fgeom)
|
|
{
|
|
*new_x += fgeom->left_width;
|
|
*new_y += fgeom->top_height;
|
|
}
|
|
|
|
retval = TRUE;
|
|
|
|
goto out;
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
/* try to the right of each window */
|
|
tmp = right_sorted;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
MetaRectangle outer_rect;
|
|
|
|
meta_window_get_outer_rect (w, &outer_rect);
|
|
|
|
rect.x = outer_rect.x + outer_rect.width;
|
|
rect.y = outer_rect.y;
|
|
|
|
if (rect_fits_in_work_area (&work_area, &rect) &&
|
|
!rectangle_overlaps_some_window (&rect, right_sorted))
|
|
{
|
|
*new_x = rect.x;
|
|
*new_y = rect.y;
|
|
if (fgeom)
|
|
{
|
|
*new_x += fgeom->left_width;
|
|
*new_y += fgeom->top_height;
|
|
}
|
|
|
|
retval = TRUE;
|
|
|
|
goto out;
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
++i;
|
|
}
|
|
|
|
out:
|
|
|
|
g_list_free (below_sorted);
|
|
g_list_free (right_sorted);
|
|
return retval;
|
|
}
|
|
|
|
void
|
|
meta_window_place (MetaWindow *window,
|
|
MetaFrameGeometry *fgeom,
|
|
int x,
|
|
int y,
|
|
int *new_x,
|
|
int *new_y)
|
|
{
|
|
GList *windows;
|
|
const MetaXineramaScreenInfo *xi;
|
|
int* xineramas_list = NULL;
|
|
int n_xineramas;
|
|
int i;
|
|
int placed_on = -1;
|
|
|
|
/* frame member variables should NEVER be used in here, only
|
|
* MetaFrameGeometry. But remember fgeom == NULL
|
|
* for undecorated windows. Also, this function should
|
|
* NEVER have side effects other than computing the
|
|
* placement coordinates.
|
|
*/
|
|
|
|
meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
|
|
|
|
windows = NULL;
|
|
|
|
switch (window->type)
|
|
{
|
|
/* Run placement algorithm on these. */
|
|
case META_WINDOW_NORMAL:
|
|
case META_WINDOW_DIALOG:
|
|
case META_WINDOW_MODAL_DIALOG:
|
|
case META_WINDOW_SPLASHSCREEN:
|
|
break;
|
|
|
|
/* Assume the app knows best how to place these, no placement
|
|
* algorithm ever (other than "leave them as-is")
|
|
*/
|
|
case META_WINDOW_DESKTOP:
|
|
case META_WINDOW_DOCK:
|
|
case META_WINDOW_TOOLBAR:
|
|
case META_WINDOW_MENU:
|
|
case META_WINDOW_UTILITY:
|
|
goto done_no_constraints;
|
|
break;
|
|
}
|
|
|
|
if (meta_prefs_get_disable_workarounds ())
|
|
{
|
|
switch (window->type)
|
|
{
|
|
/* Only accept USPosition on normal windows because the app is full
|
|
* of shit claiming the user set -geometry for a dialog or dock
|
|
*/
|
|
case META_WINDOW_NORMAL:
|
|
if (window->size_hints.flags & USPosition)
|
|
{
|
|
/* don't constrain with placement algorithm */
|
|
meta_topic (META_DEBUG_PLACEMENT,
|
|
"Honoring USPosition for %s instead of using placement algorithm\n", window->desc);
|
|
|
|
goto done;
|
|
}
|
|
break;
|
|
|
|
/* Ignore even USPosition on dialogs, splashscreen */
|
|
case META_WINDOW_DIALOG:
|
|
case META_WINDOW_MODAL_DIALOG:
|
|
case META_WINDOW_SPLASHSCREEN:
|
|
break;
|
|
|
|
/* Assume the app knows best how to place these. */
|
|
case META_WINDOW_DESKTOP:
|
|
case META_WINDOW_DOCK:
|
|
case META_WINDOW_TOOLBAR:
|
|
case META_WINDOW_MENU:
|
|
case META_WINDOW_UTILITY:
|
|
if (window->size_hints.flags & PPosition)
|
|
{
|
|
meta_topic (META_DEBUG_PLACEMENT,
|
|
"Not placing non-normal non-dialog window with PPosition set\n");
|
|
goto done_no_constraints;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* workarounds enabled */
|
|
|
|
if ((window->size_hints.flags & PPosition) ||
|
|
(window->size_hints.flags & USPosition))
|
|
{
|
|
meta_topic (META_DEBUG_PLACEMENT,
|
|
"Not placing window with PPosition or USPosition set\n");
|
|
avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
|
|
goto done_no_constraints;
|
|
}
|
|
}
|
|
|
|
if ((window->type == META_WINDOW_DIALOG ||
|
|
window->type == META_WINDOW_MODAL_DIALOG) &&
|
|
window->xtransient_for != None)
|
|
{
|
|
/* Center horizontally, at top of parent vertically */
|
|
|
|
MetaWindow *parent;
|
|
|
|
parent =
|
|
meta_display_lookup_x_window (window->display,
|
|
window->xtransient_for);
|
|
|
|
if (parent)
|
|
{
|
|
int w;
|
|
MetaRectangle area;
|
|
|
|
meta_window_get_position (parent, &x, &y);
|
|
w = parent->rect.width;
|
|
|
|
/* center of parent */
|
|
x = x + w / 2;
|
|
/* center of child over center of parent */
|
|
x -= window->rect.width / 2;
|
|
|
|
/* "visually" center window over parent, leaving twice as
|
|
* much space below as on top.
|
|
*/
|
|
y += (parent->rect.height - window->rect.height)/3;
|
|
|
|
/* put top of child's frame, not top of child's client */
|
|
if (fgeom)
|
|
y += fgeom->top_height;
|
|
|
|
/* clip to xinerama of parent*/
|
|
meta_window_get_work_area_current_xinerama (parent, &area);
|
|
|
|
if (x + window->rect.width > area.x + area.width)
|
|
x = area.x + area.width - window->rect.width;
|
|
if (y + window->rect.height > area.y + area.height)
|
|
y = area.y + area.height - window->rect.height;
|
|
if (x < area.x) x = area.x;
|
|
if (y < area.y) y = area.y;
|
|
|
|
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
|
|
window->desc);
|
|
|
|
avoid_being_obscured_as_second_modal_dialog (window, fgeom, &x, &y);
|
|
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
meta_screen_get_natural_xinerama_list (window->screen,
|
|
&xineramas_list,
|
|
&n_xineramas);
|
|
|
|
/* FIXME UTILITY with transient set should be stacked up
|
|
* on the sides of the parent window or something.
|
|
*/
|
|
|
|
if (window->type == META_WINDOW_DIALOG ||
|
|
window->type == META_WINDOW_MODAL_DIALOG ||
|
|
window->type == META_WINDOW_SPLASHSCREEN)
|
|
{
|
|
/* Center on screen */
|
|
int w, h;
|
|
|
|
/* Warning, this function is a round trip! */
|
|
xi = meta_screen_get_current_xinerama (window->screen);
|
|
|
|
w = xi->width;
|
|
h = xi->height;
|
|
|
|
x = (w - window->rect.width) / 2;
|
|
y = (h - window->rect.height) / 2;
|
|
|
|
x += xi->x_origin;
|
|
y += xi->y_origin;
|
|
|
|
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d xinerama %d\n",
|
|
window->desc, window->screen->number, xi->number);
|
|
|
|
goto done_check_denied_focus;
|
|
}
|
|
|
|
/* Find windows that matter (not minimized, on same workspace
|
|
* as placed window, may be shaded - if shaded we pretend it isn't
|
|
* for placement purposes)
|
|
*/
|
|
{
|
|
GSList *all_windows;
|
|
GSList *tmp;
|
|
|
|
all_windows = meta_display_list_windows (window->display);
|
|
|
|
tmp = all_windows;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
|
|
if (meta_window_showing_on_its_workspace (w) &&
|
|
w != window &&
|
|
(window->workspace == w->workspace ||
|
|
window->on_all_workspaces || w->on_all_workspaces))
|
|
windows = g_list_prepend (windows, w);
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
g_slist_free (all_windows);
|
|
}
|
|
|
|
/* Warning, this is a round trip! */
|
|
xi = meta_screen_get_current_xinerama (window->screen);
|
|
|
|
/* "Origin" placement algorithm */
|
|
x = xi->x_origin;
|
|
y = xi->y_origin;
|
|
|
|
if (find_first_fit (window, fgeom, windows,
|
|
xineramas_list, n_xineramas,
|
|
x, y, &x, &y))
|
|
goto done_check_denied_focus;
|
|
|
|
/* This is a special-case origin-cascade so that windows that are
|
|
* too large to fit onto a workspace (and which will be
|
|
* automaximized later) will go onto an empty xinerama if one is
|
|
* available.
|
|
*/
|
|
if (window->has_maximize_func && window->decorated &&
|
|
!window->fullscreen)
|
|
{
|
|
if (window->frame)
|
|
{
|
|
x = fgeom->left_width;
|
|
y = fgeom->top_height;
|
|
}
|
|
else
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
}
|
|
|
|
for (i = 0; i < n_xineramas; i++)
|
|
{
|
|
MetaRectangle work_area;
|
|
|
|
meta_window_get_work_area_for_xinerama (window, xineramas_list[i], &work_area);
|
|
|
|
if (!rectangle_overlaps_some_window (&work_area, windows))
|
|
{
|
|
x += work_area.x;
|
|
y += work_area.y;
|
|
placed_on = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if the window wasn't placed at the origin of an empty xinerama,
|
|
* cascade it onto the current xinerama
|
|
*/
|
|
if (placed_on == -1)
|
|
{
|
|
find_next_cascade (window, fgeom, windows, x, y, &x, &y);
|
|
placed_on = window->screen->last_xinerama_index;
|
|
}
|
|
|
|
/* Maximize windows if they are too big for their work area (bit of
|
|
* a hack here). Assume undecorated windows probably don't intend to
|
|
* be maximized.
|
|
*/
|
|
if (window->has_maximize_func && window->decorated &&
|
|
!window->fullscreen)
|
|
{
|
|
MetaRectangle workarea;
|
|
MetaRectangle outer;
|
|
|
|
meta_window_get_work_area_for_xinerama (window,
|
|
xineramas_list[placed_on],
|
|
&workarea);
|
|
meta_window_get_outer_rect (window, &outer);
|
|
|
|
if (outer.width >= workarea.width &&
|
|
outer.height >= workarea.height)
|
|
{
|
|
window->maximize_after_placement = TRUE;
|
|
}
|
|
}
|
|
|
|
done_check_denied_focus:
|
|
/* If the window is being denied focus and isn't a transient of the
|
|
* focus window, we do NOT want it to overlap with the focus window
|
|
* if at all possible. This is guaranteed to only be called if the
|
|
* focus_window is non-NULL, and we try to avoid that window.
|
|
*/
|
|
if (window->denied_focus_and_not_transient)
|
|
{
|
|
gboolean found_fit;
|
|
MetaWindow *focus_window;
|
|
MetaRectangle overlap;
|
|
|
|
focus_window = window->display->focus_window;
|
|
g_assert (focus_window != NULL);
|
|
|
|
/* No need to do anything if the window doesn't overlap at all */
|
|
found_fit = !meta_rectangle_intersect (&window->rect,
|
|
&focus_window->rect,
|
|
&overlap);
|
|
|
|
/* Try to do a first fit again, this time only taking into account the
|
|
* focus window.
|
|
*/
|
|
if (!found_fit)
|
|
{
|
|
GList *focus_window_list;
|
|
focus_window_list = g_list_prepend (NULL, focus_window);
|
|
|
|
/* Reset x and y ("origin" placement algorithm) */
|
|
x = xi->x_origin;
|
|
y = xi->y_origin;
|
|
|
|
found_fit = find_first_fit (window, fgeom, focus_window_list,
|
|
xineramas_list, n_xineramas,
|
|
x, y, &x, &y);
|
|
g_list_free (focus_window_list);
|
|
}
|
|
|
|
/* If that still didn't work, just place it where we can see as much
|
|
* as possible.
|
|
*/
|
|
if (!found_fit)
|
|
find_most_freespace (window, fgeom, focus_window, x, y, &x, &y);
|
|
}
|
|
|
|
done:
|
|
g_free (xineramas_list);
|
|
g_list_free (windows);
|
|
|
|
done_no_constraints:
|
|
|
|
*new_x = x;
|
|
*new_y = y;
|
|
}
|
|
|
|
|
|
/* These are used while moving or resizing to "snap" to useful
|
|
* places; the return value is the x/y position of the window to
|
|
* be snapped to the given edge.
|
|
*
|
|
* They only use edges on the current workspace, since things
|
|
* would be weird otherwise.
|
|
*/
|
|
static GSList*
|
|
get_windows_showing_on_same_screen (MetaWindow *window,
|
|
int *n_windows)
|
|
{
|
|
GSList *windows;
|
|
GSList *all_windows;
|
|
GSList *tmp;
|
|
int i;
|
|
|
|
windows = NULL;
|
|
|
|
i = 0;
|
|
all_windows = meta_display_list_windows (window->display);
|
|
|
|
tmp = all_windows;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
|
|
if (meta_window_should_be_showing (w) &&
|
|
w->screen == window->screen &&
|
|
w != window)
|
|
{
|
|
windows = g_slist_prepend (windows, w);
|
|
++i;
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
if (n_windows)
|
|
*n_windows = i;
|
|
|
|
g_slist_free (all_windows);
|
|
|
|
return windows;
|
|
}
|
|
|
|
static gboolean
|
|
rects_overlap_vertically (const MetaRectangle *a,
|
|
const MetaRectangle *b)
|
|
{
|
|
/* if they don't overlap, then either a is above b
|
|
* or b is above a
|
|
*/
|
|
if ((a->y + a->height) < b->y)
|
|
return FALSE;
|
|
else if ((b->y + b->height) < a->y)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
rects_overlap_horizontally (const MetaRectangle *a,
|
|
const MetaRectangle *b)
|
|
{
|
|
if ((a->x + a->width) < b->x)
|
|
return FALSE;
|
|
else if ((b->x + b->width) < a->x)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
get_vertical_edges (MetaWindow *window,
|
|
int **edges_p,
|
|
int *n_edges_p)
|
|
{
|
|
GSList *windows;
|
|
GSList *tmp;
|
|
int n_windows;
|
|
GArray *edges;
|
|
int edge, i;
|
|
MetaRectangle rect;
|
|
MetaRectangle work_area;
|
|
|
|
windows = get_windows_showing_on_same_screen (window, &n_windows);
|
|
|
|
edges = g_array_sized_new (FALSE, FALSE, sizeof (int),
|
|
n_windows * 2 + 4 /* 4 = workspace/screen edges */
|
|
+ window->screen->n_xinerama_infos - 1
|
|
+ 2 /* active window edges when in wireframe mode */);
|
|
|
|
/* workspace/screen edges */
|
|
meta_window_get_work_area_current_xinerama (window, &work_area);
|
|
|
|
g_array_append_val (edges, work_area.x);
|
|
edge = work_area.x + work_area.width;
|
|
g_array_append_val (edges, edge);
|
|
edge = 0;
|
|
g_array_append_val (edges, edge);
|
|
g_array_append_val (edges, window->screen->width);
|
|
|
|
/* Now get the xinerama screen edges */
|
|
for (i = 0; i < window->screen->n_xinerama_infos - 1; i++)
|
|
{
|
|
edge = window->screen->xinerama_infos[i].x_origin +
|
|
window->screen->xinerama_infos[i].width;
|
|
|
|
g_array_append_val (edges, edge);
|
|
}
|
|
|
|
if (window->display->grab_wireframe_active)
|
|
{
|
|
int left_edge, right_edge, top_edge, bottom_edge;
|
|
|
|
meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
|
|
&rect);
|
|
|
|
window_get_edges (window, &left_edge, &right_edge,
|
|
&top_edge, &bottom_edge);
|
|
|
|
g_array_append_val (edges, left_edge);
|
|
g_array_append_val (edges, right_edge);
|
|
}
|
|
else
|
|
meta_window_get_outer_rect (window, &rect);
|
|
|
|
/* get window edges */
|
|
tmp = windows;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
MetaRectangle w_rect;
|
|
|
|
meta_window_get_outer_rect (w, &w_rect);
|
|
|
|
if (rects_overlap_vertically (&rect, &w_rect))
|
|
{
|
|
g_array_append_val (edges, w_rect.x);
|
|
edge = w_rect.x + w_rect.width;
|
|
g_array_append_val (edges, edge);
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
g_slist_free (windows);
|
|
|
|
/* Sort */
|
|
qsort (edges->data, edges->len, sizeof (int), intcmp);
|
|
|
|
*n_edges_p = edges->len;
|
|
*edges_p = (int *) g_array_free (edges, FALSE);
|
|
}
|
|
|
|
static void
|
|
get_horizontal_edges (MetaWindow *window,
|
|
int **edges_p,
|
|
int *n_edges_p)
|
|
{
|
|
GSList *windows;
|
|
GSList *tmp;
|
|
int n_windows;
|
|
GArray *edges;
|
|
int edge, i;
|
|
MetaRectangle rect;
|
|
MetaRectangle work_area;
|
|
|
|
windows = get_windows_showing_on_same_screen (window, &n_windows);
|
|
|
|
edges = g_array_sized_new (FALSE, FALSE, sizeof (int),
|
|
n_windows * 2 + 4 /* 4 = workspace/screen edges */
|
|
+ window->screen->n_xinerama_infos - 1
|
|
+ 2 /* active window edges when in wireframe mode */);
|
|
|
|
/* workspace/screen edges */
|
|
meta_window_get_work_area_current_xinerama (window, &work_area);
|
|
|
|
g_array_append_val (edges, work_area.y);
|
|
edge = work_area.y + work_area.height;
|
|
g_array_append_val (edges, edge);
|
|
edge = 0;
|
|
g_array_append_val (edges, edge);
|
|
g_array_append_val (edges, window->screen->height);
|
|
|
|
/* Now get the xinerama screen edges */
|
|
for (i = 0; i < window->screen->n_xinerama_infos - 1; i++)
|
|
{
|
|
edge = window->screen->xinerama_infos[i].y_origin +
|
|
window->screen->xinerama_infos[i].height;
|
|
g_array_append_val (edges, edge);
|
|
}
|
|
|
|
if (window->display->grab_wireframe_active)
|
|
{
|
|
int left_edge, right_edge, top_edge, bottom_edge;
|
|
|
|
meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
|
|
&rect);
|
|
|
|
window_get_edges (window, &left_edge, &right_edge,
|
|
&top_edge, &bottom_edge);
|
|
|
|
g_array_append_val (edges, top_edge);
|
|
g_array_append_val (edges, bottom_edge);
|
|
}
|
|
else
|
|
meta_window_get_outer_rect (window, &rect);
|
|
|
|
/* get window edges */
|
|
tmp = windows;
|
|
while (tmp != NULL)
|
|
{
|
|
MetaWindow *w = tmp->data;
|
|
MetaRectangle w_rect;
|
|
|
|
meta_window_get_outer_rect (w, &w_rect);
|
|
|
|
if (rects_overlap_horizontally (&rect, &w_rect))
|
|
{
|
|
g_array_append_val (edges, w_rect.y);
|
|
edge = w_rect.y + w_rect.height;
|
|
g_array_append_val (edges, edge);
|
|
}
|
|
|
|
tmp = tmp->next;
|
|
}
|
|
g_slist_free (windows);
|
|
|
|
/* Sort */
|
|
qsort (edges->data, edges->len, sizeof (int), intcmp);
|
|
|
|
*n_edges_p = edges->len;
|
|
*edges_p = (int *) g_array_free (edges, FALSE);
|
|
}
|
|
|
|
int
|
|
meta_window_find_next_vertical_edge (MetaWindow *window,
|
|
MetaWindowEdgePosition source_edge_position,
|
|
gboolean right)
|
|
{
|
|
int left_edge, right_edge, source_edge;
|
|
int *edges;
|
|
int i;
|
|
int n_edges;
|
|
int retval;
|
|
|
|
get_vertical_edges (window, &edges, &n_edges);
|
|
|
|
/* Find next */
|
|
if (window->display->grab_wireframe_active)
|
|
{
|
|
MetaRectangle rect;
|
|
|
|
meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
|
|
&rect);
|
|
|
|
left_edge = rect.x;
|
|
right_edge = left_edge + rect.width;
|
|
}
|
|
else
|
|
window_get_edges (window, &left_edge, &right_edge, NULL, NULL);
|
|
|
|
switch (source_edge_position)
|
|
{
|
|
case META_WINDOW_EDGE_LEFT:
|
|
source_edge = left_edge;
|
|
break;
|
|
|
|
case META_WINDOW_EDGE_RIGHT:
|
|
source_edge = right_edge;
|
|
break;
|
|
|
|
case META_WINDOW_EDGE_TOP:
|
|
case META_WINDOW_EDGE_BOTTOM:
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
retval = source_edge;
|
|
|
|
if (right)
|
|
{
|
|
i = 0;
|
|
while (i < n_edges)
|
|
{
|
|
if (edges[i] > source_edge)
|
|
{
|
|
retval = edges[i];
|
|
break;
|
|
}
|
|
|
|
++i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i = n_edges;
|
|
do
|
|
{
|
|
--i;
|
|
|
|
if (edges[i] < source_edge)
|
|
{
|
|
retval = edges[i];
|
|
break;
|
|
}
|
|
}
|
|
while (i > 0);
|
|
}
|
|
|
|
g_free (edges);
|
|
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
meta_window_find_next_horizontal_edge (MetaWindow *window,
|
|
MetaWindowEdgePosition source_edge_position,
|
|
gboolean down)
|
|
{
|
|
int top_edge, bottom_edge, source_edge;
|
|
int *edges;
|
|
int i;
|
|
int n_edges;
|
|
int retval;
|
|
|
|
get_horizontal_edges (window, &edges, &n_edges);
|
|
|
|
/* Find next */
|
|
if (window->display->grab_wireframe_active)
|
|
{
|
|
MetaRectangle rect;
|
|
|
|
meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect,
|
|
&rect);
|
|
|
|
top_edge = rect.y;
|
|
bottom_edge = top_edge + rect.height;
|
|
}
|
|
else
|
|
window_get_edges (window, NULL, NULL, &top_edge, &bottom_edge);
|
|
|
|
switch (source_edge_position)
|
|
{
|
|
case META_WINDOW_EDGE_TOP:
|
|
source_edge = top_edge;
|
|
break;
|
|
|
|
case META_WINDOW_EDGE_BOTTOM:
|
|
source_edge = bottom_edge;
|
|
break;
|
|
|
|
case META_WINDOW_EDGE_LEFT:
|
|
case META_WINDOW_EDGE_RIGHT:
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
retval = source_edge;
|
|
|
|
if (down)
|
|
{
|
|
i = 0;
|
|
while (i < n_edges)
|
|
{
|
|
if (edges[i] > source_edge)
|
|
{
|
|
retval = edges[i];
|
|
break;
|
|
}
|
|
|
|
++i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i = n_edges;
|
|
do
|
|
{
|
|
--i;
|
|
|
|
if (edges[i] < source_edge)
|
|
{
|
|
retval = edges[i];
|
|
break;
|
|
}
|
|
}
|
|
while (i > 0);
|
|
}
|
|
|
|
g_free (edges);
|
|
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
meta_window_find_nearest_vertical_edge (MetaWindow *window,
|
|
int x_pos)
|
|
{
|
|
int *edges;
|
|
int i;
|
|
int n_edges;
|
|
int *positions;
|
|
int n_positions;
|
|
int retval;
|
|
|
|
get_vertical_edges (window, &edges, &n_edges);
|
|
|
|
/* Create an array of all snapped positions our window could have */
|
|
n_positions = n_edges * 2;
|
|
positions = g_new (int, n_positions);
|
|
|
|
i = 0;
|
|
while (i < n_edges)
|
|
{
|
|
int left_pos, right_pos;
|
|
|
|
left_pos = edges[i];
|
|
|
|
if (window->frame)
|
|
{
|
|
left_pos += window->frame->child_x;
|
|
right_pos = edges[i] - window->frame->rect.width;
|
|
right_pos += window->frame->child_x;
|
|
}
|
|
else
|
|
{
|
|
right_pos = edges[i] - window->rect.width;
|
|
}
|
|
|
|
positions[i * 2] = left_pos;
|
|
positions[i * 2 + 1] = right_pos;
|
|
|
|
++i;
|
|
}
|
|
|
|
g_free (edges);
|
|
|
|
/* Sort */
|
|
qsort (positions, n_positions, sizeof (int), intcmp);
|
|
|
|
/* Find nearest */
|
|
|
|
retval = positions[0];
|
|
|
|
i = 1;
|
|
while (i < n_positions)
|
|
{
|
|
int delta;
|
|
int best_delta;
|
|
|
|
delta = ABS (x_pos - positions[i]);
|
|
best_delta = ABS (x_pos - retval);
|
|
|
|
if (delta < best_delta)
|
|
retval = positions[i];
|
|
|
|
++i;
|
|
}
|
|
|
|
g_free (positions);
|
|
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
meta_window_find_nearest_horizontal_edge (MetaWindow *window,
|
|
int y_pos)
|
|
{
|
|
int *edges;
|
|
int i;
|
|
int n_edges;
|
|
int *positions;
|
|
int n_positions;
|
|
int retval;
|
|
|
|
get_horizontal_edges (window, &edges, &n_edges);
|
|
|
|
/* Create an array of all snapped positions our window could have */
|
|
n_positions = n_edges * 2;
|
|
positions = g_new (int, n_positions);
|
|
|
|
i = 0;
|
|
while (i < n_edges)
|
|
{
|
|
int top_pos, bottom_pos;
|
|
|
|
top_pos = edges[i];
|
|
|
|
if (window->frame)
|
|
{
|
|
top_pos += window->frame->child_y;
|
|
bottom_pos = edges[i] - window->frame->rect.height;
|
|
bottom_pos += window->frame->child_y;
|
|
}
|
|
else
|
|
{
|
|
bottom_pos = edges[i] - window->rect.height;
|
|
}
|
|
|
|
positions[i * 2] = top_pos;
|
|
positions[i * 2 + 1] = bottom_pos;
|
|
|
|
++i;
|
|
}
|
|
|
|
g_free (edges);
|
|
|
|
/* Sort */
|
|
qsort (positions, n_positions, sizeof (int), intcmp);
|
|
|
|
/* Find nearest */
|
|
|
|
retval = positions[0];
|
|
|
|
i = 1;
|
|
while (i < n_positions)
|
|
{
|
|
int delta;
|
|
int best_delta;
|
|
|
|
delta = ABS (y_pos - positions[i]);
|
|
best_delta = ABS (y_pos - retval);
|
|
|
|
if (delta < best_delta)
|
|
retval = positions[i];
|
|
|
|
++i;
|
|
}
|
|
|
|
g_free (positions);
|
|
|
|
return retval;
|
|
}
|