From 3aea8d8ce6c3d9fd2f2f6e1553103a11ef13a704 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Florian=20M=C3=BCllner?= Date: Sun, 10 Jan 2016 15:16:09 +0100 Subject: [PATCH] Revert "Add "size states" which save window size information" This reverts commit 2c7ef2269fc19eaef1769632a2b92f06119cc413. --- src/core/window-private.h | 23 +-- src/core/window.c | 273 ++++++++++++++---------------- src/wayland/meta-window-wayland.c | 4 +- src/x11/session.c | 8 +- src/x11/window-x11.c | 8 +- 5 files changed, 140 insertions(+), 176 deletions(-) diff --git a/src/core/window-private.h b/src/core/window-private.h index 7a2e5d890..d76aed897 100644 --- a/src/core/window-private.h +++ b/src/core/window-private.h @@ -88,20 +88,6 @@ typedef enum META_MOVE_RESIZE_RESULT_FRAME_SHAPE_CHANGED = 1 << 2, } 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 { GObject parent_instance; @@ -407,6 +393,9 @@ struct _MetaWindow /* The current window geometry of the window. */ MetaRectangle rect; + /* The geometry to restore when we unmaximize. */ + MetaRectangle saved_rect; + /* This is the geometry the window will have if no constraints have * 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 @@ -446,12 +435,6 @@ struct _MetaWindow /* Bypass compositor hints */ 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 diff --git a/src/core/window.c b/src/core/window.c index 34a36259f..3c458b074 100644 --- a/src/core/window.c +++ b/src/core/window.c @@ -89,6 +89,8 @@ static void meta_window_force_placement (MetaWindow *window); static void meta_window_show (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, MetaWindow *after_this_one); @@ -870,7 +872,7 @@ _meta_window_shared_new (MetaDisplay *display, meta_set_normal_hints (window, NULL); /* And this is our unmaximized size */ - window->size_states.normal.rect = window->rect; + window->saved_rect = window->rect; window->unconstrained_rect = window->rect; window->depth = attrs->depth; @@ -2604,23 +2606,23 @@ ensure_size_hints_satisfied (MetaRectangle *rect, 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 -save_size_state (MetaWindow *window, - MetaWindowSizeState *size_state, - MetaRectangle *saved_rect) +meta_window_save_rect (MetaWindow *window) { - size_state->rect = *saved_rect; - size_state->maximized_horizontally = window->maximized_horizontally; - size_state->maximized_vertically = window->maximized_vertically; + if (!(META_WINDOW_MAXIMIZED (window) || window->fullscreen)) + { + /* 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 @@ -2641,11 +2643,10 @@ meta_window_maximize_internal (MetaWindow *window, maximize_horizontally ? " horizontally" : maximize_vertically ? " vertically" : "BUGGGGG"); - if (!saved_rect) - saved_rect = &window->rect; - - MetaWindowSizeState *size_state = get_current_size_state (window); - save_size_state (window, size_state, saved_rect); + if (saved_rect != NULL) + window->saved_rect = *saved_rect; + else + meta_window_save_rect (window); window->maximized_horizontally = window->maximized_horizontally || maximize_horizontally; @@ -2923,7 +2924,7 @@ unmaximize_window_before_freeing (MetaWindow *window) if (window->withdrawn) /* See bug #137185 */ { - window->rect = window->size_states.normal.rect; + window->rect = window->saved_rect; set_net_wm_state (window); } else if (window->screen->closing) /* See bug #358042 */ @@ -2936,83 +2937,19 @@ unmaximize_window_before_freeing (MetaWindow *window) * before closing it. */ meta_window_move_resize_frame (window, FALSE, - window->size_states.normal.rect.x, - window->size_states.normal.rect.y, - window->size_states.normal.rect.width, - window->size_states.normal.rect.height); + window->saved_rect.x, + window->saved_rect.y, + window->saved_rect.width, + 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 meta_window_unmaximize (MetaWindow *window, MetaMaximizeFlags directions) { gboolean unmaximize_horizontally, unmaximize_vertically; + MetaRectangle new_rect; g_return_if_fail (!window->override_redirect); @@ -3021,35 +2958,66 @@ meta_window_unmaximize (MetaWindow *window, unmaximize_vertically = directions & META_MAXIMIZE_VERTICAL; g_assert (unmaximize_horizontally || unmaximize_vertically); - MetaWindowSizeState *size_state; - size_state = &window->size_states.normal; - - /* Special-case unmaximizing both directions to restoring the - * last state. This makes the unmaximize buttons go back to the - * tiled state... */ - if (META_WINDOW_MAXIMIZED (window) && directions == META_MAXIMIZE_BOTH) + /* Only do something if the window isn't already maximized in the + * given direction(s). + */ + if ((unmaximize_horizontally && window->maximized_horizontally) || + (unmaximize_vertically && window->maximized_vertically)) { - 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 target_rect; 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_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; - new_size_state.maximized_vertically = window->maximized_vertically && !unmaximize_vertically; + meta_topic (META_DEBUG_WINDOW_OPS, + "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) * 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) { @@ -3062,31 +3030,49 @@ meta_window_unmaximize (MetaWindow *window, target_rect.height = desired_rect->height; } - /* 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. + /* Window's size hints may have changed while maximized, making + * saved_rect invalid. #329152 */ - if (unmaximize_horizontally && unmaximize_vertically && - desired_rect->width * desired_rect->height > work_area.width * work_area.height * MAX_UNMAXIMIZED_WINDOW_AREA) + 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_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) - { - 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); - } + window->display->grab_anchor_window_pos = window->unconstrained_rect; } - new_size_state.rect = target_rect; - - meta_window_unmaximize_internal (window, &new_size_state); + 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 @@ -3140,8 +3126,7 @@ meta_window_make_fullscreen_internal (MetaWindow *window) meta_window_unshade (window, timestamp); } - MetaWindowSizeState *size_state = get_current_size_state (window); - save_size_state (window, size_state, &window->rect); + meta_window_save_rect (window); window->fullscreen = TRUE; @@ -3201,9 +3186,7 @@ meta_window_unmake_fullscreen (MetaWindow *window) "Unfullscreening %s\n", window->desc); window->fullscreen = FALSE; - - MetaWindowSizeState *size_state = get_current_size_state (window); - target_rect = size_state->rect; + target_rect = window->saved_rect; meta_window_frame_size_changed (window); 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.y = new_area->y + rel_y * scale_y; - window->size_states.normal.rect.x = window->unconstrained_rect.x; - window->size_states.normal.rect.y = window->unconstrained_rect.y; + window->saved_rect.x = window->unconstrained_rect.x; + window->saved_rect.y = window->unconstrained_rect.y; meta_window_move_resize_now (window); } @@ -5549,7 +5532,7 @@ update_move (MetaWindow *window, ((double)(x - display->grab_initial_window_pos.x)) / ((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, * 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; } - window->size_states.normal.rect.x = display->grab_initial_window_pos.x; - window->size_states.normal.rect.y = display->grab_initial_window_pos.y; + window->saved_rect.x = display->grab_initial_window_pos.x; + 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; } @@ -5594,17 +5577,17 @@ update_move (MetaWindow *window, */ if (wmonitor->number != monitor) { - window->size_states.normal.rect.x = work_area.x; - window->size_states.normal.rect.y = work_area.y; + window->saved_rect.x = work_area.x; + window->saved_rect.y = work_area.y; if (window->frame) { - window->size_states.normal.rect.x += window->frame->child_x; - window->size_states.normal.rect.y += window->frame->child_y; + window->saved_rect.x += window->frame->child_x; + window->saved_rect.y += window->frame->child_y; } - window->unconstrained_rect.x = window->size_states.normal.rect.x; - window->unconstrained_rect.y = window->size_states.normal.rect.y; + window->unconstrained_rect.x = window->saved_rect.x; + window->unconstrained_rect.y = window->saved_rect.y; meta_window_unmaximize (window, META_MAXIMIZE_BOTH); diff --git a/src/wayland/meta-window-wayland.c b/src/wayland/meta-window-wayland.c index bcb35c9f5..8129cb80c 100644 --- a/src/wayland/meta-window-wayland.c +++ b/src/wayland/meta-window-wayland.c @@ -362,9 +362,7 @@ meta_window_wayland_main_monitor_changed (MetaWindow *window, /* Window size. */ scale_rect_size (&window->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->size_states.tiled.rect, scale_factor); - scale_rect_size (&window->size_states.maximized.rect, scale_factor); + scale_rect_size (&window->saved_rect, scale_factor); /* Window geometry offset (XXX: Need a better place, see * meta_window_wayland_move_resize). */ diff --git a/src/x11/session.c b/src/x11/session.c index f4e80b27d..13cf76429 100644 --- a/src/x11/session.c +++ b/src/x11/session.c @@ -965,10 +965,10 @@ save_state (void) { fprintf (outfile, " \n", - window->size_states.normal.rect.x, - window->size_states.normal.rect.y, - window->size_states.normal.rect.width, - window->size_states.normal.rect.height); + window->saved_rect.x, + window->saved_rect.y, + window->saved_rect.width, + window->saved_rect.height); } /* Gravity */ diff --git a/src/x11/window-x11.c b/src/x11/window-x11.c index f81088023..99bffd7b9 100644 --- a/src/x11/window-x11.c +++ b/src/x11/window-x11.c @@ -413,10 +413,10 @@ meta_window_apply_session_info (MetaWindow *window, info->saved_rect.height, window->desc); - window->size_states.normal.rect.x = info->saved_rect.x; - window->size_states.normal.rect.y = info->saved_rect.y; - window->size_states.normal.rect.width = info->saved_rect.width; - window->size_states.normal.rect.height = info->saved_rect.height; + window->saved_rect.x = info->saved_rect.x; + window->saved_rect.y = info->saved_rect.y; + window->saved_rect.width = info->saved_rect.width; + window->saved_rect.height = info->saved_rect.height; } } }