[mutter] Revert "Add "size states" which save window size information"

[Florian Müllner <fmuellner src gnome org>]

commit 3aea8d8ce6c3d9fd2f2f6e1553103a11ef13a704
Author: Florian Müllner <fmuellner gnome org>
Date:   Sun Jan 10 15:16:09 2016 +0100

    Revert "Add "size states" which save window size information"
    
    This reverts commit 2c7ef2269fc19eaef1769632a2b92f06119cc413.

 src/core/window-private.h         |   23 +---
 src/core/window.c                 |  269 +++++++++++++++++--------------------
 src/wayland/meta-window-wayland.c |    4 +-
 src/x11/session.c                 |    8 +-
 src/x11/window-x11.c              |    8 +-
 5 files changed, 138 insertions(+), 174 deletions(-)
---
diff --git a/src/core/window-private.h b/src/core/window-private.h
index 7a2e5d8..d76aed8 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 34a3625..3c458b0 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,46 +2958,45 @@ 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)
-    {
-      meta_window_unmaximize_internal (window, size_state);
-    }
-  else if ((unmaximize_horizontally && window->maximized_horizontally) ||
-           (unmaximize_vertically   && window->maximized_vertically))
+  /* 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))
     {
-      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);
+
+      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);
 
-      new_size_state.maximized_horizontally = window->maximized_horizontally && !unmaximize_horizontally;
-      new_size_state.maximized_vertically = window->maximized_vertically && !unmaximize_vertically;
+      desired_rect = &window->saved_rect;
 
       /* Unmaximize to the saved_rect position in the direction(s)
        * being unmaximized.
        */
-      target_rect = window->rect;
-
-      desired_rect = &size_state->rect;
-
-      if (unmaximize_horizontally)
-        {
-          target_rect.x     = desired_rect->x;
-          target_rect.width = desired_rect->width;
-        }
-      if (unmaximize_vertically)
-        {
-          target_rect.y      = desired_rect->y;
-          target_rect.height = desired_rect->height;
-        }
+      target_rect = old_frame_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
@@ -3072,21 +3008,71 @@ meta_window_unmaximize (MetaWindow        *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);
+              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;
-              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);
+              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);
             }
         }
 
-      new_size_state.rect = target_rect;
+      if (unmaximize_horizontally)
+        {
+          target_rect.x     = desired_rect->x;
+          target_rect.width = desired_rect->width;
+        }
+      if (unmaximize_vertically)
+        {
+          target_rect.y      = desired_rect->y;
+          target_rect.height = desired_rect->height;
+        }
 
-      meta_window_unmaximize_internal (window, &new_size_state);
+      /* 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_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)
+        {
+          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
@@ -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 bcb35c9..8129cb8 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 f4e80b2..13cf764 100644
--- a/src/x11/session.c
+++ b/src/x11/session.c
@@ -965,10 +965,10 @@ save_state (void)
             {
               fprintf (outfile,
                        "    <maximized saved_x=\"%d\" saved_y=\"%d\" saved_width=\"%d\" 
saved_height=\"%d\"/>\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 f810880..99bffd7 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;
             }
        }
     }