2001-06-24 02:47:54 -04:00
|
|
|
/* Metacity window placement */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright (C) 2001 Havoc Pennington
|
|
|
|
*
|
|
|
|
* 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 "place.h"
|
2001-06-24 04:09:10 -04:00
|
|
|
#include "workspace.h"
|
|
|
|
#include <gdk/gdkregion.h>
|
|
|
|
#include <math.h>
|
2001-07-12 01:53:56 -04:00
|
|
|
#include <stdlib.h>
|
2001-06-24 04:09:10 -04:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Find furthest-SE origin of all workspaces.
|
|
|
|
* cascade_x, cascade_y are the target position
|
|
|
|
* of NW corner of window frame.
|
|
|
|
*/
|
|
|
|
cascade_x = 0;
|
|
|
|
cascade_y = 0;
|
|
|
|
tmp = window->workspaces;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWorkspace *space = tmp->data;
|
|
|
|
|
|
|
|
cascade_x = MAX (cascade_x, space->workarea.x);
|
|
|
|
cascade_y = MAX (cascade_y, space->workarea.y);
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find first cascade position that's not used. */
|
|
|
|
|
|
|
|
/* arbitrary-ish threshold, honors user attempts to
|
|
|
|
* manually cascade.
|
|
|
|
*/
|
2001-07-03 14:37:18 -04:00
|
|
|
if (fgeom)
|
|
|
|
{
|
|
|
|
x_threshold = MAX (fgeom->left_width, 10);
|
|
|
|
y_threshold = MAX (fgeom->top_height, 10);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x_threshold = 10;
|
|
|
|
y_threshold = 10;
|
|
|
|
}
|
2001-06-24 04:09:10 -04:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
goto found; /* no window at this cascade point. */
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cascade_x and cascade_y will match the last window in the list. */
|
|
|
|
|
|
|
|
found:
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the leftmost, then topmost, empty area on the workspace
|
|
|
|
* that can contain the new window.
|
|
|
|
*/
|
|
|
|
static gboolean
|
|
|
|
find_first_fit (MetaWindow *window,
|
|
|
|
MetaFrameGeometry *fgeom,
|
|
|
|
/* visible windows on relevant workspaces */
|
|
|
|
GList *windows,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int *new_x,
|
|
|
|
int *new_y)
|
|
|
|
{
|
2001-07-04 00:33:31 -04:00
|
|
|
|
2001-06-24 04:09:10 -04:00
|
|
|
}
|
2001-06-24 02:47:54 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
meta_window_place (MetaWindow *window,
|
|
|
|
MetaFrameGeometry *fgeom,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int *new_x,
|
|
|
|
int *new_y)
|
|
|
|
{
|
2001-06-24 04:09:10 -04:00
|
|
|
GList *windows;
|
|
|
|
|
2001-06-24 02:47:54 -04:00
|
|
|
/* frame member variables should NEVER be used in here, only
|
2001-06-24 04:09:10 -04:00
|
|
|
* MetaFrameGeometry. But remember fgeom == NULL
|
|
|
|
* for undecorated windows.
|
2001-06-24 02:47:54 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
meta_verbose ("Placing window %s\n", window->desc);
|
|
|
|
|
|
|
|
if (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;
|
|
|
|
|
2001-06-24 04:09:10 -04:00
|
|
|
if (fgeom)
|
|
|
|
y += fgeom->top_height;
|
2001-06-24 02:47:54 -04:00
|
|
|
|
|
|
|
meta_verbose ("Centered window %s over transient parent\n",
|
|
|
|
window->desc);
|
|
|
|
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (window->type == META_WINDOW_DIALOG ||
|
|
|
|
window->type == META_WINDOW_MODAL_DIALOG)
|
|
|
|
{
|
|
|
|
/* Center on screen */
|
|
|
|
int w, h;
|
|
|
|
|
2001-07-03 22:10:54 -04:00
|
|
|
/* I think whole screen will look nicer than workarea */
|
2001-07-04 00:33:31 -04:00
|
|
|
w = window->screen->width;
|
|
|
|
h = window->screen->height;
|
2001-06-24 02:47:54 -04:00
|
|
|
|
|
|
|
x = (w - window->rect.width) / 2;
|
|
|
|
y = (y - window->rect.height) / 2;
|
|
|
|
|
|
|
|
meta_verbose ("Centered window %s on screen\n",
|
|
|
|
window->desc);
|
|
|
|
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2001-06-24 04:09:10 -04:00
|
|
|
/* 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)
|
|
|
|
*/
|
|
|
|
windows = NULL;
|
|
|
|
{
|
|
|
|
GSList *all_windows;
|
|
|
|
GSList *tmp;
|
|
|
|
|
|
|
|
all_windows = meta_display_list_windows (window->display);
|
|
|
|
|
|
|
|
tmp = all_windows;
|
|
|
|
while (tmp != NULL)
|
|
|
|
{
|
|
|
|
MetaWindow *w = tmp->data;
|
|
|
|
|
|
|
|
if (!w->minimized &&
|
|
|
|
w != window &&
|
|
|
|
meta_window_shares_some_workspace (window, w))
|
|
|
|
windows = g_list_prepend (windows, w);
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-24 02:47:54 -04:00
|
|
|
/* "Origin" placement algorithm */
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
|
2001-06-24 04:09:10 -04:00
|
|
|
/* Cascade */
|
|
|
|
find_next_cascade (window, fgeom, windows, x, y, &x, &y);
|
|
|
|
|
|
|
|
g_list_free (windows);
|
|
|
|
|
2001-06-24 02:47:54 -04:00
|
|
|
done:
|
|
|
|
*new_x = x;
|
|
|
|
*new_y = y;
|
|
|
|
}
|
2001-07-12 01:53:56 -04:00
|
|
|
|
|
|
|
|
|
|
|
/* 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_on_same_workspace (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 (!w->minimized &&
|
|
|
|
w != window &&
|
|
|
|
meta_workspace_contains_window (window->screen->active_workspace,
|
|
|
|
w))
|
|
|
|
{
|
|
|
|
windows = g_slist_prepend (windows, w);
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n_windows)
|
|
|
|
*n_windows = i;
|
|
|
|
|
|
|
|
return windows;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 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 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;
|
|
|
|
}
|
|
|
|
|
2001-07-25 23:58:24 -04:00
|
|
|
static void
|
|
|
|
get_vertical_edges (MetaWindow *window,
|
|
|
|
int **edges_p,
|
|
|
|
int *n_edges_p)
|
2001-07-12 01:53:56 -04:00
|
|
|
{
|
|
|
|
GSList *windows;
|
|
|
|
GSList *tmp;
|
|
|
|
int n_windows;
|
|
|
|
int *edges;
|
|
|
|
int i;
|
|
|
|
int n_edges;
|
|
|
|
MetaRectangle rect;
|
|
|
|
|
|
|
|
windows = get_windows_on_same_workspace (window, &n_windows);
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
n_edges = n_windows * 2 + 4; /* 4 = workspace/screen edges */
|
|
|
|
edges = g_new (int, n_edges);
|
|
|
|
|
|
|
|
/* workspace/screen edges */
|
|
|
|
edges[i] = window->screen->active_workspace->workarea.x;
|
|
|
|
++i;
|
|
|
|
edges[i] =
|
|
|
|
window->screen->active_workspace->workarea.x +
|
|
|
|
window->screen->active_workspace->workarea.width;
|
|
|
|
++i;
|
|
|
|
edges[i] = 0;
|
|
|
|
++i;
|
|
|
|
edges[i] = window->screen->width;
|
|
|
|
++i;
|
|
|
|
|
|
|
|
g_assert (i == 4);
|
|
|
|
|
|
|
|
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))
|
|
|
|
{
|
|
|
|
window_get_edges (w, &edges[i], &edges[i+1], NULL, NULL);
|
|
|
|
i += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
n_edges = i;
|
|
|
|
|
|
|
|
g_slist_free (windows);
|
|
|
|
|
|
|
|
/* Sort */
|
|
|
|
qsort (edges, n_edges, sizeof (int), intcmp);
|
|
|
|
|
2001-07-25 23:58:24 -04:00
|
|
|
*edges_p = edges;
|
|
|
|
*n_edges_p = n_edges;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
get_horizontal_edges (MetaWindow *window,
|
|
|
|
int **edges_p,
|
|
|
|
int *n_edges_p)
|
|
|
|
{
|
|
|
|
GSList *windows;
|
|
|
|
GSList *tmp;
|
|
|
|
int n_windows;
|
|
|
|
int *edges;
|
|
|
|
int i;
|
|
|
|
int n_edges;
|
|
|
|
MetaRectangle rect;
|
|
|
|
|
|
|
|
windows = get_windows_on_same_workspace (window, &n_windows);
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
n_edges = n_windows * 2 + 4; /* 4 = workspace/screen edges */
|
|
|
|
edges = g_new (int, n_edges);
|
|
|
|
|
|
|
|
/* workspace/screen edges */
|
|
|
|
edges[i] = window->screen->active_workspace->workarea.y;
|
|
|
|
++i;
|
|
|
|
edges[i] =
|
|
|
|
window->screen->active_workspace->workarea.y +
|
|
|
|
window->screen->active_workspace->workarea.height;
|
|
|
|
++i;
|
|
|
|
edges[i] = 0;
|
|
|
|
++i;
|
|
|
|
edges[i] = window->screen->height;
|
|
|
|
++i;
|
|
|
|
|
|
|
|
g_assert (i == 4);
|
|
|
|
|
|
|
|
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))
|
|
|
|
{
|
|
|
|
window_get_edges (w, NULL, NULL, &edges[i], &edges[i+1]);
|
|
|
|
i += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = tmp->next;
|
|
|
|
}
|
|
|
|
n_edges = i;
|
|
|
|
|
|
|
|
g_slist_free (windows);
|
|
|
|
|
|
|
|
/* Sort */
|
|
|
|
qsort (edges, n_edges, sizeof (int), intcmp);
|
|
|
|
|
|
|
|
*edges_p = edges;
|
|
|
|
*n_edges_p = n_edges;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
meta_window_find_next_vertical_edge (MetaWindow *window,
|
|
|
|
gboolean right)
|
|
|
|
{
|
|
|
|
int left_edge, right_edge;
|
|
|
|
int *edges;
|
|
|
|
int i;
|
|
|
|
int n_edges;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
get_vertical_edges (window, &edges, &n_edges);
|
|
|
|
|
2001-07-12 01:53:56 -04:00
|
|
|
/* Find next */
|
|
|
|
meta_window_get_position (window, &retval, NULL);
|
|
|
|
|
|
|
|
window_get_edges (window, &left_edge, &right_edge, NULL, NULL);
|
|
|
|
|
|
|
|
if (right)
|
|
|
|
{
|
|
|
|
i = 0;
|
|
|
|
while (i < n_edges)
|
|
|
|
{
|
|
|
|
if (edges[i] > right_edge)
|
|
|
|
{
|
|
|
|
/* This is the one we want, snap right
|
|
|
|
* edge of window to edges[i]
|
|
|
|
*/
|
|
|
|
retval = edges[i];
|
|
|
|
if (window->frame)
|
|
|
|
{
|
|
|
|
retval -= window->frame->rect.width;
|
|
|
|
retval += window->frame->child_x;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
retval -= window->rect.width;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
i = n_edges;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
--i;
|
|
|
|
|
|
|
|
if (edges[i] < left_edge)
|
|
|
|
{
|
|
|
|
/* This is the one we want */
|
|
|
|
retval = edges[i];
|
|
|
|
if (window->frame)
|
|
|
|
retval += window->frame->child_x;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (i > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (edges);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
meta_window_find_next_horizontal_edge (MetaWindow *window,
|
|
|
|
gboolean down)
|
|
|
|
{
|
|
|
|
int top_edge, bottom_edge;
|
|
|
|
int *edges;
|
|
|
|
int i;
|
|
|
|
int n_edges;
|
|
|
|
int retval;
|
|
|
|
|
2001-07-25 23:58:24 -04:00
|
|
|
get_horizontal_edges (window, &edges, &n_edges);
|
2001-07-12 01:53:56 -04:00
|
|
|
|
|
|
|
/* Find next */
|
|
|
|
meta_window_get_position (window, NULL, &retval);
|
|
|
|
|
|
|
|
window_get_edges (window, NULL, NULL, &top_edge, &bottom_edge);
|
|
|
|
|
|
|
|
if (down)
|
|
|
|
{
|
|
|
|
i = 0;
|
|
|
|
while (i < n_edges)
|
|
|
|
{
|
|
|
|
if (edges[i] > bottom_edge)
|
|
|
|
{
|
|
|
|
/* This is the one we want, snap right
|
|
|
|
* edge of window to edges[i]
|
|
|
|
*/
|
|
|
|
retval = edges[i];
|
|
|
|
if (window->frame)
|
|
|
|
{
|
|
|
|
retval -= window->frame->rect.height;
|
|
|
|
retval += window->frame->child_y;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
retval -= window->rect.height;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
i = n_edges;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
--i;
|
|
|
|
|
|
|
|
if (edges[i] < top_edge)
|
|
|
|
{
|
|
|
|
/* This is the one we want */
|
|
|
|
retval = edges[i];
|
|
|
|
if (window->frame)
|
|
|
|
retval += window->frame->child_y;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (i > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (edges);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2001-07-25 23:58:24 -04:00
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (window->frame)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (window->frame)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|