src/gtk/inputdialog.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2006 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <glib.h>
  25 #include <glib/gi18n.h>
  26 #include <gdk/gdkkeysyms.h>
  27 #include <gtk/gtkmain.h>
  28 #include <gtk/gtkwidget.h>
  29 #include <gtk/gtkdialog.h>
  30 #include <gtk/gtkwindow.h>
  31 #include <gtk/gtksignal.h>
  32 #include <gtk/gtkvbox.h>
  33 #include <gtk/gtkhbox.h>
  34 #include <gtk/gtklabel.h>
  35 #include <gtk/gtkentry.h>
  36 #include <gtk/gtkcombo.h>
  37 #include <gtk/gtkbutton.h>
  38 #include <gtk/gtkhbbox.h>
  39 #include <gtk/gtkstock.h>
  40 #include <gtk/gtkimage.h>
  41
  42 #include "inputdialog.h"
  43 #include "manage_window.h"
  44 #include "gtkutils.h"
  45 #include "utils.h"
  46
  47 #define INPUT_DIALOG_WIDTH      420
  48
  49 typedef enum
  50 {
  51         INPUT_DIALOG_NORMAL,
  52         INPUT_DIALOG_INVISIBLE,
  53         INPUT_DIALOG_COMBO
  54 } InputDialogType;
  55
  56 static gboolean ack;
  57 static gboolean fin;
  58
  59 static InputDialogType type;
  60
  61 static GtkWidget *dialog;
  62 static GtkWidget *msg_title;
  63 static GtkWidget *msg_label;
  64 static GtkWidget *entry;
  65 static GtkWidget *combo;
  66 static GtkWidget *ok_button;
  67 static GtkWidget *icon_q, *icon_p;
  68 static gboolean is_pass = FALSE;
  69 static void input_dialog_create (gboolean is_password);
  70 static gchar *input_dialog_open (const gchar    *title,
  71                                  const gchar    *message,
  72                                  const gchar    *default_string);
  73 static void input_dialog_set    (const gchar    *title,
  74                                  const gchar    *message,
  75                                  const gchar    *default_string);
  76
  77 static void ok_clicked          (GtkWidget      *widget,
  78                                  gpointer        data);
  79 static void cancel_clicked      (GtkWidget      *widget,
  80                                  gpointer        data);
  81 static gint delete_event        (GtkWidget      *widget,
  82                                  GdkEventAny    *event,
  83                                  gpointer        data);
  84 static gboolean key_pressed     (GtkWidget      *widget,
  85                                  GdkEventKey    *event,
  86                                  gpointer        data);
  87 static void entry_activated     (GtkEditable    *editable);
  88 static void combo_activated     (GtkEditable    *editable);
  89
  90
  91 gchar *input_dialog(const gchar *title, const gchar *message,
  92                     const gchar *default_string)
  93 {
  94         if (dialog && GTK_WIDGET_VISIBLE(dialog)) return NULL;
  95
  96         if (!dialog)
  97                 input_dialog_create(FALSE);
  98
  99         type = INPUT_DIALOG_NORMAL;
 100         gtk_widget_hide(combo);
 101         gtk_widget_show(entry);
 102
 103         gtk_widget_show(icon_q);
 104         gtk_widget_hide(icon_p);
 105         is_pass = FALSE;
 106         gtk_entry_set_visibility(GTK_ENTRY(entry), TRUE);
 107
 108         return input_dialog_open(title, message, default_string);
 109 }
 110
 111 gchar *input_dialog_with_invisible(const gchar *title, const gchar *message,
 112                                    const gchar *default_string)
 113 {
 114         if (dialog && GTK_WIDGET_VISIBLE(dialog)) return NULL;
 115
 116         if (!dialog)
 117                 input_dialog_create(TRUE);
 118
 119         type = INPUT_DIALOG_INVISIBLE;
 120         gtk_widget_hide(combo);
 121         gtk_widget_show(entry);
 122
 123         gtk_widget_hide(icon_q);
 124         gtk_widget_show(icon_p);
 125         is_pass = TRUE;
 126         gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
 127
 128         return input_dialog_open(title, message, default_string);
 129 }
 130
 131 gchar *input_dialog_combo(const gchar *title, const gchar *message,
 132                           const gchar *default_string, GList *list,
 133                           gboolean case_sensitive)
 134 {
 135         if (dialog && GTK_WIDGET_VISIBLE(dialog)) return NULL;
 136
 137         if (!dialog)
 138                 input_dialog_create(FALSE);
 139
 140         type = INPUT_DIALOG_COMBO;
 141         gtk_widget_hide(entry);
 142         gtk_widget_show(combo);
 143
 144         gtk_widget_show(icon_q);
 145         gtk_widget_hide(icon_p);
 146         is_pass = FALSE;
 147
 148         if (!list) {
 149                 GList empty_list;
 150
 151                 empty_list.data = (gpointer)"";
 152                 empty_list.next = NULL;
 153                 empty_list.prev = NULL;
 154                 gtk_combo_set_popdown_strings(GTK_COMBO(combo), &empty_list);
 155         } else
 156                 gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
 157
 158         gtk_combo_set_case_sensitive(GTK_COMBO(combo), case_sensitive);
 159
 160         return input_dialog_open(title, message, default_string);
 161 }
 162
 163 gchar *input_dialog_query_password(const gchar *server, const gchar *user)
 164 {
 165         gchar *message;
 166         gchar *pass;
 167
 168         message = g_strdup_printf(_("Input password for %s on %s:"),
 169                                   user, server);
 170         pass = input_dialog_with_invisible(_("Input password"), message, NULL);
 171         g_free(message);
 172
 173         return pass;
 174 }
 175
 176 static void input_dialog_create(gboolean is_password)
 177 {
 178         static PangoFontDescription *font_desc;
 179         GtkWidget *w_hbox;
 180         GtkWidget *hbox;
 181         GtkWidget *vbox;
 182         GtkWidget *cancel_button;
 183         GtkWidget *confirm_area;
 184
 185         dialog = gtk_dialog_new();
 186
 187         gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
 188         gtk_window_set_title(GTK_WINDOW(dialog), "");
 189         gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 190
 191         g_signal_connect(G_OBJECT(dialog), "delete_event",
 192                          G_CALLBACK(delete_event), NULL);
 193         g_signal_connect(G_OBJECT(dialog), "key_press_event",
 194                          G_CALLBACK(key_pressed), NULL);
 195         MANAGE_WINDOW_SIGNALS_CONNECT(dialog);
 196
 197         gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 14);
 198         hbox = gtk_hbox_new (FALSE, 12);
 199         gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
 200         gtk_widget_show (hbox);
 201         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
 202                             FALSE, FALSE, 0);
 203
 204         /* for title label */
 205         w_hbox = gtk_hbox_new(FALSE, 0);
 206
 207         icon_q = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
 208                                 GTK_ICON_SIZE_DIALOG);
 209         gtk_misc_set_alignment (GTK_MISC (icon_q), 0.5, 0.0);
 210         gtk_box_pack_start (GTK_BOX (hbox), icon_q, FALSE, FALSE, 0);
 211         icon_p = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
 212                                 GTK_ICON_SIZE_DIALOG);
 213         gtk_misc_set_alignment (GTK_MISC (icon_p), 0.5, 0.0);
 214         gtk_box_pack_start (GTK_BOX (hbox), icon_p, FALSE, FALSE, 0);
 215
 216         vbox = gtk_vbox_new (FALSE, 12);
 217         gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
 218         gtk_widget_show (vbox);
 219
 220         msg_title = gtk_label_new("");
 221         gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5);
 222         gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT);
 223         gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE);
 224         gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0);
 225         gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE);
 226         if (!font_desc) {
 227                 gint size;
 228
 229                 size = pango_font_description_get_size
 230                         (msg_title->style->font_desc);
 231                 font_desc = pango_font_description_new();
 232                 pango_font_description_set_weight
 233                         (font_desc, PANGO_WEIGHT_BOLD);
 234                 pango_font_description_set_size
 235                         (font_desc, size * PANGO_SCALE_LARGE);
 236         }
 237         if (font_desc)
 238                 gtk_widget_modify_font(msg_title, font_desc);
 239
 240         msg_label = gtk_label_new("");
 241         gtk_misc_set_alignment(GTK_MISC(msg_label), 0, 0.5);
 242         gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_LEFT);
 243         gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 0);
 244         gtk_widget_show(msg_label);
 245
 246         entry = gtk_entry_new();
 247         gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
 248         g_signal_connect(G_OBJECT(entry), "activate",
 249                          G_CALLBACK(entry_activated), NULL);
 250
 251         combo = gtk_combo_new();
 252         gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0);
 253         g_signal_connect(G_OBJECT(GTK_COMBO(combo)->entry), "activate",
 254                          G_CALLBACK(combo_activated), NULL);
 255
 256         hbox = gtk_hbox_new(TRUE, 0);
 257
 258         gtkut_stock_button_set_create(&confirm_area,
 259                                       &cancel_button, GTK_STOCK_CANCEL,
 260                                       &ok_button, GTK_STOCK_OK,
 261                                       NULL, NULL);
 262
 263         gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
 264                          confirm_area, FALSE, FALSE, 0);
 265         gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
 266
 267         gtk_widget_show_all(GTK_DIALOG(dialog)->vbox);
 268
 269         if (is_password)
 270                 gtk_widget_hide(icon_q);
 271         else
 272                 gtk_widget_hide(icon_p);
 273
 274         is_pass = is_password;
 275
 276         gtk_widget_grab_default(ok_button);
 277
 278         g_signal_connect(G_OBJECT(ok_button), "clicked",
 279                          G_CALLBACK(ok_clicked), NULL);
 280         g_signal_connect(G_OBJECT(cancel_button), "clicked",
 281                          G_CALLBACK(cancel_clicked), NULL);
 282 }
 283
 284 static gchar *input_dialog_open(const gchar *title, const gchar *message,
 285                                 const gchar *default_string)
 286 {
 287         gchar *str;
 288
 289         if (dialog && GTK_WIDGET_VISIBLE(dialog)) return NULL;
 290
 291         if (!dialog)
 292                 input_dialog_create(FALSE);
 293
 294         input_dialog_set(title, message, default_string);
 295         gtk_widget_show(dialog);
 296
 297         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
 298         manage_window_set_transient(GTK_WINDOW(dialog));
 299
 300         ack = fin = FALSE;
 301
 302         while (fin == FALSE)
 303                 gtk_main_iteration();
 304
 305         manage_window_focus_out(dialog, NULL, NULL);
 306         gtk_widget_hide(dialog);
 307
 308         if (ack) {
 309                 GtkEditable *editable;
 310
 311                 if (type == INPUT_DIALOG_COMBO)
 312                         editable = GTK_EDITABLE(GTK_COMBO(combo)->entry);
 313                 else
 314                         editable = GTK_EDITABLE(entry);
 315
 316                 str = gtk_editable_get_chars(editable, 0, -1);
 317                 if (str && *str == '\0' && !is_pass) {
 318                         g_free(str);
 319                         str = NULL;
 320                 }
 321         } else
 322                 str = NULL;
 323
 324         GTK_EVENTS_FLUSH();
 325
 326         debug_print("return string = %s\n", str ? str : "(none)");
 327         return str;
 328 }
 329
 330 static void input_dialog_set(const gchar *title, const gchar *message,
 331                              const gchar *default_string)
 332 {
 333         GtkWidget *entry_;
 334
 335         if (type == INPUT_DIALOG_COMBO)
 336                 entry_ = GTK_COMBO(combo)->entry;
 337         else
 338                 entry_ = entry;
 339
 340         gtk_window_set_title(GTK_WINDOW(dialog), title);
 341         gtk_label_set_text(GTK_LABEL(msg_title), title);
 342         gtk_label_set_text(GTK_LABEL(msg_label), message);
 343         if (default_string && *default_string) {
 344                 gtk_entry_set_text(GTK_ENTRY(entry_), default_string);
 345                 gtk_editable_set_position(GTK_EDITABLE(entry_), 0);
 346                 gtk_editable_select_region(GTK_EDITABLE(entry_), 0, -1);
 347         } else
 348                 gtk_entry_set_text(GTK_ENTRY(entry_), "");
 349
 350         gtk_widget_grab_focus(ok_button);
 351         gtk_widget_grab_focus(entry_);
 352 }
 353
 354 static void ok_clicked(GtkWidget *widget, gpointer data)
 355 {
 356         ack = TRUE;
 357         fin = TRUE;
 358 }
 359
 360 static void cancel_clicked(GtkWidget *widget, gpointer data)
 361 {
 362         ack = FALSE;
 363         fin = TRUE;
 364 }
 365
 366 static gint delete_event(GtkWidget *widget, GdkEventAny *event, gpointer data)
 367 {
 368         ack = FALSE;
 369         fin = TRUE;
 370
 371         return TRUE;
 372 }
 373
 374 static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
 375 {
 376         if (event && event->keyval == GDK_Escape) {
 377                 ack = FALSE;
 378                 fin = TRUE;
 379         } else if (event && event->keyval == GDK_Return) {
 380                 ack = TRUE;
 381                 fin = TRUE;
 382                 return TRUE; /* do not let Return pass - it
 383                               * pops up the combo on validating */
 384         }
 385
 386         return FALSE;
 387 }
 388
 389 static void entry_activated(GtkEditable *editable)
 390 {
 391         ack = TRUE;
 392         fin = TRUE;
 393 }
 394
 395 static void combo_activated(GtkEditable *editable)
 396 {
 397         ack = TRUE;
 398         fin = TRUE;
 399 }