Define all the various constants used at the beginning of the function for

2005-11-18  Elijah Newren  <newren@gmail.com>

	* src/edge-resistance.c (apply_edge_resistance):
	Define all the various constants used at the beginning of the
	function for easier tweaking, modify the xinerama ones a bit,
	reorder the function slightly to try to make it easier to read

	* src/boxes.h (MetaEdgeType):
	* src/boxes.c (add_edges):
	* src/edge-resistance.c (apply_edge_resistance):
	* src/testboxes.c (new_onscreen_edge):
	rename META_EDGE_ONSCREEN to META_EDGE_SCREEN

	* src/testboxes.c (new_onscreen_edge):
	* src/testboxes.c (test_find_onscreen_edges):
	rename new_onscreen_edge() to new_screen_edge()

5 files changed, 184 insertions, 103 deletions

diff --git a/ChangeLog b/ChangeLog
index 2e75c923..f76ec918 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,22 @@
 2005-11-18  Elijah Newren  <newren@gmail.com>
 
+	* src/edge-resistance.c (apply_edge_resistance):
+	Define all the various constants used at the beginning of the
+	function for easier tweaking, modify the xinerama ones a bit,
+	reorder the function slightly to try to make it easier to read
+
+	* src/boxes.h (MetaEdgeType):
+	* src/boxes.c (add_edges):
+	* src/edge-resistance.c (apply_edge_resistance):
+	* src/testboxes.c (new_onscreen_edge):
+	rename META_EDGE_ONSCREEN to META_EDGE_SCREEN
+
+	* src/testboxes.c (new_onscreen_edge):
+	* src/testboxes.c (test_find_onscreen_edges):
+	rename new_onscreen_edge() to new_screen_edge()
+
+2005-11-18  Elijah Newren  <newren@gmail.com>
+
 	Uh, I was pretty sure I had tested the last patch.  I must have
 	forgotten the last part I added--the ConstraintFunc consolidation.
 	How embarrassing.
diff --git a/src/boxes.c b/src/boxes.c
index 24c0e739..06f23c02 100644
--- a/src/boxes.c
+++ b/src/boxes.c
@@ -1356,7 +1356,7 @@ add_edges (GList               *cur_edges,
           temp_edge->rect.height  = 0;
           break;
         }
-      temp_edge->edge_type = META_EDGE_ONSCREEN;
+      temp_edge->edge_type = META_EDGE_SCREEN;
       cur_edges = g_list_prepend (cur_edges, temp_edge);
     }
 
diff --git a/src/boxes.h b/src/boxes.h
index 3a9ba147..cea7cf32 100644
--- a/src/boxes.h
+++ b/src/boxes.h
@@ -50,7 +50,7 @@ typedef enum
 {
   META_EDGE_WINDOW,
   META_EDGE_XINERAMA,
-  META_EDGE_ONSCREEN
+  META_EDGE_SCREEN
 } MetaEdgeType;
 
 typedef struct _MetaEdge MetaEdge;
diff --git a/src/edge-resistance.c b/src/edge-resistance.c
index a9a1a95a..784581d1 100644
--- a/src/edge-resistance.c
+++ b/src/edge-resistance.c
@@ -334,8 +334,15 @@ apply_edge_resistance (MetaWindow                *window,
   gboolean increasing = new_pos > old_pos;
   int      increment = increasing ? 1 : -1;
 
-  /* ridiculously huge for testing */
-  const int EDGE_RESISTANCE_THRESHOLD = 16;
+  const int PIXEL_DISTANCE_THRESHOLD_WINDOW   = 16;
+  const int PIXEL_DISTANCE_THRESHOLD_XINERAMA = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_SCREEN   = 32;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW   =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA = 100;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN   = 750;
+  const int KEYBOARD_BUILDUP_THRESHOLD_WINDOW   = 16;
+  const int KEYBOARD_BUILDUP_THRESHOLD_XINERAMA = 24;
+  const int KEYBOARD_BUILDUP_THRESHOLD_SCREEN   = 32;
 
   /* Quit if no movement was specified */
   if (old_pos == new_pos)
@@ -374,50 +381,16 @@ apply_edge_resistance (MetaWindow                *window,
         meta_rectangle_vert_overlap (&edge->rect, new_rect) :
         meta_rectangle_horiz_overlap (&edge->rect, new_rect);
 
-      /* INFINITE RESISTANCE for screen edges under certain cases; If the
-       * edge is relevant and we're moving towards it and it's a screen
-       * edge and infinite resistance has been requested for this
-       * particular grab op then don't allow movement past it.
-       */
-      if (edges_align && !keyboard_op &&
-          movement_towards_edge (edge->side_type, increment) &&
-          edge->edge_type == META_EDGE_ONSCREEN &&
-          !resistance_data->allow_past_screen_edge)
+      /* Nothing to do unless the edges align */
+      if (!edges_align)
         {
-          return compare;
-        }
-
-      /* TIMEOUT RESISTANCE for screen/xinerama edges: If the edge is
-       * relevant and we're moving towards it and it's a screen/xinerama
-       * edge, then we may want to have some kind of time delay before the
-       * user can move past this edge.
-       */
-      if (edges_align && !keyboard_op &&
-          movement_towards_edge (edge->side_type, increment) &&
-          ((window->require_fully_onscreen &&
-            edge->edge_type == META_EDGE_ONSCREEN) ||
-           (window->require_on_single_xinerama &&
-            edge->edge_type == META_EDGE_XINERAMA)))
-        {
-          if (!resistance_data->timeout_setup
-              /* FIXME?: || compare != resistance_data->edge_pos */ )
-            {
-              resistance_data->timeout_id = 
-                g_timeout_add (750,
-                               edge_resistance_timeout,
-                               resistance_data);
-              resistance_data->timeout_setup = TRUE;
-              resistance_data->timeout_edge_pos = compare;
-              resistance_data->timeout_over = FALSE;
-              resistance_data->timeout_func = timeout_func;
-              resistance_data->window = window;
-            }
-          if (!resistance_data->timeout_over)
-            return compare;
+          /* Go to the next edge in the range */
+          i += increment;
+          continue;
         }
 
       /* Rest is easier to read if we split on keyboard vs. mouse op */
-      if (keyboard_op && edges_align)
+      if (keyboard_op)
         {
           /* KEYBOARD ENERGY BUILDUP RESISTANCE: If the user has is moving
            * fast enough or has already built up enough "energy", then let
@@ -425,14 +398,37 @@ apply_edge_resistance (MetaWindow                *window,
            * user was previously stopped at this edge, add movement amount
            * to the built up energy.
            */
+
+          /* First, determine the amount of the resistance */
+          int resistance = 0;
+          switch (edge->edge_type)
+            {
+            case META_EDGE_WINDOW:
+              resistance = KEYBOARD_BUILDUP_THRESHOLD_WINDOW;
+              break;
+            case META_EDGE_XINERAMA:
+              resistance = KEYBOARD_BUILDUP_THRESHOLD_XINERAMA;
+              break;
+            case META_EDGE_SCREEN:
+              resistance = KEYBOARD_BUILDUP_THRESHOLD_SCREEN;
+              break;
+            }
+
+          /* Clear any previous buildup if we've run into an edge at a
+           * different location than what we were building up on before.
+           * See below for more details where these get set.
+           */
           if (okay_to_clear_keyboard_buildup &&
               compare != keyboard_buildup_edge)
             {
               okay_to_clear_keyboard_buildup = FALSE;
               resistance_data->keyboard_buildup = 0;
             }
-          int threshold = EDGE_RESISTANCE_THRESHOLD
-                         - resistance_data->keyboard_buildup;
+
+          /* Determine the threshold */
+          int threshold = resistance - resistance_data->keyboard_buildup;
+
+          /* See if threshold hasn't been met yet or not */
           if (ABS (compare - new_pos) < threshold)
             {
               if (resistance_data->keyboard_buildup != 0)
@@ -453,18 +449,86 @@ apply_edge_resistance (MetaWindow                *window,
               keyboard_buildup_edge = compare;
             }
         }
-      else if (!keyboard_op && edges_align)
+      else /* mouse op */
         {
+          /* INFINITE RESISTANCE for screen edges under certain cases; If
+           * the edge is relevant and we're moving towards it and it's a
+           * screen edge and infinite resistance has been requested for
+           * this particular grab op then don't allow movement past it.
+           */
+          if (edge->edge_type == META_EDGE_SCREEN &&
+              !resistance_data->allow_past_screen_edge &&
+              movement_towards_edge (edge->side_type, increment))
+            {
+              return compare;
+            }
+
+          /* TIMEOUT RESISTANCE: If the edge is relevant and we're moving
+           * towards it, then we may want to have some kind of time delay
+           * before the user can move past this edge.
+           */
+          if (movement_towards_edge (edge->side_type, increment))
+            {
+              /* First, determine the length of time for the resistance */
+              int timeout_length_ms = 0;
+              switch (edge->edge_type)
+                {
+                case META_EDGE_WINDOW:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
+                  break;
+                case META_EDGE_XINERAMA:
+                  if (window->require_on_single_xinerama)
+                    timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA;
+                  break;
+                case META_EDGE_SCREEN:
+                  if (window->require_fully_onscreen)
+                    timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
+                  break;
+                }
+
+              if (!resistance_data->timeout_setup &&
+                  timeout_length_ms != 0)
+                {
+                  resistance_data->timeout_id = 
+                    g_timeout_add (timeout_length_ms,
+                                   edge_resistance_timeout,
+                                   resistance_data);
+                  resistance_data->timeout_setup = TRUE;
+                  resistance_data->timeout_edge_pos = compare;
+                  resistance_data->timeout_over = FALSE;
+                  resistance_data->timeout_func = timeout_func;
+                  resistance_data->window = window;
+                }
+              if (!resistance_data->timeout_over &&
+                  timeout_length_ms != 0)
+                return compare;
+            }
+
           /* PIXEL DISTANCE MOUSE RESISTANCE: If the edge matters and the
-           * user hasn't moved at least EDGE_RESISTANCE_THRESHOLD pixels
-           * past this edge, stop movement at this edge.  (Note that this
-           * is different from keyboard resistance precisely because
-           * keyboard move ops are relative to previous positions, whereas
-           * mouse move ops are relative to differences in mouse position
-           * and mouse position is an absolute quantity rather than a
-           * relative quantity)
+           * user hasn't moved at least threshold pixels past this edge,
+           * stop movement at this edge.  (Note that this is different from
+           * keyboard resistance precisely because keyboard move ops are
+           * relative to previous positions, whereas mouse move ops are
+           * relative to differences in mouse position and mouse position
+           * is an absolute quantity rather than a relative quantity)
            */
-          if (ABS (compare - new_pos) < EDGE_RESISTANCE_THRESHOLD)
+
+          /* First, determine the threshold */
+          int threshold = 0;
+          switch (edge->edge_type)
+            {
+            case META_EDGE_WINDOW:
+              threshold = PIXEL_DISTANCE_THRESHOLD_WINDOW;
+              break;
+            case META_EDGE_XINERAMA:
+              threshold = PIXEL_DISTANCE_THRESHOLD_XINERAMA;
+              break;
+            case META_EDGE_SCREEN:
+              threshold = PIXEL_DISTANCE_THRESHOLD_SCREEN;
+              break;
+            }
+
+          if (ABS (compare - new_pos) < threshold)
             return compare;
         }
 
diff --git a/src/testboxes.c b/src/testboxes.c
index 4ed5881d..80425a66 100644
--- a/src/testboxes.c
+++ b/src/testboxes.c
@@ -57,7 +57,7 @@ new_meta_rect (int x, int y, int width, int height)
 }
 
 static MetaEdge*
-new_onscreen_edge (int x, int y, int width, int height, int side_type)
+new_screen_edge (int x, int y, int width, int height, int side_type)
 {
   MetaEdge* temporary;
   temporary = g_new (MetaEdge, 1);
@@ -66,7 +66,7 @@ new_onscreen_edge (int x, int y, int width, int height, int side_type)
   temporary->rect.width  = width;
   temporary->rect.height = height;
   temporary->side_type = side_type;
-  temporary->edge_type = META_EDGE_ONSCREEN;
+  temporary->edge_type = META_EDGE_SCREEN;
 
   return temporary;
 }
@@ -1011,10 +1011,10 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (0);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0, 1200, 1600, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,    0, 1600, 0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,    0, 0, 1200, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,    0, 0, 1200, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,    0, 0, 1200, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,    0, 0, 1200, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
@@ -1024,12 +1024,12 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (1);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0, 1200,  400, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 400, 1160, 1200, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 1600, 0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,   20, 0, 1140, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 400, 1160, 0,   40, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 0, 1180, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 1200, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1140, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 400, 1160, 0,   40, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
@@ -1039,18 +1039,18 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (2);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1200, 1200,  400, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 450, 1200,  350, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0, 1200,  300, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 300, 1150,  150, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800, 1100,  400, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 1600, 0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,   20, 0, 1180, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800, 1100, 0,  100, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 300, 1150, 0,   50, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1200, 1100, 0,  100, left));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 450, 1150, 0,   50, left));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 0, 1180, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1200,  350, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,  150, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 450, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
@@ -1060,22 +1060,22 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (3);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1200, 1200,  400, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 380, 1200,  420, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0, 1200,  300, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 300, 1150,   80, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800, 1100,  400, 0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 700,  525, 200,  0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 700,  675, 200,  0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 1600, 0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,   20, 0, 1180, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800, 1100, 0,  100, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 700,  525, 0,  150, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 300, 1150, 0,   50, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1200, 1100, 0,  100, left));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 900,  525, 0,  150, left));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 380, 1150, 0,   50, left));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   20, 0, 1180, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1200,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1200,  420, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200,  300, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150,   80, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100,  400, 0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 200,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  675, 200,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1100, 0,  100, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 700,  525, 0,  150, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 300, 1150, 0,   50, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (1200, 1100, 0,  100, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 900,  525, 0,  150, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 380, 1150, 0,   50, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   20, 0, 1180, left));
 
 #if 0
   #define FUDGE 50 /* number of edges */
@@ -1095,10 +1095,10 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (4);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800, 1200, 800,  0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800,   20, 800,  0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,   20, 0, 1180, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge ( 800,   20, 0, 1180, left));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800, 1200, 800,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 800,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   20, 0, 1180, right));
+  tmp = g_list_prepend (tmp, new_screen_edge ( 800,   20, 0, 1180, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
@@ -1117,10 +1117,10 @@ test_find_onscreen_edges ()
   /*************************************************/  
   edges = get_screen_edges (6);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0, 1200, 1600,  0, bottom));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   40, 1600,  0, top));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (1600,   40, 0,  1160, right));
-  tmp = g_list_prepend (tmp, new_onscreen_edge (   0,   40, 0,  1160, left));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0, 1200, 1600,  0, bottom));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 1600,  0, top));
+  tmp = g_list_prepend (tmp, new_screen_edge (1600,   40, 0,  1160, right));
+  tmp = g_list_prepend (tmp, new_screen_edge (   0,   40, 0,  1160, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);