isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-24 17:10:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

increase the cascade threshold a bit. (find_first_fit): implement a

Browse Source 
2002-06-17  Havoc Pennington  <hp@pobox.com>

	* src/place.c (find_next_cascade): increase the cascade threshold
	a bit.
	(find_first_fit): implement a somewhat lame first fit algorithm
This commit is contained in:
Havoc Pennington 2002-06-18 03:06:07 +00:00 committed by Havoc Pennington
parent 6cda7d0b11
commit e51e7ab77a
2 changed files with 319 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2002-06-17 Havoc Pennington <hp@pobox.com>
* src/place.c (find_next_cascade): increase the cascade threshold
a bit.
(find_first_fit): implement a somewhat lame first fit algorithm
2002-06-17 Havoc Pennington <hp@pobox.com>
* src/window.c (meta_window_change_workspace): fix from Gaute

362
src/place.c
View File

@ -103,6 +103,10 @@ find_next_cascade (MetaWindow *window,
* cascade_x, cascade_y are the target position
* of NW corner of window frame.
*/
/* FIXME this is bogus because we get the current xinerama
* for the window based on its position, but we haven't
* placed it yet.
*/
meta_window_get_work_area (window, TRUE, &work_area);
cascade_x = MAX (0, work_area.x);
@ -115,13 +119,13 @@ find_next_cascade (MetaWindow *window,
*/
if (fgeom)
{
x_threshold = MAX (fgeom->left_width, 10);
y_threshold = MAX (fgeom->top_height, 10);
x_threshold = MAX (fgeom->left_width, 15);
y_threshold = MAX (fgeom->top_height, 15);
}
else
{
x_threshold = 10;
y_threshold = 10;
x_threshold = 15;
y_threshold = 15;
}
tmp = sorted;
@ -179,6 +183,201 @@ find_next_cascade (MetaWindow *window,
}
}
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 gboolean
fit_rect_in_xinerama (MetaScreen *screen,
MetaRectangle *rect)
{
int i;
int best_index;
int best_overlap;
const MetaXineramaScreenInfo *xsi;
/* Find xinerama with best fit, then
* shift rect to be entirely within it.
*/
best_overlap = -1;
best_index = -1;
i = 0;
while (i < screen->n_xinerama_infos)
{
MetaRectangle xinerama_rect;
MetaRectangle intersect;
int overlap;
xsi = &screen->xinerama_infos[i];
xinerama_rect.x = xsi->x_origin;
xinerama_rect.y = xsi->y_origin;
xinerama_rect.width = xsi->width;
xinerama_rect.height = xsi->height;
if (meta_rectangle_intersect (rect, &xinerama_rect, &intersect))
overlap = intersect.width * intersect.height;
else
overlap = 0;
if (overlap > best_overlap)
best_index = i;
++i;
}
/* some overlap had to be better than -1 */
g_assert (best_index >= 0);
xsi = &screen->xinerama_infos[best_index];
if (rect->x < xsi->x_origin)
rect->x = xsi->x_origin;
if (rect->y < xsi->y_origin)
rect->y = xsi->y_origin;
/* Now return whether we are entirely within the xinerama screen */
return
((rect->x + rect->width) < (xsi->x_origin + xsi->width)) &&
((rect->y + rect->height) < (xsi->y_origin + xsi->height));
}
/* Find the leftmost, then topmost, empty area on the workspace
* that can contain the new window.
*
@ -197,7 +396,103 @@ find_first_fit (MetaWindow *window,
int *new_x,
int *new_y)
{
/* FIXME */
/* 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 *sorted;
GList *tmp;
MetaRectangle rect;
retval = FALSE;
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;
}
sorted = g_list_copy (windows);
/* Below each window */
sorted = g_list_sort (sorted, leftmost_cmp);
sorted = g_list_sort (sorted, topmost_cmp);
tmp = 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 (fit_rect_in_xinerama (window->screen, &rect) &&
!rectangle_overlaps_some_window (&rect, 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;
}
/* To the right of each window */
sorted = g_list_sort (sorted, topmost_cmp);
sorted = g_list_sort (sorted, leftmost_cmp);
tmp = 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 (fit_rect_in_xinerama (window->screen, &rect) &&
!rectangle_overlaps_some_window (&rect, 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;
}
out:
g_list_free (sorted);
return retval;
}
static void
@ -215,6 +510,10 @@ constrain_placement (MetaWindow *window,
MetaRectangle work_area;
int nw_x, nw_y;
/* FIXME this is bogus because we get the current xinerama
* for the window based on its position, but we haven't
* placed it yet.
*/
meta_window_get_work_area (window, TRUE, &work_area);
nw_x = work_area.x;
@ -257,6 +556,8 @@ meta_window_place (MetaWindow *window,
meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
windows = NULL;
switch (window->type)
{
/* Run placement algorithm on these. */
@ -405,7 +706,6 @@ meta_window_place (MetaWindow *window,
* as placed window, may be shaded - if shaded we pretend it isn't
* for placement purposes)
*/
windows = NULL;
{
GSList *all_windows;
GSList *tmp;
@ -433,12 +733,14 @@ meta_window_place (MetaWindow *window,
x = xi->x_origin;
y = xi->y_origin;
/* Cascade */
if (find_first_fit (window, fgeom, windows, x, y, &x, &y))
goto done;
find_next_cascade (window, fgeom, windows, x, y, &x, &y);
done:
g_list_free (windows);
done:
constrain_placement (window, fgeom, x, y, &x, &y);
done_no_constraints:
@ -491,50 +793,6 @@ get_windows_on_same_workspace (MetaWindow *window,
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)