GNOME.org
 

[gimp] app: remove all calls to gdk_window_process_updated()

commit 3089a20167f1fda55c6c56a5201a8e1ce51fc523
Author: Michael Natterer <mitch gimp org>
Date:   Sun Jul 1 16:19:54 2018 +0200

    app: remove all calls to gdk_window_process_updated()
    
    - remove gimp_widget_flush_expose()
    - remove the "now" argument to gimp_display_shell_flush() and make it
      only update widget states
    - rename gimp_display_flush_whenever() to gimp_display_flush_update_region()
      and call gimp_display_shell_flush() separately in the only case we
      passed FALSE to flush_whenever()
    - remove th flush_now interval logic from GimpDisplay, as soon as we
      have exposed the canvas, we are in the loop for the next frame clock
      tick anyway, so delaying a useless and removed process_updates serves
      no purpose
    - in gimptool-progress.c, create the invisible grab widget also for
      non-cencelable cases, so we can always safely run the main loop
      manually to make the progress updates visible
    - in gimp-gegl-apply-operation.c, always run the main loop manually
      to make the progress updates visible
    - in gimpstatusbar.c, leave some FIXME comments as reminder that
      we might need the same logic as in gimptool-progress.c

 app/display/gimpdisplay.c            | 32 ++++--------------
 app/display/gimpdisplayshell.c       | 41 ++++++++++-------------
 app/display/gimpdisplayshell.h       |  3 +-
 app/display/gimpstatusbar.c          | 14 ++++++--
 app/gegl/gimp-gegl-apply-operation.c | 20 +++++------
 app/gegl/gimp-gegl-apply-operation.h |  2 +-
 app/tools/gimpdrawtool.c             |  4 ---
 app/tools/gimptool-progress.c        | 64 +++++++++++++++---------------------
 app/tools/gimptool.h                 |  1 +
 app/tools/gimptransformtool.c        |  3 ++
 app/widgets/gimpoverlaychild.c       |  2 --
 app/widgets/gimpprogressbox.c        | 14 --------
 app/widgets/gimpwidgets-utils.c      | 12 -------
 app/widgets/gimpwidgets-utils.h      |  2 --
 14 files changed, 76 insertions(+), 138 deletions(-)
---
diff --git a/app/display/gimpdisplay.c b/app/display/gimpdisplay.c
index 51e044ce01..0be7c90d12 100644
--- a/app/display/gimpdisplay.c
+++ b/app/display/gimpdisplay.c
@@ -50,8 +50,6 @@
 #include "gimp-intl.h"
 
 
-#define FLUSH_NOW_INTERVAL      20000 /* 20 ms in microseconds */
-
 #define PAINT_AREA_CHUNK_WIDTH  32
 #define PAINT_AREA_CHUNK_HEIGHT 32
 
@@ -78,8 +76,6 @@ struct _GimpDisplayPrivate
 
   GtkWidget      *shell;
   cairo_region_t *update_region;
-
-  guint64         last_flush_now;
 };
 
 #define GIMP_DISPLAY_GET_PRIVATE(display) \
@@ -121,8 +117,7 @@ static gboolean gimp_display_progress_message       (GimpProgress        *progre
 static void     gimp_display_progress_canceled      (GimpProgress        *progress,
                                                      GimpDisplay         *display);
 
-static void     gimp_display_flush_whenever         (GimpDisplay         *display,
-                                                     gboolean             now);
+static void     gimp_display_flush_update_region    (GimpDisplay         *display);
 static void     gimp_display_paint_area             (GimpDisplay         *display,
                                                      gint                 x,
                                                      gint                 y,
@@ -802,7 +797,9 @@ gimp_display_flush (GimpDisplay *display)
 {
   g_return_if_fail (GIMP_IS_DISPLAY (display));
 
-  gimp_display_flush_whenever (display, FALSE);
+  gimp_display_flush_update_region (display);
+
+  gimp_display_shell_flush (gimp_display_get_shell (display));
 }
 
 void
@@ -810,15 +807,14 @@ gimp_display_flush_now (GimpDisplay *display)
 {
   g_return_if_fail (GIMP_IS_DISPLAY (display));
 
-  gimp_display_flush_whenever (display, TRUE);
+  gimp_display_flush_update_region (display);
 }
 
 
 /*  private functions  */
 
 static void
-gimp_display_flush_whenever (GimpDisplay *display,
-                             gboolean     now)
+gimp_display_flush_update_region (GimpDisplay *display)
 {
   GimpDisplayPrivate *private = GIMP_DISPLAY_GET_PRIVATE (display);
 
@@ -843,22 +839,6 @@ gimp_display_flush_whenever (GimpDisplay *display,
 
       g_clear_pointer (&private->update_region, cairo_region_destroy);
     }
-
-  if (now)
-    {
-      guint64 now = g_get_monotonic_time ();
-
-      if ((now - private->last_flush_now) > FLUSH_NOW_INTERVAL)
-        {
-          gimp_display_shell_flush (gimp_display_get_shell (display), now);
-
-          private->last_flush_now = now;
-        }
-    }
-  else
-    {
-      gimp_display_shell_flush (gimp_display_get_shell (display), now);
-    }
 }
 
 static void
diff --git a/app/display/gimpdisplayshell.c b/app/display/gimpdisplayshell.c
index 08ab3340c0..dd4af58376 100644
--- a/app/display/gimpdisplayshell.c
+++ b/app/display/gimpdisplayshell.c
@@ -1691,39 +1691,32 @@ gimp_display_shell_mask_bounds (GimpDisplayShell *shell,
 }
 
 void
-gimp_display_shell_flush (GimpDisplayShell *shell,
-                          gboolean          now)
+gimp_display_shell_flush (GimpDisplayShell *shell)
 {
+  GimpImageWindow *window;
+  GimpContext     *context;
+
   g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
 
-  if (now)
-    {
-      gdk_window_process_updates (gtk_widget_get_window (shell->canvas),
-                                  FALSE);
-    }
-  else
-    {
-      GimpImageWindow *window = gimp_display_shell_get_window (shell);
-      GimpContext     *context;
+  window = gimp_display_shell_get_window (shell);
 
-      gimp_display_shell_title_update (shell);
+  gimp_display_shell_title_update (shell);
 
-      gimp_canvas_layer_boundary_set_layer (GIMP_CANVAS_LAYER_BOUNDARY (shell->layer_boundary),
-                                            gimp_image_get_active_layer (gimp_display_get_image 
(shell->display)));
+  gimp_canvas_layer_boundary_set_layer (GIMP_CANVAS_LAYER_BOUNDARY (shell->layer_boundary),
+                                        gimp_image_get_active_layer (gimp_display_get_image 
(shell->display)));
 
-      if (window && gimp_image_window_get_active_shell (window) == shell)
-        {
-          GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+  if (window && gimp_image_window_get_active_shell (window) == shell)
+    {
+      GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
 
-          gimp_ui_manager_update (manager, shell->display);
-        }
+      gimp_ui_manager_update (manager, shell->display);
+    }
 
-      context = gimp_get_user_context (shell->display->gimp);
+  context = gimp_get_user_context (shell->display->gimp);
 
-      if (shell->display == gimp_context_get_display (context))
-        {
-          gimp_ui_manager_update (shell->popup_manager, shell->display);
-        }
+  if (shell->display == gimp_context_get_display (context))
+    {
+      gimp_ui_manager_update (shell->popup_manager, shell->display);
     }
 }
 
diff --git a/app/display/gimpdisplayshell.h b/app/display/gimpdisplayshell.h
index ffcd9b376e..9a30d6b08e 100644
--- a/app/display/gimpdisplayshell.h
+++ b/app/display/gimpdisplayshell.h
@@ -293,8 +293,7 @@ gboolean          gimp_display_shell_mask_bounds   (GimpDisplayShell   *shell,
                                                     gint               *width,
                                                     gint               *height);
 
-void              gimp_display_shell_flush         (GimpDisplayShell   *shell,
-                                                    gboolean            now);
+void              gimp_display_shell_flush         (GimpDisplayShell   *shell);
 
 void              gimp_display_shell_pause         (GimpDisplayShell   *shell);
 void              gimp_display_shell_resume        (GimpDisplayShell   *shell);
diff --git a/app/display/gimpstatusbar.c b/app/display/gimpstatusbar.c
index c3f4615197..80afca79a4 100644
--- a/app/display/gimpstatusbar.c
+++ b/app/display/gimpstatusbar.c
@@ -446,7 +446,10 @@ gimp_statusbar_progress_start (GimpProgress *progress,
           statusbar->progress_shown = TRUE;
         }
 
+#if 0
+      /* FIXME flush_expose */
       gimp_widget_flush_expose (bar);
+#endif
 
       gimp_statusbar_override_window_title (statusbar);
 
@@ -503,11 +506,12 @@ gimp_statusbar_progress_set_text (GimpProgress *progress,
 
   if (statusbar->progress_active)
     {
-      GtkWidget *bar = statusbar->progressbar;
-
       gimp_statusbar_replace (statusbar, "progress", NULL, "%s", message);
 
+#if 0
+      /* FIXME flush_expose */
       gimp_widget_flush_expose (bar);
+#endif
 
       gimp_statusbar_override_window_title (statusbar);
     }
@@ -545,7 +549,10 @@ gimp_statusbar_progress_set_value (GimpProgress *progress,
               gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar),
                                              percentage);
 
+#if 0
+              /* FIXME flush_expose */
               gimp_widget_flush_expose (bar);
+#endif
             }
         }
     }
@@ -580,7 +587,10 @@ gimp_statusbar_progress_pulse (GimpProgress *progress)
 
           gtk_progress_bar_pulse (GTK_PROGRESS_BAR (bar));
 
+#if 0
+          /* FIXME flush_expose */
           gimp_widget_flush_expose (bar);
+#endif
         }
     }
 }
diff --git a/app/gegl/gimp-gegl-apply-operation.c b/app/gegl/gimp-gegl-apply-operation.c
index 9b05d949e8..3c61d195a7 100644
--- a/app/gegl/gimp-gegl-apply-operation.c
+++ b/app/gegl/gimp-gegl-apply-operation.c
@@ -75,7 +75,7 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
                                   GeglBuffer          *cache,
                                   const GeglRectangle *valid_rects,
                                   gint                 n_valid_rects,
-                                  gboolean             cancellable)
+                                  gboolean             cancelable)
 {
   GeglNode      *gegl;
   GeglNode      *effect;
@@ -183,13 +183,13 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
             gimp_progress_set_text_literal (progress, undo_desc);
 
           progress_started = FALSE;
-          cancellable      = FALSE;
+          cancelable       = FALSE;
         }
       else
         {
-          gimp_progress_start (progress, cancellable, "%s", undo_desc);
+          gimp_progress_start (progress, cancelable, "%s", undo_desc);
 
-          if (cancellable)
+          if (cancelable)
             g_signal_connect (progress, "cancel",
                               G_CALLBACK (gimp_gegl_apply_operation_cancel),
                               &cancel);
@@ -255,9 +255,8 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
                                             value * rect_pixels) /
                                            (gdouble) all_pixels);
 
-                  if (cancellable)
-                    while (! cancel && g_main_context_pending (NULL))
-                      g_main_context_iteration (NULL, FALSE);
+                  while (! cancel && g_main_context_pending (NULL))
+                    g_main_context_iteration (NULL, FALSE);
                 }
 
               done_pixels += rect_pixels;
@@ -279,9 +278,8 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
             {
               gimp_progress_set_value (progress, value);
 
-              if (cancellable)
-                while (! cancel && g_main_context_pending (NULL))
-                  g_main_context_iteration (NULL, FALSE);
+              while (! cancel && g_main_context_pending (NULL))
+                g_main_context_iteration (NULL, FALSE);
             }
         }
       else
@@ -306,7 +304,7 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
     {
       gimp_progress_end (progress);
 
-      if (cancellable)
+      if (cancelable)
         g_signal_handlers_disconnect_by_func (progress,
                                               gimp_gegl_apply_operation_cancel,
                                               &cancel);
diff --git a/app/gegl/gimp-gegl-apply-operation.h b/app/gegl/gimp-gegl-apply-operation.h
index b803715ac0..9ca6bc5dd4 100644
--- a/app/gegl/gimp-gegl-apply-operation.h
+++ b/app/gegl/gimp-gegl-apply-operation.h
@@ -44,7 +44,7 @@ gboolean   gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
                                              GeglBuffer          *cache,
                                              const GeglRectangle *valid_rects,
                                              gint                 n_valid_rects,
-                                             gboolean             cancellable);
+                                             gboolean             cancelable);
 
 
 /*  apply specific operations  */
diff --git a/app/tools/gimpdrawtool.c b/app/tools/gimpdrawtool.c
index 1d27e28eb0..9db553a7a2 100644
--- a/app/tools/gimpdrawtool.c
+++ b/app/tools/gimpdrawtool.c
@@ -457,10 +457,6 @@ gimp_draw_tool_draw (GimpDrawTool *draw_tool)
       if (draw_tool->item)
         gimp_display_shell_add_tool_item (shell, draw_tool->item);
 
-#if 0
-      gimp_display_shell_flush (shell, TRUE);
-#endif
-
       draw_tool->last_draw_time = g_get_monotonic_time ();
 
 #if 0
diff --git a/app/tools/gimptool-progress.c b/app/tools/gimptool-progress.c
index d05d719247..fca5e73b99 100644
--- a/app/tools/gimptool-progress.c
+++ b/app/tools/gimptool-progress.c
@@ -44,7 +44,7 @@
 /*  local function prototypes  */
 
 static GimpProgress * gimp_tool_progress_start     (GimpProgress        *progress,
-                                                    gboolean             cancellable,
+                                                    gboolean             cancelable,
                                                     const gchar         *message);
 static void           gimp_tool_progress_end       (GimpProgress        *progress);
 static gboolean       gimp_tool_progress_is_active (GimpProgress        *progress);
@@ -84,7 +84,8 @@ gimp_tool_progress_button_press (GtkWidget            *widget,
                                  const GdkEventButton *bevent,
                                  GimpTool             *tool)
 {
-  if (bevent->type   == GDK_BUTTON_PRESS &&
+  if (tool->progress_cancelable          &&
+      bevent->type   == GDK_BUTTON_PRESS &&
       bevent->button == 1)
     {
       GtkWidget        *event_widget;
@@ -115,7 +116,8 @@ gimp_tool_progress_key_press (GtkWidget         *widget,
                               const GdkEventKey *kevent,
                               GimpTool          *tool)
 {
-  if (kevent->keyval == GDK_KEY_Escape)
+  if (tool->progress_cancelable &&
+      kevent->keyval == GDK_KEY_Escape)
     {
       gimp_progress_cancel (GIMP_PROGRESS (tool));
     }
@@ -125,7 +127,7 @@ gimp_tool_progress_key_press (GtkWidget         *widget,
 
 static GimpProgress *
 gimp_tool_progress_start (GimpProgress *progress,
-                          gboolean      cancellable,
+                          gboolean      cancelable,
                           const gchar  *message)
 {
   GimpTool         *tool = GIMP_TOOL (progress);
@@ -150,23 +152,21 @@ gimp_tool_progress_start (GimpProgress *progress,
 
   gimp_progress_start (GIMP_PROGRESS (tool->progress), FALSE,
                        "%s", message);
-  gimp_widget_flush_expose (shell->canvas);
 
   tool->progress_display = tool->display;
 
-  if (cancellable)
-    {
-      tool->progress_grab_widget = gtk_invisible_new ();
-      gtk_widget_show (tool->progress_grab_widget);
-      gtk_grab_add (tool->progress_grab_widget);
-
-      g_signal_connect (tool->progress_grab_widget, "button-press-event",
-                        G_CALLBACK (gimp_tool_progress_button_press),
-                        tool);
-      g_signal_connect (tool->progress_grab_widget, "key-press-event",
-                        G_CALLBACK (gimp_tool_progress_key_press),
-                        tool);
-    }
+  tool->progress_grab_widget = gtk_invisible_new ();
+  gtk_widget_show (tool->progress_grab_widget);
+  gtk_grab_add (tool->progress_grab_widget);
+
+  g_signal_connect (tool->progress_grab_widget, "button-press-event",
+                    G_CALLBACK (gimp_tool_progress_button_press),
+                    tool);
+  g_signal_connect (tool->progress_grab_widget, "key-press-event",
+                    G_CALLBACK (gimp_tool_progress_key_press),
+                    tool);
+
+  tool->progress_cancelable;
 
   return progress;
 }
@@ -183,15 +183,13 @@ gimp_tool_progress_end (GimpProgress *progress)
       gimp_progress_end (GIMP_PROGRESS (tool->progress));
       gimp_display_shell_remove_unrotated_item (shell, tool->progress);
 
-      tool->progress         = NULL;
-      tool->progress_display = NULL;
+      gtk_grab_remove (tool->progress_grab_widget);
+      gtk_widget_destroy (tool->progress_grab_widget);
 
-      if (tool->progress_grab_widget)
-        {
-          gtk_grab_remove (tool->progress_grab_widget);
-          gtk_widget_destroy (tool->progress_grab_widget);
-          tool->progress_grab_widget = NULL;
-        }
+      tool->progress             = NULL;
+      tool->progress_display     = NULL;
+      tool->progress_grab_widget = NULL;
+      tool->progress_cancelable  = FALSE;
     }
 }
 
@@ -210,12 +208,7 @@ gimp_tool_progress_set_text (GimpProgress *progress,
   GimpTool *tool = GIMP_TOOL (progress);
 
   if (tool->progress)
-    {
-      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);
-
-      gimp_progress_set_text_literal (GIMP_PROGRESS (tool->progress), message);
-      gimp_widget_flush_expose (shell->canvas);
-    }
+    gimp_progress_set_text_literal (GIMP_PROGRESS (tool->progress), message);
 }
 
 static void
@@ -225,12 +218,7 @@ gimp_tool_progress_set_value (GimpProgress *progress,
   GimpTool *tool = GIMP_TOOL (progress);
 
   if (tool->progress)
-    {
-      GimpDisplayShell *shell = gimp_display_get_shell (tool->progress_display);
-
-      gimp_progress_set_value (GIMP_PROGRESS (tool->progress), percentage);
-      gimp_widget_flush_expose (shell->canvas);
-    }
+    gimp_progress_set_value (GIMP_PROGRESS (tool->progress), percentage);
 }
 
 static gdouble
diff --git a/app/tools/gimptool.h b/app/tools/gimptool.h
index c8b70fc74c..b646aa54cf 100644
--- a/app/tools/gimptool.h
+++ b/app/tools/gimptool.h
@@ -75,6 +75,7 @@ struct _GimpTool
   GimpCanvasItem  *progress;
   GimpDisplay     *progress_display;
   GtkWidget       *progress_grab_widget;
+  gboolean         progress_cancelable;
 };
 
 struct _GimpToolClass
diff --git a/app/tools/gimptransformtool.c b/app/tools/gimptransformtool.c
index b2230662cd..536d86e1ce 100644
--- a/app/tools/gimptransformtool.c
+++ b/app/tools/gimptransformtool.c
@@ -98,6 +98,9 @@ gimp_transform_tool_real_transform (GimpTransformTool *tr_tool,
   progress = gimp_progress_start (GIMP_PROGRESS (tool), FALSE,
                                   "%s", klass->progress_text);
 
+  while (g_main_context_pending (NULL))
+    g_main_context_iteration (NULL, FALSE);
+
   if (orig_buffer)
     {
       /*  this happens when transforming a selection cut out of a
diff --git a/app/widgets/gimpoverlaychild.c b/app/widgets/gimpoverlaychild.c
index bd5cd8788e..bee00bd300 100644
--- a/app/widgets/gimpoverlaychild.c
+++ b/app/widgets/gimpoverlaychild.c
@@ -374,8 +374,6 @@ gimp_overlay_child_draw (GimpOverlayBox   *box,
         {
           cairo_surface_t *surface;
 
-          gdk_window_process_updates (child->window, FALSE);
-
           surface = gdk_offscreen_window_get_surface (child->window);
 
           cairo_save (cr);
diff --git a/app/widgets/gimpprogressbox.c b/app/widgets/gimpprogressbox.c
index 086a491f28..59f94d71e3 100644
--- a/app/widgets/gimpprogressbox.c
+++ b/app/widgets/gimpprogressbox.c
@@ -135,10 +135,6 @@ gimp_progress_box_progress_start (GimpProgress *progress,
       box->cancellable = cancellable;
       box->value       = 0.0;
 
-      if (gtk_widget_is_drawable (box->progress))
-        gdk_window_process_updates (gtk_widget_get_window (box->progress),
-                                    TRUE);
-
       return progress;
     }
 
@@ -179,10 +175,6 @@ gimp_progress_box_progress_set_text (GimpProgress *progress,
       GimpProgressBox *box = GIMP_PROGRESS_BOX (progress);
 
       gtk_label_set_text (GTK_LABEL (box->label), message);
-
-      if (gtk_widget_is_drawable (box->progress))
-        gdk_window_process_updates (gtk_widget_get_window (box->progress),
-                                    TRUE);
     }
 }
 
@@ -205,8 +197,6 @@ gimp_progress_box_progress_set_value (GimpProgress *progress,
                 (percentage - gtk_progress_bar_get_fraction (bar))) > 1.0)
         {
           gtk_progress_bar_set_fraction (bar, box->value);
-
-          gimp_widget_flush_expose (box->progress);
         }
     }
 }
@@ -231,10 +221,6 @@ gimp_progress_box_progress_pulse (GimpProgress *progress)
       GtkProgressBar  *bar = GTK_PROGRESS_BAR (box->progress);
 
       gtk_progress_bar_pulse (bar);
-
-      if (gtk_widget_is_drawable (box->progress))
-        gdk_window_process_updates (gtk_widget_get_window (box->progress),
-                                    TRUE);
     }
 }
 
diff --git a/app/widgets/gimpwidgets-utils.c b/app/widgets/gimpwidgets-utils.c
index 75f1619c6f..a529bf802f 100644
--- a/app/widgets/gimpwidgets-utils.c
+++ b/app/widgets/gimpwidgets-utils.c
@@ -1505,18 +1505,6 @@ gimp_tools_set_tool_options_gui (GimpToolOptions   *tool_options,
                           widget ? (GDestroyNotify) g_object_unref : NULL);
 }
 
-void
-gimp_widget_flush_expose (GtkWidget *widget)
-{
-  g_return_if_fail (GTK_IS_WIDGET (widget));
-
-  if (! gtk_widget_is_drawable (widget))
-    return;
-
-  gdk_window_process_updates (gtk_widget_get_window (widget), FALSE);
-  gdk_display_flush (gtk_widget_get_display (widget));
-}
-
 gboolean
 gimp_widget_get_fully_opaque (GtkWidget *widget)
 {
diff --git a/app/widgets/gimpwidgets-utils.h b/app/widgets/gimpwidgets-utils.h
index 71db2d85c7..1a2f1489f0 100644
--- a/app/widgets/gimpwidgets-utils.h
+++ b/app/widgets/gimpwidgets-utils.h
@@ -101,8 +101,6 @@ GtkWidget       * gimp_tools_get_tool_options_gui  (GimpToolOptions      *tool_o
 void              gimp_tools_set_tool_options_gui  (GimpToolOptions      *tool_options,
                                                     GtkWidget            *widget);
 
-void              gimp_widget_flush_expose         (GtkWidget            *widget);
-
 gboolean          gimp_widget_get_fully_opaque     (GtkWidget            *widget);
 void              gimp_widget_set_fully_opaque     (GtkWidget            *widget,
                                                     gboolean              fully_opaque);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]