brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "Add "size states" which save window size information"

Browse Source 
This reverts commit 2c7ef2269f.
This commit is contained in:
Florian Müllner 2016-01-10 15:16:09 +01:00
parent 40c3c69435
commit 3aea8d8ce6
5 changed files with 140 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/core/window-private.h
View File

@ -88,20 +88,6 @@ typedef enum
META_MOVE_RESIZE_RESULT_FRAME_SHAPE_CHANGED = 1 << 2, META_MOVE_RESIZE_RESULT_FRAME_SHAPE_CHANGED = 1 << 2,
} MetaMoveResizeResultFlags; } MetaMoveResizeResultFlags;
/* This contains all the "state" needed for a certain size configuration.
* We have three of these size configurations: normal, tiled, and
* maximized. The idea here is that if the user tiles a normal window,
* then maximizes it, we should, upon unmaximizing and untiling the window,
* return to a normal state. We need a way of storing this information
* while maximized, so we use this structure. */
struct _MetaWindowSizeState
{
guint maximized_horizontally : 1;
guint maximized_vertically : 1;
MetaRectangle rect;
};
typedef struct _MetaWindowSizeState MetaWindowSizeState;
struct _MetaWindow struct _MetaWindow
{ {
GObject parent_instance; GObject parent_instance;
@ -407,6 +393,9 @@ struct _MetaWindow
/* The current window geometry of the window. */ /* The current window geometry of the window. */
MetaRectangle rect; MetaRectangle rect;
/* The geometry to restore when we unmaximize. */
MetaRectangle saved_rect;
/* This is the geometry the window will have if no constraints have /* This is the geometry the window will have if no constraints have
* applied. We use this whenever we are moving implicitly (for example, * applied. We use this whenever we are moving implicitly (for example,
* if we move to avoid a panel, we can snap back to this position if * if we move to avoid a panel, we can snap back to this position if
@ -446,12 +435,6 @@ struct _MetaWindow
/* Bypass compositor hints */ /* Bypass compositor hints */
guint bypass_compositor; guint bypass_compositor;
/* This is where we store data while in another state. The information
* above in MetaWindow is always the current state of the window. */
struct {
MetaWindowSizeState normal, maximized;
} size_states;
}; };
struct _MetaWindowClass struct _MetaWindowClass

273
src/core/window.c
View File

@ -89,6 +89,8 @@ static void meta_window_force_placement (MetaWindow *window);
static void meta_window_show (MetaWindow *window); static void meta_window_show (MetaWindow *window);
static void meta_window_hide (MetaWindow *window); static void meta_window_hide (MetaWindow *window);
static void meta_window_save_rect (MetaWindow *window);
static void ensure_mru_position_after (MetaWindow *window, static void ensure_mru_position_after (MetaWindow *window,
MetaWindow *after_this_one); MetaWindow *after_this_one);
@ -870,7 +872,7 @@ _meta_window_shared_new (MetaDisplay *display,
meta_set_normal_hints (window, NULL); meta_set_normal_hints (window, NULL);
/* And this is our unmaximized size */ /* And this is our unmaximized size */
window->size_states.normal.rect = window->rect; window->saved_rect = window->rect;
window->unconstrained_rect = window->rect; window->unconstrained_rect = window->rect;
window->depth = attrs->depth; window->depth = attrs->depth;
@ -2604,23 +2606,23 @@ ensure_size_hints_satisfied (MetaRectangle *rect,
rect->height += ((minh - rect->height)/hinc + 1)*hinc; rect->height += ((minh - rect->height)/hinc + 1)*hinc;
} }
static inline MetaWindowSizeState *
get_current_size_state (MetaWindow *window)
{
if (META_WINDOW_MAXIMIZED (window))
return &window->size_states.maximized;
else
return &window->size_states.normal;
}
static void static void
save_size_state (MetaWindow *window, meta_window_save_rect (MetaWindow *window)
MetaWindowSizeState *size_state,
MetaRectangle *saved_rect)
{ {
size_state->rect = *saved_rect; if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen))
size_state->maximized_horizontally = window->maximized_horizontally; {
size_state->maximized_vertically = window->maximized_vertically; /* save size/pos as appropriate args for move_resize */
if (!window->maximized_horizontally)
{
window->saved_rect.x = window->rect.x;
window->saved_rect.width = window->rect.width;
}
if (!window->maximized_vertically)
{
window->saved_rect.y = window->rect.y;
window->saved_rect.height = window->rect.height;
}
}
} }
void void
@ -2641,11 +2643,10 @@ meta_window_maximize_internal (MetaWindow *window,
maximize_horizontally ? " horizontally" : maximize_horizontally ? " horizontally" :
maximize_vertically ? " vertically" : "BUGGGGG"); maximize_vertically ? " vertically" : "BUGGGGG");
if (!saved_rect) if (saved_rect != NULL)
saved_rect = &window->rect; window->saved_rect = *saved_rect;
else
MetaWindowSizeState *size_state = get_current_size_state (window); meta_window_save_rect (window);
save_size_state (window, size_state, saved_rect);
window->maximized_horizontally = window->maximized_horizontally =
window->maximized_horizontally || maximize_horizontally; window->maximized_horizontally || maximize_horizontally;
@ -2923,7 +2924,7 @@ unmaximize_window_before_freeing (MetaWindow *window)
if (window->withdrawn) /* See bug #137185 */ if (window->withdrawn) /* See bug #137185 */
{ {
window->rect = window->size_states.normal.rect; window->rect = window->saved_rect;
set_net_wm_state (window); set_net_wm_state (window);
} }
else if (window->screen->closing) /* See bug #358042 */ else if (window->screen->closing) /* See bug #358042 */
@ -2936,83 +2937,19 @@ unmaximize_window_before_freeing (MetaWindow *window)
* before closing it. */ * before closing it. */
meta_window_move_resize_frame (window, meta_window_move_resize_frame (window,
FALSE, FALSE,
window->size_states.normal.rect.x, window->saved_rect.x,
window->size_states.normal.rect.y, window->saved_rect.y,
window->size_states.normal.rect.width, window->saved_rect.width,
window->size_states.normal.rect.height); window->saved_rect.height);
} }
} }
static void
meta_window_unmaximize_internal (MetaWindow *window,
MetaWindowSizeState *size_state)
{
MetaRectangle old_frame_rect, old_buffer_rect, target_rect;
g_return_if_fail (!window->override_redirect);
meta_window_get_frame_rect (window, &old_frame_rect);
meta_window_get_buffer_rect (window, &old_buffer_rect);
window->maximized_horizontally = size_state->maximized_horizontally;
window->maximized_vertically = size_state->maximized_vertically;
/* recalc_features() will eventually clear the cached frame
* extents, but we need the correct frame extents in the code below,
* so invalidate the old frame extents manually up front.
*/
meta_window_frame_size_changed (window);
target_rect = size_state->rect;
/* Window's size hints may have changed while maximized, making
* saved_rect invalid. #329152
*/
meta_window_frame_rect_to_client_rect (window, &target_rect, &target_rect);
ensure_size_hints_satisfied (&target_rect, &window->size_hints);
meta_window_client_rect_to_frame_rect (window, &target_rect, &target_rect);
meta_window_move_resize_internal (window,
(META_MOVE_RESIZE_MOVE_ACTION |
META_MOVE_RESIZE_RESIZE_ACTION |
META_MOVE_RESIZE_STATE_CHANGED |
META_MOVE_RESIZE_DONT_SYNC_COMPOSITOR),
NorthWestGravity,
target_rect);
meta_compositor_size_change_window (window->display->compositor, window,
META_SIZE_CHANGE_UNMAXIMIZE,
&old_frame_rect, &old_buffer_rect);
/* When we unmaximize, if we're doing a mouse move also we could
* get the window suddenly jumping to the upper left corner of
* the workspace, since that's where it was when the grab op
* started. So we need to update the grab state. We have to do
* it after the actual operation, as the window may have been moved
* by constraints.
*/
if (meta_grab_op_is_moving (window->display->grab_op) &&
window->display->grab_window == window)
{
window->display->grab_anchor_window_pos = window->unconstrained_rect;
}
meta_window_recalc_features (window);
set_net_wm_state (window);
if (!window->monitor->in_fullscreen)
meta_screen_queue_check_fullscreen (window->screen);
g_object_freeze_notify (G_OBJECT (window));
g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_MAXIMIZED_HORIZONTALLY]);
g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_MAXIMIZED_VERTICALLY]);
g_object_thaw_notify (G_OBJECT (window));
}
void void
meta_window_unmaximize (MetaWindow *window, meta_window_unmaximize (MetaWindow *window,
MetaMaximizeFlags directions) MetaMaximizeFlags directions)
{ {
gboolean unmaximize_horizontally, unmaximize_vertically; gboolean unmaximize_horizontally, unmaximize_vertically;
MetaRectangle new_rect;
g_return_if_fail (!window->override_redirect); g_return_if_fail (!window->override_redirect);
@ -3021,35 +2958,66 @@ meta_window_unmaximize (MetaWindow *window,
unmaximize_vertically = directions & META_MAXIMIZE_VERTICAL; unmaximize_vertically = directions & META_MAXIMIZE_VERTICAL;
g_assert (unmaximize_horizontally || unmaximize_vertically); g_assert (unmaximize_horizontally || unmaximize_vertically);
MetaWindowSizeState *size_state; /* Only do something if the window isn't already maximized in the
size_state = &window->size_states.normal; * given direction(s).
*/
/* Special-case unmaximizing both directions to restoring the if ((unmaximize_horizontally && window->maximized_horizontally) ||
* last state. This makes the unmaximize buttons go back to the (unmaximize_vertically && window->maximized_vertically))
* tiled state... */
if (META_WINDOW_MAXIMIZED (window) && directions == META_MAXIMIZE_BOTH)
{ {
meta_window_unmaximize_internal (window, size_state);
}
else if ((unmaximize_horizontally && window->maximized_horizontally) ||
(unmaximize_vertically && window->maximized_vertically))
{
MetaWindowSizeState new_size_state;
MetaRectangle *desired_rect; MetaRectangle *desired_rect;
MetaRectangle target_rect; MetaRectangle target_rect;
MetaRectangle work_area; MetaRectangle work_area;
MetaRectangle old_frame_rect, old_buffer_rect;
meta_window_get_work_area_for_monitor (window, window->monitor->number, &work_area); meta_window_get_work_area_for_monitor (window, window->monitor->number, &work_area);
meta_window_get_frame_rect (window, &old_frame_rect);
meta_window_get_buffer_rect (window, &old_buffer_rect);
new_size_state.maximized_horizontally = window->maximized_horizontally && !unmaximize_horizontally; meta_topic (META_DEBUG_WINDOW_OPS,
new_size_state.maximized_vertically = window->maximized_vertically && !unmaximize_vertically; "Unmaximizing %s%s\n",
window->desc,
unmaximize_horizontally && unmaximize_vertically ? "" :
unmaximize_horizontally ? " horizontally" :
unmaximize_vertically ? " vertically" : "BUGGGGG");
window->maximized_horizontally =
window->maximized_horizontally && !unmaximize_horizontally;
window->maximized_vertically =
window->maximized_vertically && !unmaximize_vertically;
/* recalc_features() will eventually clear the cached frame
* extents, but we need the correct frame extents in the code below,
* so invalidate the old frame extents manually up front.
*/
meta_window_frame_size_changed (window);
desired_rect = &window->saved_rect;
/* Unmaximize to the saved_rect position in the direction(s) /* Unmaximize to the saved_rect position in the direction(s)
* being unmaximized. * being unmaximized.
*/ */
target_rect = window->rect; target_rect = old_frame_rect;
desired_rect = &size_state->rect; /* Avoid unmaximizing to "almost maximized" size when the previous size
* is greater then 80% of the work area use MAX_UNMAXIMIZED_WINDOW_AREA of the work area as upper limit
* while maintaining the aspect ratio.
*/
if (unmaximize_horizontally && unmaximize_vertically &&
desired_rect->width * desired_rect->height > work_area.width * work_area.height * MAX_UNMAXIMIZED_WINDOW_AREA)
{
if (desired_rect->width > desired_rect->height)
{
float aspect = (float)desired_rect->height / (float)desired_rect->width;
desired_rect->width = MAX (work_area.width * sqrt (MAX_UNMAXIMIZED_WINDOW_AREA), window->size_hints.min_width);
desired_rect->height = MAX (desired_rect->width * aspect, window->size_hints.min_height);
}
else
{
float aspect = (float)desired_rect->width / (float)desired_rect->height;
desired_rect->height = MAX (work_area.height * sqrt (MAX_UNMAXIMIZED_WINDOW_AREA), window->size_hints.min_height);
desired_rect->width = MAX (desired_rect->height * aspect, window->size_hints.min_width);
}
}
if (unmaximize_horizontally) if (unmaximize_horizontally)
{ {
@ -3062,31 +3030,49 @@ meta_window_unmaximize (MetaWindow *window,
target_rect.height = desired_rect->height; target_rect.height = desired_rect->height;
} }
/* Avoid unmaximizing to "almost maximized" size when the previous size /* Window's size hints may have changed while maximized, making
* is greater then 80% of the work area use MAX_UNMAXIMIZED_WINDOW_AREA of the work area as upper limit * saved_rect invalid. #329152
* while maintaining the aspect ratio.
*/ */
if (unmaximize_horizontally && unmaximize_vertically && meta_window_frame_rect_to_client_rect (window, &target_rect, &target_rect);
desired_rect->width * desired_rect->height > work_area.width * work_area.height * MAX_UNMAXIMIZED_WINDOW_AREA) ensure_size_hints_satisfied (&target_rect, &window->size_hints);
meta_window_client_rect_to_frame_rect (window, &target_rect, &target_rect);
meta_window_move_resize_internal (window,
(META_MOVE_RESIZE_MOVE_ACTION |
META_MOVE_RESIZE_RESIZE_ACTION |
META_MOVE_RESIZE_STATE_CHANGED |
META_MOVE_RESIZE_DONT_SYNC_COMPOSITOR),
NorthWestGravity,
target_rect);
meta_window_get_frame_rect (window, &new_rect);
meta_compositor_size_change_window (window->display->compositor, window,
META_SIZE_CHANGE_UNMAXIMIZE,
&old_frame_rect, &old_buffer_rect);
/* When we unmaximize, if we're doing a mouse move also we could
* get the window suddenly jumping to the upper left corner of
* the workspace, since that's where it was when the grab op
* started. So we need to update the grab state. We have to do
* it after the actual operation, as the window may have been moved
* by constraints.
*/
if (meta_grab_op_is_moving (window->display->grab_op) &&
window->display->grab_window == window)
{ {
if (desired_rect->width > desired_rect->height) window->display->grab_anchor_window_pos = window->unconstrained_rect;
{
float aspect = (float)desired_rect->height / (float)desired_rect->width;
target_rect.width = MAX (work_area.width * sqrt (MAX_UNMAXIMIZED_WINDOW_AREA), window->size_hints.min_width);
target_rect.height = MAX (desired_rect->width * aspect, window->size_hints.min_height);
}
else
{
float aspect = (float)desired_rect->width / (float)desired_rect->height;
target_rect.height = MAX (work_area.height * sqrt (MAX_UNMAXIMIZED_WINDOW_AREA), window->size_hints.min_height);
target_rect.width = MAX (desired_rect->height * aspect, window->size_hints.min_width);
}
} }
new_size_state.rect = target_rect; meta_window_recalc_features (window);
set_net_wm_state (window);
meta_window_unmaximize_internal (window, &new_size_state); if (!window->monitor->in_fullscreen)
meta_screen_queue_check_fullscreen (window->screen);
} }
g_object_freeze_notify (G_OBJECT (window));
g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_MAXIMIZED_HORIZONTALLY]);
g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_MAXIMIZED_VERTICALLY]);
g_object_thaw_notify (G_OBJECT (window));
} }
void void
@ -3140,8 +3126,7 @@ meta_window_make_fullscreen_internal (MetaWindow *window)
meta_window_unshade (window, timestamp); meta_window_unshade (window, timestamp);
} }
MetaWindowSizeState *size_state = get_current_size_state (window); meta_window_save_rect (window);
save_size_state (window, size_state, &window->rect);
window->fullscreen = TRUE; window->fullscreen = TRUE;
@ -3201,9 +3186,7 @@ meta_window_unmake_fullscreen (MetaWindow *window)
"Unfullscreening %s\n", window->desc); "Unfullscreening %s\n", window->desc);
window->fullscreen = FALSE; window->fullscreen = FALSE;
target_rect = window->saved_rect;
MetaWindowSizeState *size_state = get_current_size_state (window);
target_rect = size_state->rect;
meta_window_frame_size_changed (window); meta_window_frame_size_changed (window);
meta_window_get_frame_rect (window, &old_frame_rect); meta_window_get_frame_rect (window, &old_frame_rect);
@ -3753,8 +3736,8 @@ meta_window_move_between_rects (MetaWindow *window,
window->unconstrained_rect.x = new_area->x + rel_x * scale_x; window->unconstrained_rect.x = new_area->x + rel_x * scale_x;
window->unconstrained_rect.y = new_area->y + rel_y * scale_y; window->unconstrained_rect.y = new_area->y + rel_y * scale_y;
window->size_states.normal.rect.x = window->unconstrained_rect.x; window->saved_rect.x = window->unconstrained_rect.x;
window->size_states.normal.rect.y = window->unconstrained_rect.y; window->saved_rect.y = window->unconstrained_rect.y;
meta_window_move_resize_now (window); meta_window_move_resize_now (window);
} }
@ -5549,7 +5532,7 @@ update_move (MetaWindow *window,
((double)(x - display->grab_initial_window_pos.x)) / ((double)(x - display->grab_initial_window_pos.x)) /
((double)display->grab_initial_window_pos.width); ((double)display->grab_initial_window_pos.width);
display->grab_initial_window_pos.x = x - window->size_states.normal.rect.width * prop; display->grab_initial_window_pos.x = x - window->saved_rect.width * prop;
/* If we started dragging the window from above the top of the window, /* If we started dragging the window from above the top of the window,
* pretend like we started dragging from the middle of the titlebar * pretend like we started dragging from the middle of the titlebar
@ -5561,10 +5544,10 @@ update_move (MetaWindow *window,
display->grab_anchor_root_y = display->grab_initial_window_pos.y + titlebar_rect.height / 2; display->grab_anchor_root_y = display->grab_initial_window_pos.y + titlebar_rect.height / 2;
} }
window->size_states.normal.rect.x = display->grab_initial_window_pos.x; window->saved_rect.x = display->grab_initial_window_pos.x;
window->size_states.normal.rect.y = display->grab_initial_window_pos.y; window->saved_rect.y = display->grab_initial_window_pos.y;
meta_window_unmaximize_internal (window, &window->size_states.normal); meta_window_unmaximize (window, META_MAXIMIZE_BOTH);
return; return;
} }
@ -5594,17 +5577,17 @@ update_move (MetaWindow *window,
*/ */
if (wmonitor->number != monitor) if (wmonitor->number != monitor)
{ {
window->size_states.normal.rect.x = work_area.x; window->saved_rect.x = work_area.x;
window->size_states.normal.rect.y = work_area.y; window->saved_rect.y = work_area.y;
if (window->frame) if (window->frame)
{ {
window->size_states.normal.rect.x += window->frame->child_x; window->saved_rect.x += window->frame->child_x;
window->size_states.normal.rect.y += window->frame->child_y; window->saved_rect.y += window->frame->child_y;
} }
window->unconstrained_rect.x = window->size_states.normal.rect.x; window->unconstrained_rect.x = window->saved_rect.x;
window->unconstrained_rect.y = window->size_states.normal.rect.y; window->unconstrained_rect.y = window->saved_rect.y;
meta_window_unmaximize (window, META_MAXIMIZE_BOTH); meta_window_unmaximize (window, META_MAXIMIZE_BOTH);

4
src/wayland/meta-window-wayland.c
View File

@ -362,9 +362,7 @@ meta_window_wayland_main_monitor_changed (MetaWindow *window,
/* Window size. */ /* Window size. */
scale_rect_size (&window->rect, scale_factor); scale_rect_size (&window->rect, scale_factor);
scale_rect_size (&window->unconstrained_rect, scale_factor); scale_rect_size (&window->unconstrained_rect, scale_factor);
scale_rect_size (&window->size_states.normal.rect, scale_factor); scale_rect_size (&window->saved_rect, scale_factor);
scale_rect_size (&window->size_states.tiled.rect, scale_factor);
scale_rect_size (&window->size_states.maximized.rect, scale_factor);
/* Window geometry offset (XXX: Need a better place, see /* Window geometry offset (XXX: Need a better place, see
* meta_window_wayland_move_resize). */ * meta_window_wayland_move_resize). */

8
src/x11/session.c
View File

@ -965,10 +965,10 @@ save_state (void)
{ {
fprintf (outfile, fprintf (outfile,
" <maximized saved_x=\"%d\" saved_y=\"%d\" saved_width=\"%d\" saved_height=\"%d\"/>\n", " <maximized saved_x=\"%d\" saved_y=\"%d\" saved_width=\"%d\" saved_height=\"%d\"/>\n",
window->size_states.normal.rect.x, window->saved_rect.x,
window->size_states.normal.rect.y, window->saved_rect.y,
window->size_states.normal.rect.width, window->saved_rect.width,
window->size_states.normal.rect.height); window->saved_rect.height);
} }
/* Gravity */ /* Gravity */

8
src/x11/window-x11.c
View File

@ -413,10 +413,10 @@ meta_window_apply_session_info (MetaWindow *window,
info->saved_rect.height, info->saved_rect.height,
window->desc); window->desc);
window->size_states.normal.rect.x = info->saved_rect.x; window->saved_rect.x = info->saved_rect.x;
window->size_states.normal.rect.y = info->saved_rect.y; window->saved_rect.y = info->saved_rect.y;
window->size_states.normal.rect.width = info->saved_rect.width; window->saved_rect.width = info->saved_rect.width;
window->size_states.normal.rect.height = info->saved_rect.height; window->saved_rect.height = info->saved_rect.height;
} }
} }
} }