Attachment 601358 Details for Bug 844165 – https://bugzilla.gnome.org/show_bug.cgi?id=622517

[patch] https://bugzilla.gnome.org/show_bug.cgi?id=622517

Allow-breaking-out-from-maximization-during-mouse.patch (text/plain), 16.21 KB, created by Wolfgang Ulbrich on 2012-07-30 23:44:28 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Wolfgang Ulbrich

Created: 2012-07-30 23:44:28 UTC

Size: 16.21 KB

patch

obsolete

>From 339710e884cfbab810382a63fafb3cdab8ee51e9 Mon Sep 17 00:00:00 2001
>From: Owen W. Taylor <otaylor@fishsoup.net>
>Date: Wed, 23 Jun 2010 15:08:38 -0400
>Subject: [PATCH] Allow breaking out from maximization during a mouse resize
>
>A maximized window can't be resized from the screen edges (preserves
>Fitts law goodness for the application), but it's still possible
>to start a resize drag with alt-middle-button. Currently we just
>don't let the user resize the window, while showing drag feedback;
>it's more useful to let the user "break" out from the resize.
>
>This provides a fast way to get a window partially aligned with
>the screen edges - maximize, then alt-drag it out from one edge.
>
>Behavior choices in this patch:
>
> - You can drag out a window out of maximization in both directions -
>   smaller and larger. This can be potentilaly useful in multihead.
>
> - Dragging a window in only one direction unmaximizes the window
>   fully, rather than leaving it in a horizontally/vertically
>   maximized state. This is done because the horizontally/vertically
>   maximzed states don't have clear visual representation and can
>   be confusing to the user.
>
> - If you drag back to the maximized state after breaking out,
>   maximization is restored, but you can't maximize a window by
>   dragging to the full size if it didn't start out that way.
>
>A new internal function meta_window_unmaximize_with_gravity() is
>added for implementing this; it's a hybrid of
>meta_window_unmaximize() and meta_window_resize_with_gravity().
>
>https://bugzilla.gnome.org/show_bug.cgi?id=622517
>---
> src/core/display-private.h |    3 +
> src/core/display.c         |   20 +++-
> src/core/window-private.h  |    5 +
> src/core/window.c          |  224 ++++++++++++++++++++++++++++++++++++++++----
> 4 files changed, 228 insertions(+), 24 deletions(-)
>
>diff --git a/src/core/display-private.h b/src/core/display-private.h
>index 19287f3..a19d1d8 100644
>--- a/src/core/display-private.h
>+++ b/src/core/display-private.h
>@@ -170,6 +170,9 @@ struct _MetaDisplay
>   guint       grab_wireframe_active : 1;
>   guint       grab_was_cancelled : 1;    /* Only used in wireframe mode */
>   guint       grab_frame_action : 1;
>+  /* During a resize operation, the directions in which we've broken
>+   * out of the initial maximization state */
>+  guint       grab_resize_unmaximize : 2; /* MetaMaximizeFlags */
>   MetaRectangle grab_wireframe_rect;
>   MetaRectangle grab_wireframe_last_xor_rect;
>   MetaRectangle grab_initial_window_pos;
>diff --git a/src/core/display.c b/src/core/display.c
>index 4c7b4c0..2122851 100644
>--- a/src/core/display.c
>+++ b/src/core/display.c
>@@ -3353,6 +3353,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
> #endif
>   display->grab_was_cancelled = FALSE;
>   display->grab_frame_action = frame_action;
>+  display->grab_resize_unmaximize = 0;
> 
>   if (display->grab_resize_timeout_id)
>     {
>@@ -3583,11 +3584,20 @@ meta_display_end_grab_op (MetaDisplay *display,
>                               display->grab_wireframe_rect.x,
>                               display->grab_wireframe_rect.y);
>           if (meta_grab_op_is_resizing (display->grab_op))
>-            meta_window_resize_with_gravity (display->grab_window,
>-                                             TRUE,
>-                                             display->grab_wireframe_rect.width,
>-                                             display->grab_wireframe_rect.height,
>-                                             meta_resize_gravity_from_grab_op (display->grab_op));
>+            {
>+              if (display->grab_resize_unmaximize != 0)
>+                meta_window_unmaximize_with_gravity (display->grab_window,
>+                                                     display->grab_resize_unmaximize,
>+                                                     display->grab_wireframe_rect.width,
>+                                                     display->grab_wireframe_rect.height,
>+                                                     meta_resize_gravity_from_grab_op (display->grab_op));
>+              else
>+                meta_window_resize_with_gravity (display->grab_window,
>+                                                 TRUE,
>+                                                 display->grab_wireframe_rect.width,
>+                                                 display->grab_wireframe_rect.height,
>+                                                 meta_resize_gravity_from_grab_op (display->grab_op));
>+            }
>         }
>       meta_window_calc_showing (display->grab_window);
>     }
>diff --git a/src/core/window-private.h b/src/core/window-private.h
>index da3fc52..65143ce 100644
>--- a/src/core/window-private.h
>+++ b/src/core/window-private.h
>@@ -412,6 +412,11 @@ void        meta_window_maximize_internal  (MetaWindow        *window,
>                                             MetaRectangle     *saved_rect);
> void        meta_window_unmaximize         (MetaWindow        *window,
>                                             MetaMaximizeFlags  directions);
>+void        meta_window_unmaximize_with_gravity (MetaWindow        *window,
>+                                                 MetaMaximizeFlags  directions,
>+                                                 int                new_width,
>+                                                 int                new_height,
>+                                                 int                gravity);
> void        meta_window_make_above         (MetaWindow  *window);
> void        meta_window_unmake_above       (MetaWindow  *window);
> void        meta_window_shade              (MetaWindow  *window,
>diff --git a/src/core/window.c b/src/core/window.c
>index 9af5283..6438540 100644
>--- a/src/core/window.c
>+++ b/src/core/window.c
>@@ -2666,9 +2666,11 @@ unmaximize_window_before_freeing (MetaWindow        *window)
>     }
> }
> 
>-void
>-meta_window_unmaximize (MetaWindow        *window,
>-                        MetaMaximizeFlags  directions)
>+static void
>+meta_window_unmaximize_internal (MetaWindow        *window,
>+                                 MetaMaximizeFlags  directions,
>+                                 MetaRectangle     *desired_rect,
>+                                 int                gravity)
> {
>   /* At least one of the two directions ought to be set */
>   gboolean unmaximize_horizontally, unmaximize_vertically;
>@@ -2702,13 +2704,13 @@ meta_window_unmaximize (MetaWindow        *window,
>       meta_window_get_client_root_coords (window, &target_rect);
>       if (unmaximize_horizontally)
>         {
>-          target_rect.x     = window->saved_rect.x;
>-          target_rect.width = window->saved_rect.width;
>+          target_rect.x     = desired_rect->x;
>+          target_rect.width = desired_rect->width;
>         }
>       if (unmaximize_vertically)
>         {
>-          target_rect.y      = window->saved_rect.y;
>-          target_rect.height = window->saved_rect.height;
>+          target_rect.y      = desired_rect->y;
>+          target_rect.height = desired_rect->height;
>         }
> 
>       /* Window's size hints may have changed while maximized, making
>@@ -2727,12 +2729,13 @@ meta_window_unmaximize (MetaWindow        *window,
>           window->display->grab_anchor_window_pos = target_rect;
>         }
> 
>-      meta_window_move_resize (window,
>-                               FALSE,
>-                               target_rect.x,
>-                               target_rect.y,
>-                               target_rect.width,
>-                               target_rect.height);
>+      meta_window_move_resize_internal (window,
>+                                        META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION,
>+                                        gravity,
>+                                        target_rect.x,
>+                                        target_rect.y,
>+                                        target_rect.width,
>+                                        target_rect.height);
> 
>       /* Make sure user_rect is current.
>        */
>@@ -2749,6 +2752,36 @@ meta_window_unmaximize (MetaWindow        *window,
> }
> 
> void
>+meta_window_unmaximize (MetaWindow        *window,
>+                        MetaMaximizeFlags  directions)
>+{
>+  meta_window_unmaximize_internal (window, directions, &window->saved_rect,
>+                                   NorthWestGravity);
>+}
>+
>+/* Like meta_window_unmaximize(), but instead of unmaximizing to the
>+ * saved position, we give the new desired size, and the gravity that
>+ * determines the positioning relationship between the area occupied
>+ * maximized and the new are. The arguments are similar to
>+ * meta_window_resize_with_gravity().
>+ */
>+void
>+meta_window_unmaximize_with_gravity (MetaWindow        *window,
>+                                     MetaMaximizeFlags  directions,
>+                                     int                new_width,
>+                                     int                new_height,
>+                                     int                gravity)
>+{
>+  MetaRectangle desired_rect;
>+
>+  meta_window_get_position (window, &desired_rect.x, &desired_rect.y);
>+  desired_rect.width = new_width;
>+  desired_rect.height = new_height;
>+
>+  meta_window_unmaximize_internal (window, directions, &desired_rect, gravity);
>+}
>+
>+void
> meta_window_make_above (MetaWindow  *window)
> {
>   window->wm_state_above = TRUE;
>@@ -7033,6 +7066,112 @@ update_resize_timeout (gpointer data)
>   return FALSE;
> }
> 
>+/* When resizing a maximized window by using alt-middle-drag (resizing
>+ * with the grips or the menu for a maximized window is not enabled),
>+ * the user can "break" out of the maximized state. This checks for
>+ * that possibility. During such a break-out resize the user can also
>+ * return to the previous maximization state by resizing back to near
>+ * the original size.
>+ */
>+static MetaMaximizeFlags
>+check_resize_unmaximize(MetaWindow *window,
>+                        int         dx,
>+                        int         dy)
>+{
>+  int threshold;
>+  MetaMaximizeFlags new_unmaximize;
>+
>+#define DRAG_THRESHOLD_TO_RESIZE_THRESHOLD_FACTOR 3
>+
>+  threshold = meta_ui_get_drag_threshold (window->screen->ui) *
>+    DRAG_THRESHOLD_TO_RESIZE_THRESHOLD_FACTOR;
>+  new_unmaximize = 0;
>+
>+  if (window->maximized_horizontally ||
>+      (window->display->grab_resize_unmaximize & META_MAXIMIZE_HORIZONTAL) != 0)
>+    {
>+      int x_amount;
>+
>+      /* We allow breaking out of maximization in either direction, to make
>+       * the window larger than the monitor as well as smaller than the
>+       * monitor. If we wanted to only allow resizing smaller than the
>+       * monitor, we'd use - dx for NE/E/SE and dx for SW/W/NW.
>+       */
>+      switch (window->display->grab_op)
>+        {
>+        case META_GRAB_OP_RESIZING_NE:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_NE:
>+        case META_GRAB_OP_RESIZING_E:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_E:
>+        case META_GRAB_OP_RESIZING_SE:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_SE:
>+        case META_GRAB_OP_RESIZING_SW:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_SW:
>+        case META_GRAB_OP_RESIZING_W:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_W:
>+        case META_GRAB_OP_RESIZING_NW:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_NW:
>+          x_amount = dx < 0 ? - dx : dx;
>+          break;
>+        default:
>+          x_amount = 0;
>+          break;
>+        }
>+
>+      if (x_amount > threshold)
>+        new_unmaximize |= META_MAXIMIZE_HORIZONTAL;
>+    }
>+
>+  if (window->maximized_vertically ||
>+      (window->display->grab_resize_unmaximize & META_MAXIMIZE_VERTICAL) != 0)
>+    {
>+      int y_amount;
>+
>+      switch (window->display->grab_op)
>+        {
>+        case META_GRAB_OP_RESIZING_N:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_N:
>+        case META_GRAB_OP_RESIZING_NE:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_NE:
>+        case META_GRAB_OP_RESIZING_NW:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_NW:
>+        case META_GRAB_OP_RESIZING_SE:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_SE:
>+        case META_GRAB_OP_RESIZING_S:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_S:
>+        case META_GRAB_OP_RESIZING_SW:
>+        case META_GRAB_OP_KEYBOARD_RESIZING_SW:
>+          y_amount = dy < 0 ? - dy : dy;
>+          break;
>+        default:
>+          y_amount = 0;
>+          break;
>+        }
>+
>+      if (y_amount > threshold)
>+        new_unmaximize |= META_MAXIMIZE_VERTICAL;
>+    }
>+
>+  /* Marco doesn't have a full user interface for only horizontally or
>+   * vertically maximized, so while only unmaximizing in the direction drags
>+   * has some advantages, it will also confuse the user. So, we always
>+   * unmaximize both ways if possible.
>+   */
>+  if (new_unmaximize != 0)
>+    {
>+      new_unmaximize = 0;
>+
>+      if (window->maximized_horizontally ||
>+          (window->display->grab_resize_unmaximize & META_MAXIMIZE_HORIZONTAL) != 0)
>+        new_unmaximize |= META_MAXIMIZE_HORIZONTAL;
>+      if (window->maximized_vertically ||
>+          (window->display->grab_resize_unmaximize & META_MAXIMIZE_VERTICAL) != 0)
>+        new_unmaximize |= META_MAXIMIZE_VERTICAL;
>+    }
>+
>+  return new_unmaximize;
>+}
>+
> static void
> update_resize (MetaWindow *window,
>                gboolean    snap,
>@@ -7045,6 +7184,7 @@ update_resize (MetaWindow *window,
>   MetaRectangle old;
>   int new_x, new_y;
>   double remaining;
>+  MetaMaximizeFlags new_unmaximize;
>   
>   window->display->grab_latest_motion_x = x;
>   window->display->grab_latest_motion_y = y;
>@@ -7233,6 +7375,8 @@ update_resize (MetaWindow *window,
> 
>   if (window->display->grab_wireframe_active)
>     {
>+      MetaRectangle root_coords;
>+
>       if ((new_x + new_w <= new_x) || (new_y + new_h <= new_y))
>         return;
> 
>@@ -7242,18 +7386,60 @@ update_resize (MetaWindow *window,
>        * wireframe, but still resize it; however, that probably
>        * confuses broken clients that have problems with opaque
>        * resize, they probably don't track their visibility.
>+       *
>+       * We handle the basic constraints on maximized windows here
>+       * to give the user feedback.
>        */
>+
>+      if (window->maximized_horizontally && (new_unmaximize & META_MAXIMIZE_HORIZONTAL) == 0)
>+        {
>+          meta_window_get_client_root_coords (window, &root_coords);
>+          new_x = root_coords.x;
>+          new_w = root_coords.width;
>+        }
>+      if (window->maximized_vertically && (new_unmaximize & META_MAXIMIZE_VERTICAL) == 0)
>+        {
>+          meta_window_get_client_root_coords (window, &root_coords);
>+          new_y = root_coords.y;
>+          new_h = root_coords.height;
>+        }
>+
>       meta_window_update_wireframe (window, new_x, new_y, new_w, new_h);
>     }
>   else
>     {
>-      /* We don't need to update unless the specified width and height
>-       * are actually different from what we had before.
>-       */
>-      if (old.width != new_w || old.height != new_h)
>-        meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity);
>+      if (new_unmaximize == window->display->grab_resize_unmaximize)
>+        {
>+          /* We don't need to update unless the specified width and height
>+           * are actually different from what we had before.
>+           */
>+          if (old.width != new_w || old.height != new_h)
>+            {
>+              if ((window->display->grab_resize_unmaximize == new_unmaximize))
>+                meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity);
>+            }
>+        }
>+      else
>+        {
>+          if ((new_unmaximize & ~window->display->grab_resize_unmaximize) != 0)
>+            {
>+              meta_window_unmaximize_with_gravity (window,
>+                                                   (new_unmaximize & ~window->display->grab_resize_unmaximize),
>+                                                   new_w, new_h, gravity);
>+            }
>+
>+          if ((window->display->grab_resize_unmaximize & ~new_unmaximize))
>+            {
>+              MetaRectangle saved_rect = window->saved_rect;
>+              meta_window_maximize (window,
>+                                    (window->display->grab_resize_unmaximize & ~new_unmaximize));
>+              window->saved_rect = saved_rect;
>+            }
>+        }
>     }
> 
>+  window->display->grab_resize_unmaximize = new_unmaximize;
>+
>   /* Store the latest resize time, if we actually resized. */
>   if (window->rect.width != old.width || window->rect.height != old.height)
>     g_get_current_time (&window->display->grab_last_moveresize_time);
>-- 
>1.7.0.1
>

Actions: View | Diff

Attachments on bug 844165: 601356 | 601357 | 601358 | 601359 | 601360 | 601361 | 601362 | 601363 | 601364 | 601365 | 601366 | 601367