Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 652 insertions, 0 deletions

diff --git a/app/display/gimpdisplayshell-callbacks.c b/app/display/gimpdisplayshell-callbacks.c
new file mode 100644
index 0000000..4b87898
--- /dev/null
+++ b/app/display/gimpdisplayshell-callbacks.c
@@ -0,0 +1,652 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpmath/gimpmath.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "display-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpimage.h"
+#include "core/gimpimage-quick-mask.h"
+
+#include "widgets/gimpcairo-wilber.h"
+#include "widgets/gimpuimanager.h"
+
+#include "gimpcanvasitem.h"
+#include "gimpdisplay.h"
+#include "gimpdisplayshell.h"
+#include "gimpdisplayshell-appearance.h"
+#include "gimpdisplayshell-callbacks.h"
+#include "gimpdisplayshell-draw.h"
+#include "gimpdisplayshell-scale.h"
+#include "gimpdisplayshell-scroll.h"
+#include "gimpdisplayshell-scrollbars.h"
+#include "gimpdisplayshell-selection.h"
+#include "gimpdisplayshell-title.h"
+#include "gimpdisplayshell-transform.h"
+#include "gimpdisplayxfer.h"
+#include "gimpimagewindow.h"
+#include "gimpnavigationeditor.h"
+
+#include "git-version.h"
+
+#include "gimp-intl.h"
+
+
+/*  local function prototypes  */
+
+static void       gimp_display_shell_vadjustment_changed      (GtkAdjustment    *adjustment,
+                                                               GimpDisplayShell *shell);
+static void       gimp_display_shell_hadjustment_changed      (GtkAdjustment    *adjustment,
+                                                               GimpDisplayShell *shell);
+static gboolean   gimp_display_shell_vscrollbar_change_value  (GtkRange         *range,
+                                                               GtkScrollType     scroll,
+                                                               gdouble           value,
+                                                               GimpDisplayShell *shell);
+
+static gboolean   gimp_display_shell_hscrollbar_change_value  (GtkRange         *range,
+                                                               GtkScrollType     scroll,
+                                                               gdouble           value,
+                                                               GimpDisplayShell *shell);
+
+static void       gimp_display_shell_canvas_draw_image        (GimpDisplayShell *shell,
+                                                               cairo_t          *cr);
+static void       gimp_display_shell_canvas_draw_drop_zone    (GimpDisplayShell *shell,
+                                                               cairo_t          *cr);
+
+
+/*  public functions  */
+
+void
+gimp_display_shell_canvas_realize (GtkWidget        *canvas,
+                                   GimpDisplayShell *shell)
+{
+  GimpCanvasPaddingMode padding_mode;
+  GimpRGB               padding_color;
+  GtkAllocation         allocation;
+
+  gtk_widget_grab_focus (canvas);
+
+  gimp_display_shell_get_padding (shell, &padding_mode, &padding_color);
+  gimp_display_shell_set_padding (shell, padding_mode, &padding_color);
+
+  gtk_widget_get_allocation (canvas, &allocation);
+
+  gimp_display_shell_title_update (shell);
+
+  shell->disp_width  = allocation.width;
+  shell->disp_height = allocation.height;
+
+  /*  set up the scrollbar observers  */
+  g_signal_connect (shell->hsbdata, "value-changed",
+                    G_CALLBACK (gimp_display_shell_hadjustment_changed),
+                    shell);
+  g_signal_connect (shell->vsbdata, "value-changed",
+                    G_CALLBACK (gimp_display_shell_vadjustment_changed),
+                    shell);
+
+  g_signal_connect (shell->hsb, "change-value",
+                    G_CALLBACK (gimp_display_shell_hscrollbar_change_value),
+                    shell);
+
+  g_signal_connect (shell->vsb, "change-value",
+                    G_CALLBACK (gimp_display_shell_vscrollbar_change_value),
+                    shell);
+
+  /*  allow shrinking  */
+  gtk_widget_set_size_request (GTK_WIDGET (shell), 0, 0);
+
+  shell->xfer = gimp_display_xfer_realize (GTK_WIDGET(shell));
+
+  /*  HACK: remove with GTK+ 3.x: this unconditionally maps the
+   *  rulers, if configured to be hidden they are never visible to the
+   *  user because they will be hidden again right away.
+   *
+   *  For some obscure reason, having the rulers mapped once prevents
+   *  crashes with tablets and on-canvas dialogs. See bug #784480 and
+   *  all its duplicates.
+   */
+  gtk_widget_show (shell->hrule);
+  gtk_widget_show (shell->vrule);
+}
+
+void
+gimp_display_shell_canvas_realize_after (GtkWidget        *canvas,
+                                         GimpDisplayShell *shell)
+{
+  GimpImageWindow *window = gimp_display_shell_get_window (shell);
+
+  /*  HACK: see above: must go with GTK+ 3.x too. Restore the rulers'
+   *  intended visibility again.
+   */
+  gimp_image_window_suspend_keep_pos (window);
+  gimp_display_shell_appearance_update (shell);
+  gimp_image_window_resume_keep_pos (window);
+}
+
+void
+gimp_display_shell_canvas_size_allocate (GtkWidget        *widget,
+                                         GtkAllocation    *allocation,
+                                         GimpDisplayShell *shell)
+{
+  /*  are we in destruction?  */
+  if (! shell->display || ! gimp_display_get_shell (shell->display))
+    return;
+
+  if ((shell->disp_width  != allocation->width) ||
+      (shell->disp_height != allocation->height))
+    {
+      if (shell->zoom_on_resize   &&
+          shell->disp_width  > 64 &&
+          shell->disp_height > 64 &&
+          allocation->width  > 64 &&
+          allocation->height > 64)
+        {
+          gdouble scale = gimp_zoom_model_get_factor (shell->zoom);
+          gint    offset_x;
+          gint    offset_y;
+
+          /* FIXME: The code is a bit of a mess */
+
+          /*  multiply the zoom_factor with the ratio of the new and
+           *  old canvas diagonals
+           */
+          scale *= (sqrt (SQR (allocation->width) +
+                          SQR (allocation->height)) /
+                    sqrt (SQR (shell->disp_width) +
+                          SQR (shell->disp_height)));
+
+          offset_x = UNSCALEX (shell, shell->offset_x);
+          offset_y = UNSCALEX (shell, shell->offset_y);
+
+          gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, scale);
+
+          shell->offset_x = SCALEX (shell, offset_x);
+          shell->offset_y = SCALEY (shell, offset_y);
+        }
+
+      shell->disp_width  = allocation->width;
+      shell->disp_height = allocation->height;
+
+      /* When we size-allocate due to resize of the top level window,
+       * we want some additional logic. Don't apply it on
+       * zoom_on_resize though.
+       */
+      if (shell->size_allocate_from_configure_event &&
+          ! shell->zoom_on_resize)
+        {
+          gboolean center_horizontally;
+          gboolean center_vertically;
+          gint     target_offset_x;
+          gint     target_offset_y;
+          gint     sw;
+          gint     sh;
+
+          gimp_display_shell_scale_get_image_size (shell, &sw, &sh);
+
+          center_horizontally = sw <= shell->disp_width;
+          center_vertically   = sh <= shell->disp_height;
+
+          if (! gimp_display_shell_get_infinite_canvas (shell))
+            {
+              gimp_display_shell_scroll_center_image (shell,
+                                                      center_horizontally,
+                                                      center_vertically);
+            }
+          else
+            {
+              gimp_display_shell_scroll_center_content (shell,
+                                                        center_horizontally,
+                                                        center_vertically);
+            }
+
+          /* This is basically the best we can do before we get an
+           * API for storing the image offset at the start of an
+           * image window resize using the mouse
+           */
+          target_offset_x = shell->offset_x;
+          target_offset_y = shell->offset_y;
+
+          if (! center_horizontally)
+            {
+              target_offset_x = MAX (shell->offset_x, 0);
+            }
+
+          if (! center_vertically)
+            {
+              target_offset_y = MAX (shell->offset_y, 0);
+            }
+
+          gimp_display_shell_scroll_set_offset (shell,
+                                                target_offset_x,
+                                                target_offset_y);
+        }
+
+      gimp_display_shell_scroll_clamp_and_update (shell);
+      gimp_display_shell_scaled (shell);
+
+      shell->size_allocate_from_configure_event = FALSE;
+    }
+
+  if (shell->size_allocate_center_image)
+    {
+      gimp_display_shell_scroll_center_image (shell, TRUE, TRUE);
+
+      shell->size_allocate_center_image = FALSE;
+    }
+}
+
+gboolean
+gimp_display_shell_canvas_expose (GtkWidget        *widget,
+                                  GdkEventExpose   *eevent,
+                                  GimpDisplayShell *shell)
+{
+  /*  are we in destruction?  */
+  if (! shell->display || ! gimp_display_get_shell (shell->display))
+    return TRUE;
+
+  /*  we will scroll around in the next tick anyway, so we just can as
+   *  well skip the drawing of this frame and wait for the next
+   */
+  if (shell->size_allocate_center_image)
+    return TRUE;
+
+  /*  ignore events on overlays  */
+  if (eevent->window == gtk_widget_get_window (widget))
+    {
+      GimpImage *image = gimp_display_get_image (shell->display);
+      cairo_t   *cr;
+
+      cr = gdk_cairo_create (gtk_widget_get_window (shell->canvas));
+      gdk_cairo_region (cr, eevent->region);
+      cairo_clip (cr);
+
+      /* If we are currently converting the image, it might be in inconsistent
+       * state and should not be redrawn.
+       */
+      if (image != NULL && ! gimp_image_get_converting (image))
+        {
+          gimp_display_shell_canvas_draw_image (shell, cr);
+        }
+      else if (image == NULL)
+        {
+          gimp_display_shell_canvas_draw_drop_zone (shell, cr);
+        }
+
+      cairo_destroy (cr);
+    }
+
+  return FALSE;
+}
+
+gboolean
+gimp_display_shell_origin_button_press (GtkWidget        *widget,
+                                        GdkEventButton   *event,
+                                        GimpDisplayShell *shell)
+{
+  if (! shell->display->gimp->busy)
+    {
+      if (event->type == GDK_BUTTON_PRESS && event->button == 1)
+        {
+          gboolean unused;
+
+          g_signal_emit_by_name (shell, "popup-menu", &unused);
+        }
+    }
+
+  /* Return TRUE to stop signal emission so the button doesn't grab the
+   * pointer away from us.
+   */
+  return TRUE;
+}
+
+gboolean
+gimp_display_shell_quick_mask_button_press (GtkWidget        *widget,
+                                            GdkEventButton   *bevent,
+                                            GimpDisplayShell *shell)
+{
+  if (! gimp_display_get_image (shell->display))
+    return TRUE;
+
+  if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
+    {
+      GimpImageWindow *window = gimp_display_shell_get_window (shell);
+
+      if (window)
+        {
+          GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+
+          gimp_ui_manager_ui_popup (manager,
+                                    "/quick-mask-popup",
+                                    GTK_WIDGET (shell),
+                                    NULL, NULL, NULL, NULL);
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+void
+gimp_display_shell_quick_mask_toggled (GtkWidget        *widget,
+                                       GimpDisplayShell *shell)
+{
+  GimpImage *image  = gimp_display_get_image (shell->display);
+  gboolean   active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+
+  if (active != gimp_image_get_quick_mask_state (image))
+    {
+      GimpImageWindow *window = gimp_display_shell_get_window (shell);
+
+      if (window)
+        {
+          GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+
+          gimp_ui_manager_toggle_action (manager,
+                                         "quick-mask", "quick-mask-toggle",
+                                         active);
+        }
+    }
+}
+
+gboolean
+gimp_display_shell_navigation_button_press (GtkWidget        *widget,
+                                            GdkEventButton   *bevent,
+                                            GimpDisplayShell *shell)
+{
+  if (! gimp_display_get_image (shell->display))
+    return TRUE;
+
+  if (bevent->type == GDK_BUTTON_PRESS && bevent->button == 1)
+    {
+      gimp_navigation_editor_popup (shell, widget, bevent->x, bevent->y);
+    }
+
+  return TRUE;
+}
+
+
+/*  private functions  */
+
+static void
+gimp_display_shell_vadjustment_changed (GtkAdjustment    *adjustment,
+                                        GimpDisplayShell *shell)
+{
+  /*  If we are panning with mouse, scrollbars are to be ignored or
+   *  they will cause jitter in motion
+   */
+  if (! shell->scrolling)
+    gimp_display_shell_scroll (shell,
+                               0,
+                               gtk_adjustment_get_value (adjustment) -
+                               shell->offset_y);
+}
+
+static void
+gimp_display_shell_hadjustment_changed (GtkAdjustment    *adjustment,
+                                        GimpDisplayShell *shell)
+{
+  /* If we are panning with mouse, scrollbars are to be ignored or
+   * they will cause jitter in motion
+   */
+  if (! shell->scrolling)
+    gimp_display_shell_scroll (shell,
+                               gtk_adjustment_get_value (adjustment) -
+                               shell->offset_x,
+                               0);
+}
+
+static gboolean
+gimp_display_shell_hscrollbar_change_value (GtkRange         *range,
+                                            GtkScrollType     scroll,
+                                            gdouble           value,
+                                            GimpDisplayShell *shell)
+{
+  if (! shell->display)
+    return TRUE;
+
+  if ((scroll == GTK_SCROLL_JUMP)          ||
+      (scroll == GTK_SCROLL_PAGE_BACKWARD) ||
+      (scroll == GTK_SCROLL_PAGE_FORWARD))
+    return FALSE;
+
+  g_object_freeze_notify (G_OBJECT (shell->hsbdata));
+
+  gimp_display_shell_scrollbars_setup_horizontal (shell, value);
+
+  g_object_thaw_notify (G_OBJECT (shell->hsbdata)); /* emits "changed" */
+
+  return FALSE;
+}
+
+static gboolean
+gimp_display_shell_vscrollbar_change_value (GtkRange         *range,
+                                            GtkScrollType     scroll,
+                                            gdouble           value,
+                                            GimpDisplayShell *shell)
+{
+  if (! shell->display)
+    return TRUE;
+
+  if ((scroll == GTK_SCROLL_JUMP)          ||
+      (scroll == GTK_SCROLL_PAGE_BACKWARD) ||
+      (scroll == GTK_SCROLL_PAGE_FORWARD))
+    return FALSE;
+
+  g_object_freeze_notify (G_OBJECT (shell->vsbdata));
+
+  gimp_display_shell_scrollbars_setup_vertical (shell, value);
+
+  g_object_thaw_notify (G_OBJECT (shell->vsbdata)); /* emits "changed" */
+
+  return FALSE;
+}
+
+static void
+gimp_display_shell_canvas_draw_image (GimpDisplayShell *shell,
+                                      cairo_t          *cr)
+{
+  cairo_rectangle_list_t *clip_rectangles;
+  GeglRectangle           image_rect;
+  GeglRectangle           rotated_image_rect;
+  GeglRectangle           canvas_rect;
+  cairo_matrix_t          matrix;
+  gdouble                 x1, y1;
+  gdouble                 x2, y2;
+
+  gimp_display_shell_scale_get_image_unrotated_bounding_box (
+    shell,
+    &image_rect.x,
+    &image_rect.y,
+    &image_rect.width,
+    &image_rect.height);
+
+  gimp_display_shell_scale_get_image_unrotated_bounds (
+    shell,
+    &canvas_rect.x,
+    &canvas_rect.y,
+    &canvas_rect.width,
+    &canvas_rect.height);
+
+  /*  the background has already been cleared by GdkWindow
+   */
+
+
+  /*  on top, draw the exposed part of the region that is inside the
+   *  image
+   */
+
+  cairo_save (cr);
+  clip_rectangles = cairo_copy_clip_rectangle_list (cr);
+  cairo_get_matrix (cr, &matrix);
+
+  if (shell->rotate_transform)
+    cairo_transform (cr, shell->rotate_transform);
+
+  if (shell->show_all)
+    {
+      cairo_save (cr);
+
+      if (gimp_display_shell_get_padding_in_show_all (shell))
+        {
+          cairo_rectangle (cr,
+                           canvas_rect.x,
+                           canvas_rect.y,
+                           canvas_rect.width,
+                           canvas_rect.height);
+          cairo_clip (cr);
+        }
+
+      gimp_display_shell_draw_checkerboard (shell, cr);
+
+      cairo_restore (cr);
+    }
+
+  cairo_rectangle (cr,
+                   image_rect.x,
+                   image_rect.y,
+                   image_rect.width,
+                   image_rect.height);
+  cairo_clip (cr);
+
+  gimp_display_shell_rotate_bounds (shell,
+                                    image_rect.x,
+                                    image_rect.y,
+                                    image_rect.x + image_rect.width,
+                                    image_rect.y + image_rect.height,
+                                    &x1, &y1, &x2, &y2);
+
+  rotated_image_rect.x      = floor (x1);
+  rotated_image_rect.y      = floor (y1);
+  rotated_image_rect.width  = ceil  (x2) - rotated_image_rect.x;
+  rotated_image_rect.height = ceil  (y2) - rotated_image_rect.y;
+
+  if (gdk_cairo_get_clip_rectangle (cr, NULL))
+    {
+      gint i;
+
+      if (! shell->show_all)
+        {
+          cairo_save (cr);
+          gimp_display_shell_draw_checkerboard (shell, cr);
+          cairo_restore (cr);
+        }
+
+      if (shell->show_image)
+        {
+          cairo_set_matrix (cr, &matrix);
+
+          for (i = 0; i < clip_rectangles->num_rectangles; i++)
+            {
+              cairo_rectangle_t clip_rect = clip_rectangles->rectangles[i];
+              GeglRectangle     rect;
+
+              rect.x      = floor (clip_rect.x);
+              rect.y      = floor (clip_rect.y);
+              rect.width  = ceil  (clip_rect.x + clip_rect.width)  - rect.x;
+              rect.height = ceil  (clip_rect.y + clip_rect.height) - rect.y;
+
+              if (gegl_rectangle_intersect (&rect, &rect, &rotated_image_rect))
+                {
+                  gimp_display_shell_draw_image (shell, cr,
+                                                 rect.x,     rect.y,
+                                                 rect.width, rect.height);
+                }
+            }
+        }
+    }
+
+  cairo_rectangle_list_destroy (clip_rectangles);
+  cairo_restore (cr);
+
+
+  /*  finally, draw all the remaining image window stuff on top
+   */
+
+  /* draw canvas items */
+  cairo_save (cr);
+
+  if (shell->rotate_transform)
+    cairo_transform (cr, shell->rotate_transform);
+
+  gimp_canvas_item_draw (shell->canvas_item, cr);
+
+  cairo_restore (cr);
+
+  gimp_canvas_item_draw (shell->unrotated_item, cr);
+
+  /* restart (and recalculate) the selection boundaries */
+  gimp_display_shell_selection_draw (shell, cr);
+  gimp_display_shell_selection_restart (shell);
+}
+
+static void
+gimp_display_shell_canvas_draw_drop_zone (GimpDisplayShell *shell,
+                                          cairo_t          *cr)
+{
+  cairo_save (cr);
+
+  gimp_cairo_draw_drop_wilber (shell->canvas, cr, shell->blink);
+
+  cairo_restore (cr);
+
+#ifdef GIMP_UNSTABLE
+  {
+    PangoLayout   *layout;
+    gchar         *msg;
+    GtkAllocation  allocation;
+    gint           width;
+    gint           height;
+    gdouble        scale;
+
+    layout = gtk_widget_create_pango_layout (shell->canvas, NULL);
+
+    msg = g_strdup_printf (_("<big>Unstable Development Version</big>\n\n"
+                             "<small>commit <tt>%s</tt></small>\n\n"
+                             "<small>Please test bugs against "
+                             "latest git master branch\n"
+                             "before reporting them.</small>"),
+                             GIMP_GIT_VERSION_ABBREV);
+    pango_layout_set_markup (layout, msg, -1);
+    g_free (msg);
+    pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
+
+    pango_layout_get_pixel_size (layout, &width, &height);
+    gtk_widget_get_allocation (shell->canvas, &allocation);
+
+    scale = MIN (((gdouble) allocation.width  / 2.0) / (gdouble) width,
+                 ((gdouble) allocation.height / 2.0) / (gdouble) height);
+
+    cairo_move_to (cr,
+                   (allocation.width  - (width  * scale)) / 2,
+                   (allocation.height - (height * scale)) / 2);
+
+    cairo_scale (cr, scale, scale);
+
+    pango_cairo_show_layout (cr, layout);
+
+    g_object_unref (layout);
+  }
+#endif /* GIMP_UNSTABLE */
+}