edge-resistance: remove dead code

Timeouts are not used since de65967b62d46d6dd01352d5fb5104f88f30d88e.

4 files changed, 39 insertions, 203 deletions

diff --git a/src/core/edge-resistance.c b/src/core/edge-resistance.c
index 105c51b3..23bf79f8 100644
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -36,29 +36,12 @@
   window->type   != META_WINDOW_MENU    &&     \
   window->type   != META_WINDOW_SPLASHSCREEN
 
-struct ResistanceDataForAnEdge
-{
-  gboolean     timeout_setup;
-  guint        timeout_id;
-  int          timeout_edge_pos;
-  gboolean     timeout_over;
-  GSourceFunc  timeout_func;
-  MetaWindow  *window;
-  int          keyboard_buildup;
-};
-typedef struct ResistanceDataForAnEdge ResistanceDataForAnEdge;
-
 struct MetaEdgeResistanceData
 {
   GArray *left_edges;
   GArray *right_edges;
   GArray *top_edges;
   GArray *bottom_edges;
-
-  ResistanceDataForAnEdge left_data;
-  ResistanceDataForAnEdge right_data;
-  ResistanceDataForAnEdge top_data;
-  ResistanceDataForAnEdge bottom_data;
 };
 
 static void compute_resistance_and_snapping_edges (MetaDisplay *display);
@@ -309,29 +292,15 @@ movement_towards_edge (MetaSide side, int increment)
     }
 }
 
-static gboolean
-edge_resistance_timeout (gpointer data)
-{
-  ResistanceDataForAnEdge *resistance_data = data;
-
-  resistance_data->timeout_over = TRUE;
-  resistance_data->timeout_id = 0;
-  (*resistance_data->timeout_func)(resistance_data->window);
-
-  return FALSE;
-}
-
 static int
-apply_edge_resistance (MetaWindow                *window,
-                       int                        old_pos,
-                       int                        new_pos,
-                       const MetaRectangle       *old_rect,
-                       const MetaRectangle       *new_rect,
-                       GArray                    *edges,
-                       ResistanceDataForAnEdge   *resistance_data,
-                       GSourceFunc                timeout_func,
-                       gboolean                   xdir,
-                       gboolean                   keyboard_op)
+apply_edge_resistance (MetaWindow          *window,
+                       int                  old_pos,
+                       int                  new_pos,
+                       const MetaRectangle *old_rect,
+                       const MetaRectangle *new_rect,
+                       GArray              *edges,
+                       gboolean             xdir,
+                       gboolean             keyboard_op)
 {
   int i, begin, end;
   int last_edge;
@@ -344,29 +313,11 @@ apply_edge_resistance (MetaWindow                *window,
   const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR = 0;
   const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN = 32;
   const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN = 0;
-  const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW = 0;
-  const int TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR = 0;
-  const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN = 0;
 
   /* Quit if no movement was specified */
   if (old_pos == new_pos)
     return new_pos;
 
-  /* Remove the old timeout if it's no longer relevant */
-  if (resistance_data->timeout_setup &&
-      ((resistance_data->timeout_edge_pos > old_pos &&
-        resistance_data->timeout_edge_pos > new_pos)  ||
-       (resistance_data->timeout_edge_pos < old_pos &&
-        resistance_data->timeout_edge_pos < new_pos)))
-    {
-      resistance_data->timeout_setup = FALSE;
-      if (resistance_data->timeout_id != 0)
-        {
-          g_source_remove (resistance_data->timeout_id);
-          resistance_data->timeout_id = 0;
-        }
-    }
-
   /* Get the range of indices in the edge array that we move past/to. */
   begin = find_index_of_edge_near_position (edges, old_pos,  increasing, xdir);
   end   = find_index_of_edge_near_position (edges, new_pos, !increasing, xdir);
@@ -410,47 +361,6 @@ apply_edge_resistance (MetaWindow                *window,
         {
           int threshold;
 
-          /* 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_MONITOR:
-                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR;
-                  break;
-                case META_EDGE_SCREEN:
-                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
-                  break;
-                default:
-                  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 threshold pixels past this edge,
            * stop movement at this edge.  (Note that this is different from
@@ -544,7 +454,6 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                     MetaWindow          *window,
                                     const MetaRectangle *old_outer,
                                     MetaRectangle       *new_outer,
-                                    GSourceFunc          timeout_func,
                                     gboolean             auto_snap,
                                     gboolean             keyboard_op,
                                     gboolean             is_resize)
@@ -609,8 +518,6 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                               old_outer,
                                               new_outer,
                                               edge_data->left_edges,
-                                              &edge_data->left_data,
-                                              timeout_func,
                                               TRUE,
                                               keyboard_op);
           new_right  = apply_edge_resistance (window,
@@ -619,8 +526,6 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                               old_outer,
                                               new_outer,
                                               edge_data->right_edges,
-                                              &edge_data->right_data,
-                                              timeout_func,
                                               TRUE,
                                               keyboard_op);
         }
@@ -638,8 +543,6 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                               old_outer,
                                               new_outer,
                                               edge_data->top_edges,
-                                              &edge_data->top_data,
-                                              timeout_func,
                                               FALSE,
                                               keyboard_op);
           new_bottom = apply_edge_resistance (window,
@@ -648,8 +551,6 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
                                               old_outer,
                                               new_outer,
                                               edge_data->bottom_edges,
-                                              &edge_data->bottom_data,
-                                              timeout_func,
                                               FALSE,
                                               keyboard_op);
         }
@@ -738,20 +639,6 @@ meta_display_cleanup_edges (MetaDisplay *display)
   edge_data->top_edges = NULL;
   edge_data->bottom_edges = NULL;
 
-  /* Cleanup the timeouts */
-  if (edge_data->left_data.timeout_setup   &&
-      edge_data->left_data.timeout_id   != 0)
-    g_source_remove (edge_data->left_data.timeout_id);
-  if (edge_data->right_data.timeout_setup  &&
-      edge_data->right_data.timeout_id  != 0)
-    g_source_remove (edge_data->right_data.timeout_id);
-  if (edge_data->top_data.timeout_setup    &&
-      edge_data->top_data.timeout_id    != 0)
-    g_source_remove (edge_data->top_data.timeout_id);
-  if (edge_data->bottom_data.timeout_setup &&
-      edge_data->bottom_data.timeout_id != 0)
-    g_source_remove (edge_data->bottom_data.timeout_id);
-
   g_free (display->grab_edge_resistance_data);
   display->grab_edge_resistance_data = NULL;
 }
@@ -928,22 +815,6 @@ cache_edges (MetaDisplay *display,
 }
 
 static void
-initialize_grab_edge_resistance_data (MetaDisplay *display)
-{
-  MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
-
-  edge_data->left_data.timeout_setup   = FALSE;
-  edge_data->right_data.timeout_setup  = FALSE;
-  edge_data->top_data.timeout_setup    = FALSE;
-  edge_data->bottom_data.timeout_setup = FALSE;
-
-  edge_data->left_data.keyboard_buildup   = 0;
-  edge_data->right_data.keyboard_buildup  = 0;
-  edge_data->top_data.keyboard_buildup    = 0;
-  edge_data->bottom_data.keyboard_buildup = 0;
-}
-
-static void
 compute_resistance_and_snapping_edges (MetaDisplay *display)
 {
   GList *stacked_windows;
@@ -1122,25 +993,19 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
                display->grab_screen->active_workspace->monitor_edges,
                display->grab_screen->active_workspace->screen_edges);
   g_list_free (edges);
-
-  /*
-   * 6th: Initialize the resistance timeouts and buildups
-   */
-  initialize_grab_edge_resistance_data (display);
 }
 
 /* Note that old_[xy] and new_[xy] are with respect to inner positions of
  * the window.
  */
 void
-meta_window_edge_resistance_for_move (MetaWindow  *window,
-                                      int          old_x,
-                                      int          old_y,
-                                      int         *new_x,
-                                      int         *new_y,
-                                      GSourceFunc  timeout_func,
-                                      gboolean     snap,
-                                      gboolean     is_keyboard_op)
+meta_window_edge_resistance_for_move (MetaWindow *window,
+                                      int         old_x,
+                                      int         old_y,
+                                      int        *new_x,
+                                      int        *new_y,
+                                      gboolean    snap,
+                                      gboolean    is_keyboard_op)
 {
   MetaRectangle old_outer, proposed_outer, new_outer;
   gboolean is_resize;
@@ -1167,7 +1032,6 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
                                           window,
                                           &old_outer,
                                           &new_outer,
-                                          timeout_func,
                                           snap,
                                           is_keyboard_op,
                                           is_resize))
@@ -1226,15 +1090,14 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
  * sizes of the inner window.
  */
 void
-meta_window_edge_resistance_for_resize (MetaWindow  *window,
-                                        int          old_width,
-                                        int          old_height,
-                                        int         *new_width,
-                                        int         *new_height,
-                                        int          gravity,
-                                        GSourceFunc  timeout_func,
-                                        gboolean     snap,
-                                        gboolean     is_keyboard_op)
+meta_window_edge_resistance_for_resize (MetaWindow *window,
+                                        int         old_width,
+                                        int         old_height,
+                                        int        *new_width,
+                                        int        *new_height,
+                                        int         gravity,
+                                        gboolean    snap,
+                                        gboolean    is_keyboard_op)
 {
   MetaRectangle old_outer, new_outer;
   int proposed_outer_width, proposed_outer_height;
@@ -1265,7 +1128,6 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
                                           window,
                                           &old_outer,
                                           &new_outer,
-                                          timeout_func,
                                           snap,
                                           is_keyboard_op,
                                           is_resize))
diff --git a/src/core/edge-resistance.h b/src/core/edge-resistance.h
index caf56bb8..c53ce60f 100644
--- a/src/core/edge-resistance.h
+++ b/src/core/edge-resistance.h
@@ -24,23 +24,21 @@
 
 #include "window-private.h"
 
-void        meta_window_edge_resistance_for_move   (MetaWindow  *window,
-                                                    int          old_x,
-                                                    int          old_y,
-                                                    int         *new_x,
-                                                    int         *new_y,
-                                                    GSourceFunc  timeout_func,
-                                                    gboolean     snap,
-                                                    gboolean     is_keyboard_op);
-void        meta_window_edge_resistance_for_resize (MetaWindow  *window,
-                                                    int          old_width,
-                                                    int          old_height,
-                                                    int         *new_width,
-                                                    int         *new_height,
-                                                    int          gravity,
-                                                    GSourceFunc  timeout_func,
-                                                    gboolean     snap,
-                                                    gboolean     is_keyboard_op);
+void meta_window_edge_resistance_for_move   (MetaWindow *window,
+                                             int         old_x,
+                                             int         old_y,
+                                             int        *new_x,
+                                             int        *new_y,
+                                             gboolean    snap,
+                                             gboolean    is_keyboard_op);
 
-#endif /* META_EDGE_RESISTANCE_H */
+void meta_window_edge_resistance_for_resize (MetaWindow *window,
+                                             int         old_width,
+                                             int         old_height,
+                                             int        *new_width,
+                                             int        *new_height,
+                                             int         gravity,
+                                             gboolean    snap,
+                                             gboolean    is_keyboard_op);
 
+#endif /* META_EDGE_RESISTANCE_H */
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index af61f7b0..e9e6ecd1 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -1557,7 +1557,6 @@ process_keyboard_move_grab (MetaDisplay *display,
                                             old_rect.y,
                                             &x,
                                             &y,
-                                            NULL,
                                             smart_snap,
                                             TRUE);
 
@@ -1990,7 +1989,6 @@ process_keyboard_resize_grab (MetaDisplay *display,
                                               &width,
                                               &height,
                                               gravity,
-                                              NULL,
                                               smart_snap,
                                               TRUE);
 
diff --git a/src/core/window.c b/src/core/window.c
index a2495d98..ab86382b 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -98,18 +98,11 @@ static void meta_window_move_resize_now (MetaWindow  *window);
 
 static void meta_window_unqueue (MetaWindow *window, guint queuebits);
 
-static void     update_move           (MetaWindow   *window,
-                                       gboolean      snap,
-                                       int           x,
-                                       int           y);
-static gboolean update_move_timeout   (gpointer data);
 static void     update_resize         (MetaWindow   *window,
                                        gboolean      snap,
                                        int           x,
                                        int           y,
                                        gboolean      force);
-static gboolean update_resize_timeout (gpointer data);
-
 
 static void meta_window_flush_calc_showing   (MetaWindow *window);
 
@@ -7550,19 +7543,6 @@ check_moveresize_frequency (MetaWindow *window,
     }
 }
 
-static gboolean
-update_move_timeout (gpointer data)
-{
-  MetaWindow *window = data;
-
-  update_move (window,
-               window->display->grab_last_user_action_was_snap,
-               window->display->grab_latest_motion_x,
-               window->display->grab_latest_motion_y);
-
-  return FALSE;
-}
-
 static void
 update_move (MetaWindow  *window,
              gboolean     snap,
@@ -7784,7 +7764,6 @@ update_move (MetaWindow  *window,
                                         old.y,
                                         &new_x,
                                         &new_y,
-                                        update_move_timeout,
                                         snap,
                                         FALSE);
 
@@ -8005,7 +7984,6 @@ update_resize (MetaWindow *window,
                                           &new_w,
                                           &new_h,
                                           gravity,
-                                          update_resize_timeout,
                                           snap,
                                           FALSE);