summaryrefslogtreecommitdiffstats
path: root/app/display/gimpstatusbar.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:23:22 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:23:22 +0000
commite42129241681dde7adae7d20697e7b421682fbb4 (patch)
treeaf1fe815a5e639e68e59fabd8395ec69458b3e5e /app/display/gimpstatusbar.c
parentInitial commit. (diff)
downloadgimp-e42129241681dde7adae7d20697e7b421682fbb4.tar.xz
gimp-e42129241681dde7adae7d20697e7b421682fbb4.zip
Adding upstream version 2.10.22.upstream/2.10.22upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'app/display/gimpstatusbar.c')
-rw-r--r--app/display/gimpstatusbar.c1747
1 files changed, 1747 insertions, 0 deletions
diff --git a/app/display/gimpstatusbar.c b/app/display/gimpstatusbar.c
new file mode 100644
index 0000000..0c0ca14
--- /dev/null
+++ b/app/display/gimpstatusbar.c
@@ -0,0 +1,1747 @@
+/* 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 <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpmath/gimpmath.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "display-types.h"
+
+#include "config/gimpdisplayconfig.h"
+
+#include "core/gimpimage.h"
+#include "core/gimpprogress.h"
+
+#include "widgets/gimpuimanager.h"
+#include "widgets/gimpwidgets-utils.h"
+
+#include "gimpdisplay.h"
+#include "gimpdisplayshell.h"
+#include "gimpdisplayshell-scale.h"
+#include "gimpimagewindow.h"
+#include "gimpscalecombobox.h"
+#include "gimpstatusbar.h"
+
+#include "gimp-intl.h"
+
+
+/* maximal width of the string holding the cursor-coordinates */
+#define CURSOR_LEN 256
+
+/* the spacing of the hbox */
+#define HBOX_SPACING 1
+
+/* spacing between the icon and the statusbar label */
+#define ICON_SPACING 2
+
+/* timeout (in milliseconds) for temporary statusbar messages */
+#define MESSAGE_TIMEOUT 8000
+
+/* minimal interval (in microseconds) between progress updates */
+#define MIN_PROGRESS_UPDATE_INTERVAL 50000
+
+
+typedef struct _GimpStatusbarMsg GimpStatusbarMsg;
+
+struct _GimpStatusbarMsg
+{
+ guint context_id;
+ gchar *icon_name;
+ gchar *text;
+};
+
+
+static void gimp_statusbar_progress_iface_init (GimpProgressInterface *iface);
+
+static void gimp_statusbar_dispose (GObject *object);
+static void gimp_statusbar_finalize (GObject *object);
+
+static void gimp_statusbar_screen_changed (GtkWidget *widget,
+ GdkScreen *previous);
+static void gimp_statusbar_style_set (GtkWidget *widget,
+ GtkStyle *prev_style);
+
+static void gimp_statusbar_hbox_size_request (GtkWidget *widget,
+ GtkRequisition *requisition,
+ GimpStatusbar *statusbar);
+
+static GimpProgress *
+ gimp_statusbar_progress_start (GimpProgress *progress,
+ gboolean cancellable,
+ const gchar *message);
+static void gimp_statusbar_progress_end (GimpProgress *progress);
+static gboolean gimp_statusbar_progress_is_active (GimpProgress *progress);
+static void gimp_statusbar_progress_set_text (GimpProgress *progress,
+ const gchar *message);
+static void gimp_statusbar_progress_set_value (GimpProgress *progress,
+ gdouble percentage);
+static gdouble gimp_statusbar_progress_get_value (GimpProgress *progress);
+static void gimp_statusbar_progress_pulse (GimpProgress *progress);
+static gboolean gimp_statusbar_progress_message (GimpProgress *progress,
+ Gimp *gimp,
+ GimpMessageSeverity severity,
+ const gchar *domain,
+ const gchar *message);
+static void gimp_statusbar_progress_canceled (GtkWidget *button,
+ GimpStatusbar *statusbar);
+
+static gboolean gimp_statusbar_label_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ GimpStatusbar *statusbar);
+
+static void gimp_statusbar_update (GimpStatusbar *statusbar);
+static void gimp_statusbar_unit_changed (GimpUnitComboBox *combo,
+ GimpStatusbar *statusbar);
+static void gimp_statusbar_scale_changed (GimpScaleComboBox *combo,
+ GimpStatusbar *statusbar);
+static void gimp_statusbar_scale_activated (GimpScaleComboBox *combo,
+ GimpStatusbar *statusbar);
+static gboolean gimp_statusbar_rotate_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar);
+static gboolean gimp_statusbar_horiz_flip_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar);
+static gboolean gimp_statusbar_vert_flip_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar);
+static void gimp_statusbar_shell_scaled (GimpDisplayShell *shell,
+ GimpStatusbar *statusbar);
+static void gimp_statusbar_shell_rotated (GimpDisplayShell *shell,
+ GimpStatusbar *statusbar);
+static void gimp_statusbar_shell_status_notify(GimpDisplayShell *shell,
+ const GParamSpec *pspec,
+ GimpStatusbar *statusbar);
+static guint gimp_statusbar_get_context_id (GimpStatusbar *statusbar,
+ const gchar *context);
+static gboolean gimp_statusbar_temp_timeout (GimpStatusbar *statusbar);
+
+static void gimp_statusbar_add_message (GimpStatusbar *statusbar,
+ guint context_id,
+ const gchar *icon_name,
+ const gchar *format,
+ va_list args,
+ gboolean move_to_front) G_GNUC_PRINTF (4, 0);
+static void gimp_statusbar_remove_message (GimpStatusbar *statusbar,
+ guint context_id);
+static void gimp_statusbar_msg_free (GimpStatusbarMsg *msg);
+
+static gchar * gimp_statusbar_vprintf (const gchar *format,
+ va_list args) G_GNUC_PRINTF (1, 0);
+
+static GdkPixbuf * gimp_statusbar_load_icon (GimpStatusbar *statusbar,
+ const gchar *icon_name);
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpStatusbar, gimp_statusbar, GTK_TYPE_STATUSBAR,
+ G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROGRESS,
+ gimp_statusbar_progress_iface_init))
+
+#define parent_class gimp_statusbar_parent_class
+
+
+static void
+gimp_statusbar_class_init (GimpStatusbarClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->dispose = gimp_statusbar_dispose;
+ object_class->finalize = gimp_statusbar_finalize;
+
+ widget_class->screen_changed = gimp_statusbar_screen_changed;
+ widget_class->style_set = gimp_statusbar_style_set;
+}
+
+static void
+gimp_statusbar_progress_iface_init (GimpProgressInterface *iface)
+{
+ iface->start = gimp_statusbar_progress_start;
+ iface->end = gimp_statusbar_progress_end;
+ iface->is_active = gimp_statusbar_progress_is_active;
+ iface->set_text = gimp_statusbar_progress_set_text;
+ iface->set_value = gimp_statusbar_progress_set_value;
+ iface->get_value = gimp_statusbar_progress_get_value;
+ iface->pulse = gimp_statusbar_progress_pulse;
+ iface->message = gimp_statusbar_progress_message;
+}
+
+static void
+gimp_statusbar_init (GimpStatusbar *statusbar)
+{
+ GtkWidget *hbox;
+ GtkWidget *hbox2;
+ GtkWidget *image;
+ GtkWidget *label;
+ GimpUnitStore *store;
+ GList *children;
+
+ statusbar->shell = NULL;
+ statusbar->messages = NULL;
+ statusbar->context_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free, NULL);
+ statusbar->seq_context_id = 1;
+
+ statusbar->temp_context_id =
+ gimp_statusbar_get_context_id (statusbar, "gimp-statusbar-temp");
+
+ statusbar->cursor_format_str[0] = '\0';
+ statusbar->cursor_format_str_f[0] = '\0';
+ statusbar->length_format_str[0] = '\0';
+
+ statusbar->progress_active = FALSE;
+ statusbar->progress_shown = FALSE;
+
+ /* remove the message label from the message area */
+ hbox = gtk_statusbar_get_message_area (GTK_STATUSBAR (statusbar));
+ gtk_box_set_spacing (GTK_BOX (hbox), HBOX_SPACING);
+
+ children = gtk_container_get_children (GTK_CONTAINER (hbox));
+ statusbar->label = g_object_ref (children->data);
+ g_list_free (children);
+
+ gtk_container_remove (GTK_CONTAINER (hbox), statusbar->label);
+
+ g_signal_connect (hbox, "size-request",
+ G_CALLBACK (gimp_statusbar_hbox_size_request),
+ statusbar);
+
+ statusbar->cursor_label = gtk_label_new ("8888, 8888");
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->cursor_label, FALSE, FALSE, 0);
+ gtk_widget_show (statusbar->cursor_label);
+
+ store = gimp_unit_store_new (2);
+ statusbar->unit_combo = gimp_unit_combo_box_new_with_model (store);
+ g_object_unref (store);
+
+ /* see issue #2642 */
+ gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (statusbar->unit_combo), 1);
+
+ gtk_widget_set_can_focus (statusbar->unit_combo, FALSE);
+ g_object_set (statusbar->unit_combo, "focus-on-click", FALSE, NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->unit_combo, FALSE, FALSE, 0);
+ gtk_widget_show (statusbar->unit_combo);
+
+ g_signal_connect (statusbar->unit_combo, "changed",
+ G_CALLBACK (gimp_statusbar_unit_changed),
+ statusbar);
+
+ statusbar->scale_combo = gimp_scale_combo_box_new ();
+ gtk_widget_set_can_focus (statusbar->scale_combo, FALSE);
+ g_object_set (statusbar->scale_combo, "focus-on-click", FALSE, NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->scale_combo, FALSE, FALSE, 0);
+ gtk_widget_show (statusbar->scale_combo);
+
+ g_signal_connect (statusbar->scale_combo, "changed",
+ G_CALLBACK (gimp_statusbar_scale_changed),
+ statusbar);
+
+ g_signal_connect (statusbar->scale_combo, "entry-activated",
+ G_CALLBACK (gimp_statusbar_scale_activated),
+ statusbar);
+
+ /* Shell transform status */
+ statusbar->rotate_widget = gtk_event_box_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->rotate_widget,
+ FALSE, FALSE, 1);
+ gtk_widget_show (statusbar->rotate_widget);
+
+ statusbar->rotate_label = gtk_label_new (NULL);
+ gtk_container_add (GTK_CONTAINER (statusbar->rotate_widget),
+ statusbar->rotate_label);
+ gtk_widget_show (statusbar->rotate_label);
+
+ g_signal_connect (statusbar->rotate_widget, "button-press-event",
+ G_CALLBACK (gimp_statusbar_rotate_pressed),
+ statusbar);
+
+ statusbar->horizontal_flip_icon = gtk_event_box_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->horizontal_flip_icon,
+ FALSE, FALSE, 1);
+ gtk_widget_show (statusbar->horizontal_flip_icon);
+
+ image = gtk_image_new_from_icon_name ("gimp-flip-horizontal",
+ GTK_ICON_SIZE_MENU);
+ gtk_container_add (GTK_CONTAINER (statusbar->horizontal_flip_icon), image);
+ gtk_widget_show (image);
+
+ g_signal_connect (statusbar->horizontal_flip_icon, "button-press-event",
+ G_CALLBACK (gimp_statusbar_horiz_flip_pressed),
+ statusbar);
+
+ statusbar->vertical_flip_icon = gtk_event_box_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->vertical_flip_icon,
+ FALSE, FALSE, 1);
+ gtk_widget_show (statusbar->vertical_flip_icon);
+
+ image = gtk_image_new_from_icon_name ("gimp-flip-vertical",
+ GTK_ICON_SIZE_MENU);
+ gtk_container_add (GTK_CONTAINER (statusbar->vertical_flip_icon), image);
+ gtk_widget_show (image);
+
+ g_signal_connect (statusbar->vertical_flip_icon, "button-press-event",
+ G_CALLBACK (gimp_statusbar_vert_flip_pressed),
+ statusbar);
+
+ /* put the label back into the message area */
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->label, TRUE, TRUE, 1);
+
+ g_object_unref (statusbar->label);
+
+ g_signal_connect_after (statusbar->label, "expose-event",
+ G_CALLBACK (gimp_statusbar_label_expose),
+ statusbar);
+
+ statusbar->progressbar = g_object_new (GTK_TYPE_PROGRESS_BAR,
+ "text-xalign", 0.0,
+ "text-yalign", 0.5,
+ "ellipsize", PANGO_ELLIPSIZE_END,
+ NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), statusbar->progressbar, TRUE, TRUE, 0);
+ /* don't show the progress bar */
+
+ /* construct the cancel button's contents manually because we
+ * always want image and label regardless of settings, and we want
+ * a menu size image.
+ */
+ statusbar->cancel_button = gtk_button_new ();
+ gtk_widget_set_can_focus (statusbar->cancel_button, FALSE);
+ gtk_button_set_relief (GTK_BUTTON (statusbar->cancel_button),
+ GTK_RELIEF_NONE);
+ gtk_widget_set_sensitive (statusbar->cancel_button, FALSE);
+ gtk_box_pack_end (GTK_BOX (hbox),
+ statusbar->cancel_button, FALSE, FALSE, 0);
+ /* don't show the cancel button */
+
+ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_container_add (GTK_CONTAINER (statusbar->cancel_button), hbox2);
+ gtk_widget_show (hbox2);
+
+ image = gtk_image_new_from_icon_name ("gtk-cancel", GTK_ICON_SIZE_MENU);
+ gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2);
+ gtk_widget_show (image);
+
+ label = gtk_label_new ("Cancel");
+ gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 2);
+ gtk_widget_show (label);
+
+ g_signal_connect (statusbar->cancel_button, "clicked",
+ G_CALLBACK (gimp_statusbar_progress_canceled),
+ statusbar);
+}
+
+static void
+gimp_statusbar_dispose (GObject *object)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (object);
+
+ if (statusbar->temp_timeout_id)
+ {
+ g_source_remove (statusbar->temp_timeout_id);
+ statusbar->temp_timeout_id = 0;
+ }
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_statusbar_finalize (GObject *object)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (object);
+
+ g_clear_object (&statusbar->icon);
+ g_clear_pointer (&statusbar->icon_hash, g_hash_table_unref);
+
+ g_slist_free_full (statusbar->messages,
+ (GDestroyNotify) gimp_statusbar_msg_free);
+ statusbar->messages = NULL;
+
+ g_clear_pointer (&statusbar->context_ids, g_hash_table_destroy);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_statusbar_screen_changed (GtkWidget *widget,
+ GdkScreen *previous)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (widget);
+
+ if (GTK_WIDGET_CLASS (parent_class)->screen_changed)
+ GTK_WIDGET_CLASS (parent_class)->screen_changed (widget, previous);
+
+ g_clear_pointer (&statusbar->icon_hash, g_hash_table_unref);
+}
+
+static void
+gimp_statusbar_style_set (GtkWidget *widget,
+ GtkStyle *prev_style)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (widget);
+
+ GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
+
+ g_clear_pointer (&statusbar->icon_hash, g_hash_table_unref);
+}
+
+static void
+gimp_statusbar_hbox_size_request (GtkWidget *widget,
+ GtkRequisition *requisition,
+ GimpStatusbar *statusbar)
+{
+ GtkRequisition child_requisition;
+ gint width = 0;
+
+ /* also consider the children which can be invisible */
+
+ gtk_widget_size_request (statusbar->cursor_label, &child_requisition);
+ width += child_requisition.width;
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ gtk_widget_size_request (statusbar->unit_combo, &child_requisition);
+ width += child_requisition.width;
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ gtk_widget_size_request (statusbar->scale_combo, &child_requisition);
+ width += child_requisition.width;
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ gtk_widget_size_request (statusbar->progressbar, &child_requisition);
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ gtk_widget_size_request (statusbar->label, &child_requisition);
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ gtk_widget_size_request (statusbar->cancel_button, &child_requisition);
+ requisition->height = MAX (requisition->height,
+ child_requisition.height);
+
+ requisition->width = MAX (requisition->width, width + 32);
+}
+
+static GimpProgress *
+gimp_statusbar_progress_start (GimpProgress *progress,
+ gboolean cancellable,
+ const gchar *message)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (! statusbar->progress_active)
+ {
+ GtkWidget *bar = statusbar->progressbar;
+ GtkAllocation allocation;
+
+ statusbar->progress_active = TRUE;
+ statusbar->progress_value = 0.0;
+ statusbar->progress_last_update_time = g_get_monotonic_time ();
+
+ gimp_statusbar_push (statusbar, "progress", NULL, "%s", message);
+ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar), 0.0);
+ gtk_widget_set_sensitive (statusbar->cancel_button, cancellable);
+
+ if (cancellable)
+ {
+ if (message)
+ {
+ gchar *tooltip = g_strdup_printf (_("Cancel <i>%s</i>"), message);
+
+ gimp_help_set_help_data_with_markup (statusbar->cancel_button,
+ tooltip, NULL);
+ g_free (tooltip);
+ }
+
+ gtk_widget_show (statusbar->cancel_button);
+ }
+
+ gtk_widget_get_allocation (statusbar->label, &allocation);
+
+ gtk_widget_show (statusbar->progressbar);
+ gtk_widget_hide (statusbar->label);
+
+ /* This shit is needed so that the progress bar is drawn in the
+ * correct place in the cases where we suck completely and run
+ * an operation that blocks the GUI and doesn't let the main
+ * loop run.
+ */
+ gtk_container_resize_children (GTK_CONTAINER (statusbar));
+ gtk_widget_size_allocate (statusbar->progressbar, &allocation);
+
+ if (! gtk_widget_get_visible (GTK_WIDGET (statusbar)))
+ {
+ gtk_widget_show (GTK_WIDGET (statusbar));
+ statusbar->progress_shown = TRUE;
+ }
+
+ gimp_widget_flush_expose (bar);
+
+ gimp_statusbar_override_window_title (statusbar);
+
+ return progress;
+ }
+
+ return NULL;
+}
+
+static void
+gimp_statusbar_progress_end (GimpProgress *progress)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (statusbar->progress_active)
+ {
+ GtkWidget *bar = statusbar->progressbar;
+
+ if (statusbar->progress_shown)
+ {
+ gtk_widget_hide (GTK_WIDGET (statusbar));
+ statusbar->progress_shown = FALSE;
+ }
+
+ statusbar->progress_active = FALSE;
+ statusbar->progress_value = 0.0;
+
+ gtk_widget_hide (bar);
+ gtk_widget_show (statusbar->label);
+
+ gimp_statusbar_pop (statusbar, "progress");
+
+ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar), 0.0);
+ gtk_widget_set_sensitive (statusbar->cancel_button, FALSE);
+ gtk_widget_hide (statusbar->cancel_button);
+
+ gimp_statusbar_restore_window_title (statusbar);
+ }
+}
+
+static gboolean
+gimp_statusbar_progress_is_active (GimpProgress *progress)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ return statusbar->progress_active;
+}
+
+static void
+gimp_statusbar_progress_set_text (GimpProgress *progress,
+ const gchar *message)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (statusbar->progress_active)
+ {
+ GtkWidget *bar = statusbar->progressbar;
+
+ gimp_statusbar_replace (statusbar, "progress", NULL, "%s", message);
+
+ gimp_widget_flush_expose (bar);
+
+ gimp_statusbar_override_window_title (statusbar);
+ }
+}
+
+static void
+gimp_statusbar_progress_set_value (GimpProgress *progress,
+ gdouble percentage)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (statusbar->progress_active)
+ {
+ guint64 time = g_get_monotonic_time ();
+
+ if (time - statusbar->progress_last_update_time >=
+ MIN_PROGRESS_UPDATE_INTERVAL)
+ {
+ GtkWidget *bar = statusbar->progressbar;
+ GtkAllocation allocation;
+ gdouble diff;
+
+ gtk_widget_get_allocation (bar, &allocation);
+
+ statusbar->progress_value = percentage;
+
+ diff = fabs (percentage -
+ gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (bar)));
+
+ /* only update the progress bar if this causes a visible change */
+ if (allocation.width * diff >= 1.0)
+ {
+ statusbar->progress_last_update_time = time;
+
+ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar),
+ percentage);
+
+ gimp_widget_flush_expose (bar);
+ }
+ }
+ }
+}
+
+static gdouble
+gimp_statusbar_progress_get_value (GimpProgress *progress)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (statusbar->progress_active)
+ return statusbar->progress_value;
+
+ return 0.0;
+}
+
+static void
+gimp_statusbar_progress_pulse (GimpProgress *progress)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+
+ if (statusbar->progress_active)
+ {
+ guint64 time = g_get_monotonic_time ();
+
+ if (time - statusbar->progress_last_update_time >=
+ MIN_PROGRESS_UPDATE_INTERVAL)
+ {
+ GtkWidget *bar = statusbar->progressbar;
+
+ statusbar->progress_last_update_time = time;
+
+ gtk_progress_bar_pulse (GTK_PROGRESS_BAR (bar));
+
+ gimp_widget_flush_expose (bar);
+ }
+ }
+}
+
+static gboolean
+gimp_statusbar_progress_message (GimpProgress *progress,
+ Gimp *gimp,
+ GimpMessageSeverity severity,
+ const gchar *domain,
+ const gchar *message)
+{
+ GimpStatusbar *statusbar = GIMP_STATUSBAR (progress);
+ PangoLayout *layout;
+ const gchar *icon_name;
+ gboolean handle_msg = FALSE;
+
+ /* don't accept a message if we are already displaying a more severe one */
+ if (statusbar->temp_timeout_id && statusbar->temp_severity > severity)
+ return FALSE;
+
+ /* we can only handle short one-liners */
+ layout = gtk_widget_create_pango_layout (statusbar->label, message);
+
+ icon_name = gimp_get_message_icon_name (severity);
+
+ if (pango_layout_get_line_count (layout) == 1)
+ {
+ GtkAllocation label_allocation;
+ gint width;
+
+ gtk_widget_get_allocation (statusbar->label, &label_allocation);
+
+ pango_layout_get_pixel_size (layout, &width, NULL);
+
+ if (width < label_allocation.width)
+ {
+ if (icon_name)
+ {
+ GdkPixbuf *pixbuf;
+
+ pixbuf = gimp_statusbar_load_icon (statusbar, icon_name);
+
+ width += ICON_SPACING + gdk_pixbuf_get_width (pixbuf);
+
+ g_object_unref (pixbuf);
+
+ handle_msg = (width < label_allocation.width);
+ }
+ else
+ {
+ handle_msg = TRUE;
+ }
+ }
+ }
+
+ g_object_unref (layout);
+
+ if (handle_msg)
+ gimp_statusbar_push_temp (statusbar, severity, icon_name, "%s", message);
+
+ return handle_msg;
+}
+
+static void
+gimp_statusbar_progress_canceled (GtkWidget *button,
+ GimpStatusbar *statusbar)
+{
+ if (statusbar->progress_active)
+ gimp_progress_cancel (GIMP_PROGRESS (statusbar));
+}
+
+static void
+gimp_statusbar_set_text (GimpStatusbar *statusbar,
+ const gchar *icon_name,
+ const gchar *text)
+{
+ if (statusbar->progress_active)
+ {
+ gtk_progress_bar_set_text (GTK_PROGRESS_BAR (statusbar->progressbar),
+ text);
+ }
+ else
+ {
+ g_clear_object (&statusbar->icon);
+
+ if (icon_name)
+ statusbar->icon = gimp_statusbar_load_icon (statusbar, icon_name);
+
+ if (statusbar->icon)
+ {
+ PangoAttrList *attrs;
+ PangoAttribute *attr;
+ PangoRectangle rect;
+ gchar *tmp;
+
+ tmp = g_strconcat (" ", text, NULL);
+ gtk_label_set_text (GTK_LABEL (statusbar->label), tmp);
+ g_free (tmp);
+
+ rect.x = 0;
+ rect.y = 0;
+ rect.width = PANGO_SCALE * (gdk_pixbuf_get_width (statusbar->icon) +
+ ICON_SPACING);
+ rect.height = 0;
+
+ attrs = pango_attr_list_new ();
+
+ attr = pango_attr_shape_new (&rect, &rect);
+ attr->start_index = 0;
+ attr->end_index = 1;
+ pango_attr_list_insert (attrs, attr);
+
+ gtk_label_set_attributes (GTK_LABEL (statusbar->label), attrs);
+ pango_attr_list_unref (attrs);
+ }
+ else
+ {
+ gtk_label_set_text (GTK_LABEL (statusbar->label), text);
+ gtk_label_set_attributes (GTK_LABEL (statusbar->label), NULL);
+ }
+ }
+}
+
+static void
+gimp_statusbar_update (GimpStatusbar *statusbar)
+{
+ GimpStatusbarMsg *msg = NULL;
+
+ if (statusbar->messages)
+ msg = statusbar->messages->data;
+
+ if (msg && msg->text)
+ {
+ gimp_statusbar_set_text (statusbar, msg->icon_name, msg->text);
+ }
+ else
+ {
+ gimp_statusbar_set_text (statusbar, NULL, "");
+ }
+}
+
+
+/* public functions */
+
+GtkWidget *
+gimp_statusbar_new (void)
+{
+ return g_object_new (GIMP_TYPE_STATUSBAR, NULL);
+}
+
+void
+gimp_statusbar_set_shell (GimpStatusbar *statusbar,
+ GimpDisplayShell *shell)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
+
+ if (shell == statusbar->shell)
+ return;
+
+ if (statusbar->shell)
+ {
+ g_signal_handlers_disconnect_by_func (statusbar->shell,
+ gimp_statusbar_shell_scaled,
+ statusbar);
+ g_signal_handlers_disconnect_by_func (statusbar->shell,
+ gimp_statusbar_shell_rotated,
+ statusbar);
+ g_signal_handlers_disconnect_by_func (statusbar->shell,
+ gimp_statusbar_shell_status_notify,
+ statusbar);
+ }
+
+ statusbar->shell = shell;
+
+ g_signal_connect_object (statusbar->shell, "scaled",
+ G_CALLBACK (gimp_statusbar_shell_scaled),
+ statusbar, 0);
+ g_signal_connect_object (statusbar->shell, "rotated",
+ G_CALLBACK (gimp_statusbar_shell_rotated),
+ statusbar, 0);
+ g_signal_connect_object (statusbar->shell, "notify::status",
+ G_CALLBACK (gimp_statusbar_shell_status_notify),
+ statusbar, 0);
+ gimp_statusbar_shell_rotated (shell, statusbar);
+}
+
+gboolean
+gimp_statusbar_get_visible (GimpStatusbar *statusbar)
+{
+ g_return_val_if_fail (GIMP_IS_STATUSBAR (statusbar), FALSE);
+
+ if (statusbar->progress_shown)
+ return FALSE;
+
+ return gtk_widget_get_visible (GTK_WIDGET (statusbar));
+}
+
+void
+gimp_statusbar_set_visible (GimpStatusbar *statusbar,
+ gboolean visible)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ if (statusbar->progress_shown)
+ {
+ if (visible)
+ {
+ statusbar->progress_shown = FALSE;
+ return;
+ }
+ }
+
+ gtk_widget_set_visible (GTK_WIDGET (statusbar), visible);
+}
+
+void
+gimp_statusbar_empty (GimpStatusbar *statusbar)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ gtk_widget_hide (statusbar->cursor_label);
+ gtk_widget_hide (statusbar->unit_combo);
+ gtk_widget_hide (statusbar->scale_combo);
+ gtk_widget_hide (statusbar->rotate_widget);
+ gtk_widget_hide (statusbar->horizontal_flip_icon);
+ gtk_widget_hide (statusbar->vertical_flip_icon);
+}
+
+void
+gimp_statusbar_fill (GimpStatusbar *statusbar)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ gtk_widget_show (statusbar->cursor_label);
+ gtk_widget_show (statusbar->unit_combo);
+ gtk_widget_show (statusbar->scale_combo);
+ gtk_widget_show (statusbar->rotate_widget);
+ gimp_statusbar_shell_rotated (statusbar->shell, statusbar);
+}
+
+void
+gimp_statusbar_override_window_title (GimpStatusbar *statusbar)
+{
+ GtkWidget *toplevel;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (statusbar));
+
+ if (gimp_image_window_is_iconified (GIMP_IMAGE_WINDOW (toplevel)))
+ {
+ const gchar *message = gimp_statusbar_peek (statusbar, "progress");
+
+ if (message)
+ gtk_window_set_title (GTK_WINDOW (toplevel), message);
+ }
+}
+
+void
+gimp_statusbar_restore_window_title (GimpStatusbar *statusbar)
+{
+ GtkWidget *toplevel;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (statusbar));
+
+ if (gimp_image_window_is_iconified (GIMP_IMAGE_WINDOW (toplevel)))
+ {
+ g_object_notify (G_OBJECT (statusbar->shell), "title");
+ }
+}
+
+void
+gimp_statusbar_push (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ const gchar *format,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (context != NULL);
+ g_return_if_fail (format != NULL);
+
+ va_start (args, format);
+ gimp_statusbar_push_valist (statusbar, context, icon_name, format, args);
+ va_end (args);
+}
+
+void
+gimp_statusbar_push_valist (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ const gchar *format,
+ va_list args)
+{
+ guint context_id;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (context != NULL);
+ g_return_if_fail (format != NULL);
+
+ context_id = gimp_statusbar_get_context_id (statusbar, context);
+
+ gimp_statusbar_add_message (statusbar,
+ context_id,
+ icon_name, format, args,
+ /* move_to_front = */ TRUE);
+}
+
+void
+gimp_statusbar_push_coords (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ GimpCursorPrecision precision,
+ const gchar *title,
+ gdouble x,
+ const gchar *separator,
+ gdouble y,
+ const gchar *help)
+{
+ GimpDisplayShell *shell;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (title != NULL);
+ g_return_if_fail (separator != NULL);
+
+ if (help == NULL)
+ help = "";
+
+ shell = statusbar->shell;
+
+ switch (precision)
+ {
+ case GIMP_CURSOR_PRECISION_PIXEL_CENTER:
+ x = (gint) x;
+ y = (gint) y;
+ break;
+
+ case GIMP_CURSOR_PRECISION_PIXEL_BORDER:
+ x = RINT (x);
+ y = RINT (y);
+ break;
+
+ case GIMP_CURSOR_PRECISION_SUBPIXEL:
+ break;
+ }
+
+ if (shell->unit == GIMP_UNIT_PIXEL)
+ {
+ if (precision == GIMP_CURSOR_PRECISION_SUBPIXEL)
+ {
+ gimp_statusbar_push (statusbar, context,
+ icon_name,
+ statusbar->cursor_format_str_f,
+ title,
+ x,
+ separator,
+ y,
+ help);
+ }
+ else
+ {
+ gimp_statusbar_push (statusbar, context,
+ icon_name,
+ statusbar->cursor_format_str,
+ title,
+ (gint) RINT (x),
+ separator,
+ (gint) RINT (y),
+ help);
+ }
+ }
+ else /* show real world units */
+ {
+ gdouble xres;
+ gdouble yres;
+
+ gimp_image_get_resolution (gimp_display_get_image (shell->display),
+ &xres, &yres);
+
+ gimp_statusbar_push (statusbar, context,
+ icon_name,
+ statusbar->cursor_format_str,
+ title,
+ gimp_pixels_to_units (x, shell->unit, xres),
+ separator,
+ gimp_pixels_to_units (y, shell->unit, yres),
+ help);
+ }
+}
+
+void
+gimp_statusbar_push_length (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ const gchar *title,
+ GimpOrientationType axis,
+ gdouble value,
+ const gchar *help)
+{
+ GimpDisplayShell *shell;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (title != NULL);
+
+ if (help == NULL)
+ help = "";
+
+ shell = statusbar->shell;
+
+ if (shell->unit == GIMP_UNIT_PIXEL)
+ {
+ gimp_statusbar_push (statusbar, context,
+ icon_name,
+ statusbar->length_format_str,
+ title,
+ (gint) RINT (value),
+ help);
+ }
+ else /* show real world units */
+ {
+ gdouble xres;
+ gdouble yres;
+ gdouble resolution;
+
+ gimp_image_get_resolution (gimp_display_get_image (shell->display),
+ &xres, &yres);
+
+ switch (axis)
+ {
+ case GIMP_ORIENTATION_HORIZONTAL:
+ resolution = xres;
+ break;
+
+ case GIMP_ORIENTATION_VERTICAL:
+ resolution = yres;
+ break;
+
+ default:
+ g_return_if_reached ();
+ break;
+ }
+
+ gimp_statusbar_push (statusbar, context,
+ icon_name,
+ statusbar->length_format_str,
+ title,
+ gimp_pixels_to_units (value, shell->unit, resolution),
+ help);
+ }
+}
+
+void
+gimp_statusbar_replace (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ const gchar *format,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (context != NULL);
+ g_return_if_fail (format != NULL);
+
+ va_start (args, format);
+ gimp_statusbar_replace_valist (statusbar, context, icon_name, format, args);
+ va_end (args);
+}
+
+void
+gimp_statusbar_replace_valist (GimpStatusbar *statusbar,
+ const gchar *context,
+ const gchar *icon_name,
+ const gchar *format,
+ va_list args)
+{
+ guint context_id;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (context != NULL);
+ g_return_if_fail (format != NULL);
+
+ context_id = gimp_statusbar_get_context_id (statusbar, context);
+
+ gimp_statusbar_add_message (statusbar,
+ context_id,
+ icon_name, format, args,
+ /* move_to_front = */ FALSE);
+}
+
+const gchar *
+gimp_statusbar_peek (GimpStatusbar *statusbar,
+ const gchar *context)
+{
+ GSList *list;
+ guint context_id;
+
+ g_return_val_if_fail (GIMP_IS_STATUSBAR (statusbar), NULL);
+ g_return_val_if_fail (context != NULL, NULL);
+
+ context_id = gimp_statusbar_get_context_id (statusbar, context);
+
+ for (list = statusbar->messages; list; list = list->next)
+ {
+ GimpStatusbarMsg *msg = list->data;
+
+ if (msg->context_id == context_id)
+ {
+ return msg->text;
+ }
+ }
+
+ return NULL;
+}
+
+void
+gimp_statusbar_pop (GimpStatusbar *statusbar,
+ const gchar *context)
+{
+ guint context_id;
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (context != NULL);
+
+ context_id = gimp_statusbar_get_context_id (statusbar, context);
+
+ gimp_statusbar_remove_message (statusbar,
+ context_id);
+}
+
+void
+gimp_statusbar_push_temp (GimpStatusbar *statusbar,
+ GimpMessageSeverity severity,
+ const gchar *icon_name,
+ const gchar *format,
+ ...)
+{
+ va_list args;
+
+ va_start (args, format);
+ gimp_statusbar_push_temp_valist (statusbar, severity, icon_name, format, args);
+ va_end (args);
+}
+
+void
+gimp_statusbar_push_temp_valist (GimpStatusbar *statusbar,
+ GimpMessageSeverity severity,
+ const gchar *icon_name,
+ const gchar *format,
+ va_list args)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+ g_return_if_fail (severity <= GIMP_MESSAGE_WARNING);
+ g_return_if_fail (format != NULL);
+
+ /* don't accept a message if we are already displaying a more severe one */
+ if (statusbar->temp_timeout_id && statusbar->temp_severity > severity)
+ return;
+
+ if (statusbar->temp_timeout_id)
+ g_source_remove (statusbar->temp_timeout_id);
+
+ statusbar->temp_timeout_id =
+ g_timeout_add (MESSAGE_TIMEOUT,
+ (GSourceFunc) gimp_statusbar_temp_timeout, statusbar);
+
+ statusbar->temp_severity = severity;
+
+ gimp_statusbar_add_message (statusbar,
+ statusbar->temp_context_id,
+ icon_name, format, args,
+ /* move_to_front = */ TRUE);
+
+ if (severity >= GIMP_MESSAGE_WARNING)
+ gimp_widget_blink (statusbar->label);
+}
+
+void
+gimp_statusbar_pop_temp (GimpStatusbar *statusbar)
+{
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ if (statusbar->temp_timeout_id)
+ {
+ g_source_remove (statusbar->temp_timeout_id);
+ statusbar->temp_timeout_id = 0;
+
+ gimp_statusbar_remove_message (statusbar,
+ statusbar->temp_context_id);
+ }
+}
+
+void
+gimp_statusbar_update_cursor (GimpStatusbar *statusbar,
+ GimpCursorPrecision precision,
+ gdouble x,
+ gdouble y)
+{
+ GimpDisplayShell *shell;
+ GimpImage *image;
+ gchar buffer[CURSOR_LEN];
+
+ g_return_if_fail (GIMP_IS_STATUSBAR (statusbar));
+
+ shell = statusbar->shell;
+ image = gimp_display_get_image (shell->display);
+
+ if (! image ||
+ x < 0 ||
+ y < 0 ||
+ x >= gimp_image_get_width (image) ||
+ y >= gimp_image_get_height (image))
+ {
+ gtk_widget_set_sensitive (statusbar->cursor_label, FALSE);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (statusbar->cursor_label, TRUE);
+ }
+
+ switch (precision)
+ {
+ case GIMP_CURSOR_PRECISION_PIXEL_CENTER:
+ x = (gint) x;
+ y = (gint) y;
+ break;
+
+ case GIMP_CURSOR_PRECISION_PIXEL_BORDER:
+ x = RINT (x);
+ y = RINT (y);
+ break;
+
+ case GIMP_CURSOR_PRECISION_SUBPIXEL:
+ break;
+ }
+
+ if (shell->unit == GIMP_UNIT_PIXEL)
+ {
+ if (precision == GIMP_CURSOR_PRECISION_SUBPIXEL)
+ {
+ g_snprintf (buffer, sizeof (buffer),
+ statusbar->cursor_format_str_f,
+ "", x, ", ", y, "");
+ }
+ else
+ {
+ g_snprintf (buffer, sizeof (buffer),
+ statusbar->cursor_format_str,
+ "", (gint) RINT (x), ", ", (gint) RINT (y), "");
+ }
+ }
+ else /* show real world units */
+ {
+ GtkTreeModel *model;
+ GimpUnitStore *store;
+
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (statusbar->unit_combo));
+ store = GIMP_UNIT_STORE (model);
+
+ gimp_unit_store_set_pixel_values (store, x, y);
+ gimp_unit_store_get_values (store, shell->unit, &x, &y);
+
+ g_snprintf (buffer, sizeof (buffer),
+ statusbar->cursor_format_str,
+ "", x, ", ", y, "");
+ }
+
+ gtk_label_set_text (GTK_LABEL (statusbar->cursor_label), buffer);
+}
+
+void
+gimp_statusbar_clear_cursor (GimpStatusbar *statusbar)
+{
+ gtk_label_set_text (GTK_LABEL (statusbar->cursor_label), "");
+ gtk_widget_set_sensitive (statusbar->cursor_label, TRUE);
+}
+
+
+/* private functions */
+
+static gboolean
+gimp_statusbar_label_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ GimpStatusbar *statusbar)
+{
+ if (statusbar->icon)
+ {
+ cairo_t *cr;
+ PangoRectangle rect;
+ gint x, y;
+
+ cr = gdk_cairo_create (event->window);
+
+ gdk_cairo_region (cr, event->region);
+ cairo_clip (cr);
+
+ gtk_label_get_layout_offsets (GTK_LABEL (widget), &x, &y);
+
+ pango_layout_index_to_pos (gtk_label_get_layout (GTK_LABEL (widget)), 0,
+ &rect);
+
+ /* the rectangle width is negative when rendering right-to-left */
+ x += PANGO_PIXELS (rect.x) + (rect.width < 0 ?
+ PANGO_PIXELS (rect.width) : 0);
+ y += PANGO_PIXELS (rect.y);
+
+ gdk_cairo_set_source_pixbuf (cr, statusbar->icon, x, y);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+ }
+
+ return FALSE;
+}
+
+static void
+gimp_statusbar_shell_scaled (GimpDisplayShell *shell,
+ GimpStatusbar *statusbar)
+{
+ static PangoLayout *layout = NULL;
+
+ GimpImage *image = gimp_display_get_image (shell->display);
+ GtkTreeModel *model;
+ const gchar *text;
+ gint image_width;
+ gint image_height;
+ gdouble image_xres;
+ gdouble image_yres;
+ gint width;
+
+ if (image)
+ {
+ image_width = gimp_image_get_width (image);
+ image_height = gimp_image_get_height (image);
+ gimp_image_get_resolution (image, &image_xres, &image_yres);
+ }
+ else
+ {
+ image_width = shell->disp_width;
+ image_height = shell->disp_height;
+ image_xres = shell->display->config->monitor_xres;
+ image_yres = shell->display->config->monitor_yres;
+ }
+
+ g_signal_handlers_block_by_func (statusbar->scale_combo,
+ gimp_statusbar_scale_changed, statusbar);
+ gimp_scale_combo_box_set_scale (GIMP_SCALE_COMBO_BOX (statusbar->scale_combo),
+ gimp_zoom_model_get_factor (shell->zoom));
+ g_signal_handlers_unblock_by_func (statusbar->scale_combo,
+ gimp_statusbar_scale_changed, statusbar);
+
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (statusbar->unit_combo));
+ gimp_unit_store_set_resolutions (GIMP_UNIT_STORE (model),
+ image_xres, image_yres);
+
+ g_signal_handlers_block_by_func (statusbar->unit_combo,
+ gimp_statusbar_unit_changed, statusbar);
+ gimp_unit_combo_box_set_active (GIMP_UNIT_COMBO_BOX (statusbar->unit_combo),
+ shell->unit);
+ g_signal_handlers_unblock_by_func (statusbar->unit_combo,
+ gimp_statusbar_unit_changed, statusbar);
+
+ if (shell->unit == GIMP_UNIT_PIXEL)
+ {
+ g_snprintf (statusbar->cursor_format_str,
+ sizeof (statusbar->cursor_format_str),
+ "%%s%%d%%s%%d%%s");
+ g_snprintf (statusbar->cursor_format_str_f,
+ sizeof (statusbar->cursor_format_str_f),
+ "%%s%%.1f%%s%%.1f%%s");
+ g_snprintf (statusbar->length_format_str,
+ sizeof (statusbar->length_format_str),
+ "%%s%%d%%s");
+ }
+ else /* show real world units */
+ {
+ gint w_digits;
+ gint h_digits;
+
+ w_digits = gimp_unit_get_scaled_digits (shell->unit, image_xres);
+ h_digits = gimp_unit_get_scaled_digits (shell->unit, image_yres);
+
+ g_snprintf (statusbar->cursor_format_str,
+ sizeof (statusbar->cursor_format_str),
+ "%%s%%.%df%%s%%.%df%%s",
+ w_digits, h_digits);
+ strcpy (statusbar->cursor_format_str_f, statusbar->cursor_format_str);
+ g_snprintf (statusbar->length_format_str,
+ sizeof (statusbar->length_format_str),
+ "%%s%%.%df%%s", MAX (w_digits, h_digits));
+ }
+
+ gimp_statusbar_update_cursor (statusbar, GIMP_CURSOR_PRECISION_SUBPIXEL,
+ -image_width, -image_height);
+
+ text = gtk_label_get_text (GTK_LABEL (statusbar->cursor_label));
+
+ /* one static layout for all displays should be fine */
+ if (! layout)
+ layout = gtk_widget_create_pango_layout (statusbar->cursor_label, NULL);
+
+ pango_layout_set_text (layout, text, -1);
+ pango_layout_get_pixel_size (layout, &width, NULL);
+
+ gtk_widget_set_size_request (statusbar->cursor_label, width, -1);
+
+ gimp_statusbar_clear_cursor (statusbar);
+}
+
+static void
+gimp_statusbar_shell_rotated (GimpDisplayShell *shell,
+ GimpStatusbar *statusbar)
+{
+ if (shell->rotate_angle != 0.0)
+ {
+ /* Degree symbol U+00B0. There are no spaces between the value and the
+ * unit for angular rotation.
+ */
+ gchar *text = g_strdup_printf (" %.2f\xC2\xB0", shell->rotate_angle);
+
+ gtk_label_set_text (GTK_LABEL (statusbar->rotate_label), text);
+ g_free (text);
+
+ gtk_widget_show (statusbar->rotate_widget);
+ }
+ else
+ {
+ gtk_widget_hide (statusbar->rotate_widget);
+ }
+
+ if (shell->flip_horizontally)
+ gtk_widget_show (statusbar->horizontal_flip_icon);
+ else
+ gtk_widget_hide (statusbar->horizontal_flip_icon);
+
+ if (shell->flip_vertically)
+ gtk_widget_show (statusbar->vertical_flip_icon);
+ else
+ gtk_widget_hide (statusbar->vertical_flip_icon);
+}
+
+static void
+gimp_statusbar_shell_status_notify (GimpDisplayShell *shell,
+ const GParamSpec *pspec,
+ GimpStatusbar *statusbar)
+{
+ gimp_statusbar_replace (statusbar, "title",
+ NULL, "%s", shell->status);
+}
+
+static void
+gimp_statusbar_unit_changed (GimpUnitComboBox *combo,
+ GimpStatusbar *statusbar)
+{
+ gimp_display_shell_set_unit (statusbar->shell,
+ gimp_unit_combo_box_get_active (combo));
+}
+
+static void
+gimp_statusbar_scale_changed (GimpScaleComboBox *combo,
+ GimpStatusbar *statusbar)
+{
+ gimp_display_shell_scale (statusbar->shell,
+ GIMP_ZOOM_TO,
+ gimp_scale_combo_box_get_scale (combo),
+ GIMP_ZOOM_FOCUS_BEST_GUESS);
+}
+
+static void
+gimp_statusbar_scale_activated (GimpScaleComboBox *combo,
+ GimpStatusbar *statusbar)
+{
+ gtk_widget_grab_focus (statusbar->shell->canvas);
+}
+
+static gboolean
+gimp_statusbar_rotate_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar)
+{
+ GimpImageWindow *window = gimp_display_shell_get_window (statusbar->shell);
+ GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+
+ gimp_ui_manager_activate_action (manager, "view", "view-rotate-other");
+ return FALSE;
+}
+
+static gboolean
+gimp_statusbar_horiz_flip_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar)
+{
+ GimpImageWindow *window = gimp_display_shell_get_window (statusbar->shell);
+ GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+
+ gimp_ui_manager_activate_action (manager, "view", "view-flip-horizontally");
+
+ return FALSE;
+}
+
+static gboolean
+gimp_statusbar_vert_flip_pressed (GtkWidget *event_box,
+ GdkEvent *event,
+ GimpStatusbar *statusbar)
+{
+ GimpImageWindow *window = gimp_display_shell_get_window (statusbar->shell);
+ GimpUIManager *manager = gimp_image_window_get_ui_manager (window);
+
+ gimp_ui_manager_activate_action (manager, "view", "view-flip-vertically");
+
+ return FALSE;
+}
+
+static guint
+gimp_statusbar_get_context_id (GimpStatusbar *statusbar,
+ const gchar *context)
+{
+ guint id = GPOINTER_TO_UINT (g_hash_table_lookup (statusbar->context_ids,
+ context));
+
+ if (! id)
+ {
+ id = statusbar->seq_context_id++;
+
+ g_hash_table_insert (statusbar->context_ids,
+ g_strdup (context), GUINT_TO_POINTER (id));
+ }
+
+ return id;
+}
+
+static gboolean
+gimp_statusbar_temp_timeout (GimpStatusbar *statusbar)
+{
+ gimp_statusbar_pop_temp (statusbar);
+
+ return FALSE;
+}
+
+static void
+gimp_statusbar_add_message (GimpStatusbar *statusbar,
+ guint context_id,
+ const gchar *icon_name,
+ const gchar *format,
+ va_list args,
+ gboolean move_to_front)
+{
+ gchar *message;
+ GSList *list;
+ GimpStatusbarMsg *msg;
+ gint position;
+
+ message = gimp_statusbar_vprintf (format, args);
+
+ for (list = statusbar->messages; list; list = g_slist_next (list))
+ {
+ msg = list->data;
+
+ if (msg->context_id == context_id)
+ {
+ gboolean is_front_message = (list == statusbar->messages);
+
+ if ((is_front_message || ! move_to_front) &&
+ strcmp (msg->text, message) == 0 &&
+ g_strcmp0 (msg->icon_name, icon_name) == 0)
+ {
+ g_free (message);
+ return;
+ }
+
+ if (move_to_front)
+ {
+ statusbar->messages = g_slist_remove (statusbar->messages, msg);
+ gimp_statusbar_msg_free (msg);
+
+ break;
+ }
+ else
+ {
+ g_free (msg->icon_name);
+ msg->icon_name = g_strdup (icon_name);
+
+ g_free (msg->text);
+ msg->text = message;
+
+ if (is_front_message)
+ gimp_statusbar_update (statusbar);
+
+ return;
+ }
+ }
+ }
+
+ msg = g_slice_new (GimpStatusbarMsg);
+
+ msg->context_id = context_id;
+ msg->icon_name = g_strdup (icon_name);
+ msg->text = message;
+
+ /* find the position at which to insert the new message */
+ position = 0;
+ /* progress messages are always at the front of the list */
+ if (! (statusbar->progress_active &&
+ context_id == gimp_statusbar_get_context_id (statusbar, "progress")))
+ {
+ if (statusbar->progress_active)
+ position++;
+
+ /* temporary messages are in front of all other non-progress messages */
+ if (statusbar->temp_timeout_id &&
+ context_id != statusbar->temp_context_id)
+ position++;
+ }
+
+ statusbar->messages = g_slist_insert (statusbar->messages, msg, position);
+
+ if (position == 0)
+ gimp_statusbar_update (statusbar);
+}
+
+static void
+gimp_statusbar_remove_message (GimpStatusbar *statusbar,
+ guint context_id)
+{
+ GSList *list;
+ gboolean needs_update = FALSE;
+
+ for (list = statusbar->messages; list; list = g_slist_next (list))
+ {
+ GimpStatusbarMsg *msg = list->data;
+
+ if (msg->context_id == context_id)
+ {
+ needs_update = (list == statusbar->messages);
+
+ statusbar->messages = g_slist_remove (statusbar->messages, msg);
+ gimp_statusbar_msg_free (msg);
+
+ break;
+ }
+ }
+
+ if (needs_update)
+ gimp_statusbar_update (statusbar);
+}
+
+static void
+gimp_statusbar_msg_free (GimpStatusbarMsg *msg)
+{
+ g_free (msg->icon_name);
+ g_free (msg->text);
+
+ g_slice_free (GimpStatusbarMsg, msg);
+}
+
+static gchar *
+gimp_statusbar_vprintf (const gchar *format,
+ va_list args)
+{
+ gchar *message;
+ gchar *newline;
+
+ message = g_strdup_vprintf (format, args);
+
+ /* guard us from multi-line strings */
+ newline = strchr (message, '\r');
+ if (newline)
+ *newline = '\0';
+
+ newline = strchr (message, '\n');
+ if (newline)
+ *newline = '\0';
+
+ return message;
+}
+
+static GdkPixbuf *
+gimp_statusbar_load_icon (GimpStatusbar *statusbar,
+ const gchar *icon_name)
+{
+ GdkPixbuf *icon;
+
+ if (G_UNLIKELY (! statusbar->icon_hash))
+ {
+ statusbar->icon_hash =
+ g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ (GDestroyNotify) g_free,
+ (GDestroyNotify) g_object_unref);
+ }
+
+ icon = g_hash_table_lookup (statusbar->icon_hash, icon_name);
+
+ if (icon)
+ return g_object_ref (icon);
+
+ icon = gimp_widget_load_icon (statusbar->label, icon_name, 16);
+
+ /* this is not optimal but so what */
+ if (g_hash_table_size (statusbar->icon_hash) > 16)
+ g_hash_table_remove_all (statusbar->icon_hash);
+
+ g_hash_table_insert (statusbar->icon_hash,
+ g_strdup (icon_name), g_object_ref (icon));
+
+ return icon;
+}