summaryrefslogtreecommitdiffstats
path: root/eel/eel-stock-dialogs.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--eel/eel-stock-dialogs.c539
1 files changed, 539 insertions, 0 deletions
diff --git a/eel/eel-stock-dialogs.c b/eel/eel-stock-dialogs.c
new file mode 100644
index 0000000..499af99
--- /dev/null
+++ b/eel/eel-stock-dialogs.c
@@ -0,0 +1,539 @@
+/* eel-stock-dialogs.c: Various standard dialogs for Eel.
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ *
+ * The Gnome Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * The Gnome Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB. If not,
+ * see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Darin Adler <darin@eazel.com>
+ */
+
+#include <config.h>
+#include "eel-stock-dialogs.h"
+
+#include "eel-glib-extensions.h"
+#include "eel-gtk-extensions.h"
+
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+
+#define TIMED_WAIT_STANDARD_DURATION 2000
+#define TIMED_WAIT_MIN_TIME_UP 3000
+
+#define TIMED_WAIT_MINIMUM_DIALOG_WIDTH 300
+
+#define RESPONSE_DETAILS 1000
+
+typedef struct
+{
+ EelCancelCallback cancel_callback;
+ gpointer callback_data;
+
+ /* Parameters for creation of the window. */
+ char *wait_message;
+ GtkWindow *parent_window;
+
+ /* Timer to determine when we need to create the window. */
+ guint timeout_handler_id;
+
+ /* Window, once it's created. */
+ GtkDialog *dialog;
+
+ /* system time (microseconds) when dialog was created */
+ gint64 dialog_creation_time;
+} TimedWait;
+
+static GHashTable *timed_wait_hash_table;
+
+static void timed_wait_dialog_destroy_callback (GtkWidget *object,
+ gpointer callback_data);
+
+static guint
+timed_wait_hash (gconstpointer value)
+{
+ const TimedWait *wait;
+
+ wait = value;
+
+ return GPOINTER_TO_UINT (wait->cancel_callback)
+ ^ GPOINTER_TO_UINT (wait->callback_data);
+}
+
+static gboolean
+timed_wait_hash_equal (gconstpointer value1,
+ gconstpointer value2)
+{
+ const TimedWait *wait1, *wait2;
+
+ wait1 = value1;
+ wait2 = value2;
+
+ return wait1->cancel_callback == wait2->cancel_callback
+ && wait1->callback_data == wait2->callback_data;
+}
+
+static void
+timed_wait_delayed_close_destroy_dialog_callback (GtkWidget *object,
+ gpointer callback_data)
+{
+ g_source_remove (GPOINTER_TO_UINT (callback_data));
+}
+
+static gboolean
+timed_wait_delayed_close_timeout_callback (gpointer callback_data)
+{
+ guint handler_id;
+
+ handler_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (callback_data),
+ "eel-stock-dialogs/delayed_close_handler_timeout_id"));
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (callback_data),
+ G_CALLBACK (timed_wait_delayed_close_destroy_dialog_callback),
+ GUINT_TO_POINTER (handler_id));
+
+ gtk_widget_destroy (GTK_WIDGET (callback_data));
+
+ return FALSE;
+}
+
+static void
+timed_wait_free (TimedWait *wait)
+{
+ guint delayed_close_handler_id;
+ guint64 time_up;
+
+ g_assert (g_hash_table_lookup (timed_wait_hash_table, wait) != NULL);
+
+ g_hash_table_remove (timed_wait_hash_table, wait);
+
+ g_free (wait->wait_message);
+ if (wait->parent_window != NULL)
+ {
+ g_object_unref (wait->parent_window);
+ }
+ if (wait->timeout_handler_id != 0)
+ {
+ g_source_remove (wait->timeout_handler_id);
+ }
+ if (wait->dialog != NULL)
+ {
+ /* Make sure to detach from the "destroy" signal, or we'll
+ * double-free.
+ */
+ g_signal_handlers_disconnect_by_func (G_OBJECT (wait->dialog),
+ G_CALLBACK (timed_wait_dialog_destroy_callback),
+ wait);
+
+ /* compute time up in milliseconds */
+ time_up = (g_get_monotonic_time () - wait->dialog_creation_time) / 1000;
+
+ if (time_up < TIMED_WAIT_MIN_TIME_UP)
+ {
+ delayed_close_handler_id = g_timeout_add (TIMED_WAIT_MIN_TIME_UP - time_up,
+ timed_wait_delayed_close_timeout_callback,
+ wait->dialog);
+ g_object_set_data (G_OBJECT (wait->dialog),
+ "eel-stock-dialogs/delayed_close_handler_timeout_id",
+ GUINT_TO_POINTER (delayed_close_handler_id));
+ g_signal_connect (wait->dialog, "destroy",
+ G_CALLBACK (timed_wait_delayed_close_destroy_dialog_callback),
+ GUINT_TO_POINTER (delayed_close_handler_id));
+ }
+ else
+ {
+ gtk_widget_destroy (GTK_WIDGET (wait->dialog));
+ }
+ }
+
+ /* And the wait object itself. */
+ g_free (wait);
+}
+
+static void
+timed_wait_dialog_destroy_callback (GtkWidget *object,
+ gpointer callback_data)
+{
+ TimedWait *wait;
+
+ wait = callback_data;
+
+ g_assert (GTK_DIALOG (object) == wait->dialog);
+
+ wait->dialog = NULL;
+
+ /* When there's no cancel_callback, the originator will/must
+ * call eel_timed_wait_stop which will call timed_wait_free.
+ */
+
+ if (wait->cancel_callback != NULL)
+ {
+ (*wait->cancel_callback)(wait->callback_data);
+ timed_wait_free (wait);
+ }
+}
+
+static void
+trash_dialog_response_callback (GtkDialog *dialog,
+ int response_id,
+ TimedWait *wait)
+{
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+static gboolean
+timed_wait_callback (gpointer callback_data)
+{
+ TimedWait *wait;
+ GtkDialog *dialog;
+ const char *button;
+
+ wait = callback_data;
+
+ /* Put up the timed wait window. */
+ button = wait->cancel_callback != NULL ? _("_Cancel") : ("_OK");
+ dialog = GTK_DIALOG (gtk_message_dialog_new (wait->parent_window,
+ 0,
+ GTK_MESSAGE_INFO,
+ GTK_BUTTONS_NONE,
+ NULL));
+
+ g_object_set (dialog,
+ "text", wait->wait_message,
+ "secondary-text", _("You can stop this operation by clicking cancel."),
+ NULL);
+
+ gtk_dialog_add_button (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK);
+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+
+ /* The contents are often very small, causing tiny little
+ * dialogs with their titles clipped if you just let gtk
+ * sizing do its thing. This enforces a minimum width to
+ * make it more likely that the title won't be clipped.
+ */
+ gtk_window_set_default_size (GTK_WINDOW (dialog),
+ TIMED_WAIT_MINIMUM_DIALOG_WIDTH,
+ -1);
+ wait->dialog_creation_time = g_get_monotonic_time ();
+ gtk_widget_show (GTK_WIDGET (dialog));
+
+ /* FIXME bugzilla.eazel.com 2441:
+ * Could parent here, but it's complicated because we
+ * don't want this window to go away just because the parent
+ * would go away first.
+ */
+
+ /* Make the dialog cancel the timed wait when it goes away.
+ * Connect to "destroy" instead of "response" since we want
+ * to be called no matter how the dialog goes away.
+ */
+ g_signal_connect (dialog, "destroy",
+ G_CALLBACK (timed_wait_dialog_destroy_callback),
+ wait);
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (trash_dialog_response_callback),
+ wait);
+
+ wait->timeout_handler_id = 0;
+ wait->dialog = dialog;
+
+ return FALSE;
+}
+
+void
+eel_timed_wait_start_with_duration (int duration,
+ EelCancelCallback cancel_callback,
+ gpointer callback_data,
+ const char *wait_message,
+ GtkWindow *parent_window)
+{
+ TimedWait *wait;
+
+ g_return_if_fail (callback_data != NULL);
+ g_return_if_fail (wait_message != NULL);
+ g_return_if_fail (parent_window == NULL || GTK_IS_WINDOW (parent_window));
+
+ /* Create the timed wait record. */
+ wait = g_new0 (TimedWait, 1);
+ wait->wait_message = g_strdup (wait_message);
+ wait->cancel_callback = cancel_callback;
+ wait->callback_data = callback_data;
+ wait->parent_window = parent_window;
+
+ if (parent_window != NULL)
+ {
+ g_object_ref (parent_window);
+ }
+
+ /* Start the timer. */
+ wait->timeout_handler_id = g_timeout_add (duration, timed_wait_callback, wait);
+
+ /* Put in the hash table so we can find it later. */
+ if (timed_wait_hash_table == NULL)
+ {
+ timed_wait_hash_table = g_hash_table_new (timed_wait_hash, timed_wait_hash_equal);
+ }
+ g_assert (g_hash_table_lookup (timed_wait_hash_table, wait) == NULL);
+ g_hash_table_insert (timed_wait_hash_table, wait, wait);
+ g_assert (g_hash_table_lookup (timed_wait_hash_table, wait) == wait);
+}
+
+void
+eel_timed_wait_start (EelCancelCallback cancel_callback,
+ gpointer callback_data,
+ const char *wait_message,
+ GtkWindow *parent_window)
+{
+ eel_timed_wait_start_with_duration
+ (TIMED_WAIT_STANDARD_DURATION,
+ cancel_callback, callback_data,
+ wait_message, parent_window);
+}
+
+void
+eel_timed_wait_stop (EelCancelCallback cancel_callback,
+ gpointer callback_data)
+{
+ TimedWait key;
+ TimedWait *wait;
+
+ g_return_if_fail (callback_data != NULL);
+
+ key.cancel_callback = cancel_callback;
+ key.callback_data = callback_data;
+ wait = g_hash_table_lookup (timed_wait_hash_table, &key);
+
+ g_return_if_fail (wait != NULL);
+
+ timed_wait_free (wait);
+}
+
+int
+eel_run_simple_dialog (GtkWidget *parent,
+ gboolean ignore_close_box,
+ GtkMessageType message_type,
+ const char *primary_text,
+ const char *secondary_text,
+ ...)
+{
+ va_list button_title_args;
+ const char *button_title;
+ GtkWidget *dialog;
+ GtkWidget *top_widget, *chosen_parent;
+ int result;
+ int response_id;
+
+ /* Parent it if asked to. */
+ chosen_parent = NULL;
+ if (parent != NULL)
+ {
+ top_widget = gtk_widget_get_toplevel (parent);
+ if (GTK_IS_WINDOW (top_widget))
+ {
+ chosen_parent = top_widget;
+ }
+ }
+
+ /* Create the dialog. */
+ dialog = gtk_message_dialog_new (GTK_WINDOW (chosen_parent),
+ 0,
+ message_type,
+ GTK_BUTTONS_NONE,
+ NULL);
+
+ g_object_set (dialog,
+ "text", primary_text,
+ "secondary-text", secondary_text,
+ NULL);
+
+ va_start (button_title_args, secondary_text);
+ response_id = 0;
+ while (1)
+ {
+ button_title = va_arg (button_title_args, const char *);
+ if (button_title == NULL)
+ {
+ break;
+ }
+ gtk_dialog_add_button (GTK_DIALOG (dialog), button_title, response_id);
+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), response_id);
+ response_id++;
+ }
+ va_end (button_title_args);
+
+ /* Run it. */
+ gtk_widget_show (dialog);
+ result = gtk_dialog_run (GTK_DIALOG (dialog));
+ while ((result == GTK_RESPONSE_NONE || result == GTK_RESPONSE_DELETE_EVENT) && ignore_close_box)
+ {
+ gtk_widget_show (GTK_WIDGET (dialog));
+ result = gtk_dialog_run (GTK_DIALOG (dialog));
+ }
+ gtk_widget_destroy (dialog);
+
+ return result;
+}
+
+static GtkDialog *
+create_message_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkMessageType type,
+ GtkButtonsType buttons_type,
+ GtkWindow *parent)
+{
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (parent,
+ 0,
+ type,
+ buttons_type,
+ NULL);
+ if (parent)
+ {
+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+ }
+
+ g_object_set (dialog,
+ "text", primary_text,
+ "secondary-text", secondary_text,
+ NULL);
+
+ return GTK_DIALOG (dialog);
+}
+
+static GtkDialog *
+show_message_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkMessageType type,
+ GtkButtonsType buttons_type,
+ GtkWindow *parent)
+{
+ GtkDialog *dialog;
+
+ dialog = create_message_dialog (primary_text, secondary_text, type,
+ buttons_type, parent);
+ gtk_widget_show (GTK_WIDGET (dialog));
+
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy), NULL);
+
+ return dialog;
+}
+
+static GtkDialog *
+show_ok_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkMessageType type,
+ GtkWindow *parent)
+{
+ GtkDialog *dialog;
+
+ dialog = show_message_dialog (primary_text, secondary_text, type,
+ GTK_BUTTONS_OK, parent);
+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+
+ return dialog;
+}
+
+GtkDialog *
+eel_show_info_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkWindow *parent)
+{
+ return show_ok_dialog (primary_text,
+ secondary_text,
+ GTK_MESSAGE_INFO, parent);
+}
+
+GtkDialog *
+eel_show_warning_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkWindow *parent)
+{
+ return show_ok_dialog (primary_text,
+ secondary_text,
+ GTK_MESSAGE_WARNING, parent);
+}
+
+
+GtkDialog *
+eel_show_error_dialog (const char *primary_text,
+ const char *secondary_text,
+ GtkWindow *parent)
+{
+ return show_ok_dialog (primary_text,
+ secondary_text,
+ GTK_MESSAGE_ERROR, parent);
+}
+
+/**
+ * eel_show_yes_no_dialog:
+ *
+ * Create and show a dialog asking a question with two choices.
+ * The caller needs to set up any necessary callbacks
+ * for the buttons. Use eel_create_question_dialog instead
+ * if any visual changes need to be made, to avoid flashiness.
+ * @question: The text of the question.
+ * @yes_label: The label of the "yes" button.
+ * @no_label: The label of the "no" button.
+ * @parent: The parent window for this dialog.
+ */
+GtkDialog *
+eel_show_yes_no_dialog (const char *primary_text,
+ const char *secondary_text,
+ const char *yes_label,
+ const char *no_label,
+ GtkWindow *parent)
+{
+ GtkDialog *dialog = NULL;
+ dialog = eel_create_question_dialog (primary_text,
+ secondary_text,
+ no_label, GTK_RESPONSE_CANCEL,
+ yes_label, GTK_RESPONSE_YES,
+ GTK_WINDOW (parent));
+ gtk_widget_show (GTK_WIDGET (dialog));
+ return dialog;
+}
+
+/**
+ * eel_create_question_dialog:
+ *
+ * Create a dialog asking a question with at least two choices.
+ * The caller needs to set up any necessary callbacks
+ * for the buttons. The dialog is not yet shown, so that the
+ * caller can add additional buttons or make other visual changes
+ * without causing flashiness.
+ * @question: The text of the question.
+ * @answer_0: The label of the leftmost button (index 0)
+ * @answer_1: The label of the 2nd-to-leftmost button (index 1)
+ * @parent: The parent window for this dialog.
+ */
+GtkDialog *
+eel_create_question_dialog (const char *primary_text,
+ const char *secondary_text,
+ const char *answer_1,
+ int response_1,
+ const char *answer_2,
+ int response_2,
+ GtkWindow *parent)
+{
+ GtkDialog *dialog;
+
+ dialog = create_message_dialog (primary_text,
+ secondary_text,
+ GTK_MESSAGE_QUESTION,
+ GTK_BUTTONS_NONE,
+ parent);
+ gtk_dialog_add_buttons (dialog, answer_1, response_1, answer_2, response_2, NULL);
+ return dialog;
+}