32d4bd6b63
2006-01-20 Elijah Newren <newren gmail com> * src/async-getprop.c: * src/common.h: * src/display.c: * src/eggaccelerators.c: * src/frames.c: * src/gradient.c: * src/iconcache.c: * src/keybindings.c: * src/metaaccellabel.c: * src/place.c: * src/prefs.c: * src/preview-widget.c: * src/screen.c: * src/session.c: * src/stack.c: * src/tabpopup.c: * src/theme-viewer.c: * src/theme.c: * src/window-props.c: * src/window.c: * src/workspace.c: * src/tools/metacity-window-demo.c: * src/wm-tester/test-gravity.c: * src/wm-tester/test-resizing.c: * src/wm-tester/test-size-hints.c: Patch from Kjartan Maraas to fix a lot of tiny issues (unused variable removal, making unused variables used again, correction of types passed/declared for printf arguments, removal of unneeded breaks and returns, dead code removal, dead code revival, renaming to prevent shadowed variables, declaring unexported functions as static) spotted by the intel compiler. #321439
1560 lines
40 KiB
C
1560 lines
40 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;
|
|
}
|
|
|
|
/* 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++)
|
|
{
|
|
#ifdef WITH_VERBOSE_MODE
|
|
char xinerama_location_string[RECT_LENGTH];
|
|
meta_rectangle_to_string (&window->screen->xinerama_infos[xineramas_list[i]].rect,
|
|
xinerama_location_string);
|
|
meta_topic (META_DEBUG_XINERAMA,
|
|
"Natural xinerama %d is %s\n",
|
|
i,
|
|
xinerama_location_string);
|
|
#endif
|
|
}
|
|
|
|
/* 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 (meta_rectangle_contains_rect (&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 (meta_rectangle_contains_rect (&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 (meta_rectangle_contains_rect (&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;
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
#if 0
|
|
/* FIXME: If no one has complained about this within a couple
|
|
* months, it means that the constraints.c rewrite fixed this
|
|
* correctly and this hack is no longer necessary. Feel free to
|
|
* submit a patch removing this #ifdef'd out code. (Comment
|
|
* written on 2005-10-28).
|
|
*/
|
|
|
|
MetaRectangle area;
|
|
|
|
/* 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;
|
|
#endif
|
|
|
|
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 current xinerama (i.e. on current monitor) */
|
|
int w, h;
|
|
|
|
/* Warning, this function is a round trip! */
|
|
xi = meta_screen_get_current_xinerama (window->screen);
|
|
|
|
w = xi->rect.width;
|
|
h = xi->rect.height;
|
|
|
|
x = (w - window->rect.width) / 2;
|
|
y = (h - window->rect.height) / 2;
|
|
|
|
x += xi->rect.x;
|
|
y += xi->rect.y;
|
|
|
|
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->rect.x;
|
|
y = xi->rect.y;
|
|
|
|
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)
|
|
window->maximize_horizontally_after_placement = TRUE;
|
|
|
|
if (outer.height >= workarea.height)
|
|
window->maximize_vertically_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->rect.x;
|
|
y = xi->rect.y;
|
|
|
|
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 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->rect.width);
|
|
|
|
/* Now get the xinerama screen edges */
|
|
for (i = 0; i < window->screen->n_xinerama_infos - 1; i++)
|
|
{
|
|
edge = window->screen->xinerama_infos[i].rect.x +
|
|
window->screen->xinerama_infos[i].rect.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 (meta_rectangle_vert_overlap (&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->rect.height);
|
|
|
|
/* Now get the xinerama screen edges */
|
|
for (i = 0; i < window->screen->n_xinerama_infos - 1; i++)
|
|
{
|
|
edge = window->screen->xinerama_infos[i].rect.y +
|
|
window->screen->xinerama_infos[i].rect.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 (meta_rectangle_horiz_overlap (&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;
|
|
}
|