src/ui/dialog/dialog.cpp

   1 /**
   2  * \brief Base class for dialogs in Inkscape.  This class provides certain
   3  *        common behaviors and styles wanted of all dialogs in the application.
   4  *
   5  * Author:
   6  *   Bryce W. Harrington <bryce@bryceharrington.org>
   7  *   buliabyak@gmail.com
   8  *
   9  * Copyright (C) 2004, 2005 Authors
  10  *
  11  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include <config.h>
  16 #endif
  17
  18 #include <typeinfo>
  19 #include <gtkmm/stock.h>
  20 #include <gtk/gtk.h>
  21
  22 #include "application/application.h"
  23 #include "application/editor.h"
  24 #include "inkscape.h"
  25 #include "event-context.h"
  26 #include "desktop.h"
  27 #include "desktop-handles.h"
  28 #include "dialog-manager.h"
  29 #include "dialogs/dialog-events.h"
  30 #include "shortcuts.h"
  31 #include "prefs-utils.h"
  32 #include "interface.h"
  33 #include "verbs.h"
  34
  35 namespace Inkscape {
  36 namespace UI {
  37 namespace Dialog {
  38
  39 #ifndef WIN32
  40 static gboolean
  41 sp_retransientize_again (gpointer dlgPtr)
  42 {
  43     Dialog *dlg = (Dialog *)dlgPtr;
  44     dlg->retransientize_suppress = false;
  45     return FALSE; // so that it is only called once
  46 }
  47 #endif
  48
  49 static void
  50 sp_retransientize (Inkscape::Application *inkscape, SPDesktop *desktop, gpointer dlgPtr)
  51 {
  52     Dialog *dlg = (Dialog *)dlgPtr;
  53     dlg->onDesktopActivated (desktop);
  54 }
  55
  56 static void
  57 sp_dialog_shutdown (GtkObject *object, gpointer dlgPtr)
  58 {
  59     Dialog *dlg = (Dialog *)dlgPtr;
  60     dlg->onShutdown();
  61 }
  62
  63 void
  64 Dialog::present()
  65 {
  66     Gtk::Dialog::present();
  67 }
  68
  69 void
  70 Dialog::save_geometry()
  71 {
  72     int y, x, w, h;
  73
  74     get_position(x, y);
  75     get_size(w, h);
  76
  77 //    g_print ("write %d %d %d %d\n", x, y, w, h);
  78
  79     prefs_set_int_attribute (_prefs_path, "x", x);
  80     prefs_set_int_attribute (_prefs_path, "y", y);
  81     prefs_set_int_attribute (_prefs_path, "w", w);
  82     prefs_set_int_attribute (_prefs_path, "h", h);
  83 }
  84
  85 void
  86 Dialog::read_geometry()
  87 {
  88     _user_hidden = false;
  89
  90     int x = prefs_get_int_attribute (_prefs_path, "x", -1000);
  91     int y = prefs_get_int_attribute (_prefs_path, "y", -1000);
  92     int w = prefs_get_int_attribute (_prefs_path, "w", 0);
  93     int h = prefs_get_int_attribute (_prefs_path, "h", 0);
  94
  95 //    g_print ("read %d %d %d %d\n", x, y, w, h);
  96
  97     // If there are stored height and width values for the dialog,
  98     // resize the window to match; otherwise we leave it at its default
  99     if (w != 0 && h != 0) {
 100         resize (w, h);
 101     }
 102
 103     // If there are stored values for where the dialog should be
 104     // located, then restore the dialog to that position.
 105     if (x != -1000 && y != -1000) {
 106         move(x, y);
 107     } else {
 108         // ...otherwise just put it in the middle of the screen
 109         set_position(Gtk::WIN_POS_CENTER);
 110     }
 111 }
 112
 113 void hideCallback(GtkObject *object, gpointer dlgPtr)
 114 {
 115     Dialog* example;
 116     if ((void*)dlgPtr == 0 || typeid(dlgPtr) != typeid(example))
 117             return;
 118
 119     Dialog *dlg = (Dialog *)dlgPtr;
 120     dlg->onHideF12();
 121 }
 122
 123 void unhideCallback(GtkObject *object, gpointer dlgPtr)
 124 {
 125     Dialog* example;
 126     if ((void*)dlgPtr == 0 || typeid(dlgPtr) != typeid(example))
 127             return;
 128
 129     Dialog *dlg = (Dialog *)dlgPtr;
 130     dlg->onShowF12();
 131 }
 132
 133 //=====================================================================
 134
 135 /**
 136  * UI::Dialog::Dialog is a base class for all dialogs in Inkscape.  The
 137  * purpose of this class is to provide a unified place for ensuring
 138  * style and behavior.  Specifically, this class provides functionality
 139  * for saving and restoring the size and position of dialogs (through
 140  * the user's preferences file).
 141  *
 142  * It also provides some general purpose signal handlers for things like
 143  * showing and hiding all dialogs.
 144  */
 145 Dialog::Dialog(const char *prefs_path, int verb_num, const char *apply_label)
 146 {
 147     hide();
 148     set_has_separator(false);
 149
 150     _prefs_path = prefs_path;
 151
 152     if (prefs_get_int_attribute ("dialogs", "showclose", 0) || apply_label) {
 153         // TODO: make the order of buttons obey the global preference
 154         if (apply_label) {
 155             add_button(Glib::ustring(apply_label), Gtk::RESPONSE_APPLY);
 156             set_default_response(Gtk::RESPONSE_APPLY);
 157         }
 158        add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
 159     }
 160
 161     GtkWidget *dlg = GTK_WIDGET(gobj());
 162
 163     if (verb_num)
 164     {
 165         gchar title[500];
 166         sp_ui_dialog_title_string (Inkscape::Verb::get(verb_num), title);
 167         set_title(title);
 168     }
 169
 170     sp_transientize(dlg);
 171     retransientize_suppress = false;
 172
 173     gtk_signal_connect( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC(sp_dialog_event_handler), dlg );
 174
 175     _hiddenF12 = false;
 176     if (Inkscape::NSApplication::Application::getNewGui())
 177     {
 178         _desktop_activated_connection = Inkscape::NSApplication::Editor::connectDesktopActivated (sigc::mem_fun (*this, &Dialog::onDesktopActivated));
 179         _dialogs_hidden_connection = Inkscape::NSApplication::Editor::connectDialogsHidden (sigc::mem_fun (*this, &Dialog::onHideF12));
 180         _dialogs_unhidden_connection = Inkscape::NSApplication::Editor::connectDialogsUnhidden (sigc::mem_fun (*this, &Dialog::onShowF12));
 181         _shutdown_connection = Inkscape::NSApplication::Editor::connectShutdown (sigc::mem_fun (*this, &Dialog::onShutdown));
 182     }
 183     else
 184     {
 185         g_signal_connect   (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_retransientize), (void *)this);
 186         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(hideCallback), (void *)this );
 187         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(unhideCallback), (void *)this );
 188         g_signal_connect   (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_dialog_shutdown), (void *)this);
 189     }
 190
 191     g_signal_connect_after( gobj(), "key_press_event", (GCallback)windowKeyPress, NULL );
 192
 193     read_geometry();
 194     present();
 195 }
 196
 197 Dialog::Dialog(BaseObjectType *gobj)
 198     : Gtk::Dialog(gobj)
 199 {
 200 }
 201
 202 Dialog::~Dialog()
 203 {
 204     if (Inkscape::NSApplication::Application::getNewGui())
 205     {
 206         _desktop_activated_connection.disconnect();
 207         _dialogs_hidden_connection.disconnect();
 208         _dialogs_unhidden_connection.disconnect();
 209         _shutdown_connection.disconnect();
 210     }
 211
 212     save_geometry();
 213 }
 214
 215
 216 bool Dialog::windowKeyPress( GtkWidget *widget, GdkEventKey *event )
 217 {
 218     unsigned int shortcut = 0;
 219     shortcut = get_group0_keyval (event) |
 220         ( event->state & GDK_SHIFT_MASK ?
 221           SP_SHORTCUT_SHIFT_MASK : 0 ) |
 222         ( event->state & GDK_CONTROL_MASK ?
 223           SP_SHORTCUT_CONTROL_MASK : 0 ) |
 224         ( event->state & GDK_MOD1_MASK ?
 225           SP_SHORTCUT_ALT_MASK : 0 );
 226     return sp_shortcut_invoke( shortcut, SP_ACTIVE_DESKTOP );
 227 }
 228
 229 //---------------------------------------------------------------------
 230
 231 void
 232 Dialog::on_response(int response_id)
 233 {
 234     switch (response_id) {
 235         case Gtk::RESPONSE_APPLY: {
 236             _apply();
 237             break;
 238         }
 239         case Gtk::RESPONSE_CLOSE: {
 240             _close();
 241             break;
 242         }
 243     }
 244 }
 245
 246 bool
 247 Dialog::on_delete_event (GdkEventAny *event)
 248 {
 249     save_geometry();
 250     _user_hidden = true;
 251
 252     return false;
 253 }
 254
 255 void
 256 Dialog::onHideF12()
 257 {
 258     _hiddenF12 = true;
 259     save_geometry();
 260     hide();
 261 }
 262
 263 void
 264 Dialog::onShowF12()
 265 {
 266     if (_user_hidden)
 267         return;
 268
 269     if (_hiddenF12) {
 270         show();
 271         read_geometry();
 272     }
 273
 274     _hiddenF12 = false;
 275 }
 276
 277 void
 278 Dialog::onShutdown()
 279 {
 280     save_geometry();
 281     _user_hidden = true;
 282 }
 283
 284 void
 285 Dialog::onDesktopActivated (SPDesktop *desktop)
 286 {
 287     gint transient_policy = prefs_get_int_attribute_limited ( "options.transientpolicy", "value", 1, 0, 2);
 288
 289     if (!transient_policy)
 290         return;
 291
 292 #ifndef WIN32
 293     GtkWindow *dialog_win = GTK_WINDOW(gobj());
 294
 295     if (retransientize_suppress) {
 296          /* if retransientizing of this dialog is still forbidden after
 297           * previous call warning turned off because it was confusingly fired
 298           * when loading many files from command line
 299           */
 300
 301          // g_warning("Retranzientize aborted! You're switching windows too fast!");
 302         return;
 303     }
 304
 305     if (dialog_win)
 306     {
 307         retransientize_suppress = true; // disallow other attempts to retranzientize this dialog
 308
 309         desktop->setWindowTransient (dialog_win);
 310
 311         /*
 312          * This enables "aggressive" transientization,
 313          * i.e. dialogs always emerging on top when you switch documents. Note
 314          * however that this breaks "click to raise" policy of a window
 315          * manager because the switched-to document will be raised at once
 316          * (so that its transients also could raise)
 317          */
 318         if (transient_policy == 2 && !_hiddenF12 && !_user_hidden) {
 319             // without this, a transient window not always emerges on top
 320             gtk_window_present (dialog_win);
 321         }
 322     }
 323
 324     // we're done, allow next retransientizing not sooner than after 120 msec
 325     gtk_timeout_add (120, (GtkFunction) sp_retransientize_again, (gpointer) this);
 326 #endif
 327 }
 328
 329
 330 Inkscape::Selection*
 331 Dialog::_getSelection()
 332 {
 333     return SP_DT_SELECTION(SP_ACTIVE_DESKTOP);
 334 }
 335
 336 void
 337 Dialog::_apply()
 338 {
 339     g_warning("Apply button clicked for dialog [Dialog::_apply()]");
 340 }
 341
 342 void
 343 Dialog::_close()
 344 {
 345     GtkWidget *dlg = GTK_WIDGET(gobj());
 346
 347                         /* this code sends a delete_event to the dialog,
 348                          * instead of just destroying it, so that the
 349                          * dialog can do some housekeeping, such as remember
 350                          * its position.
 351                          */
 352                         GdkEventAny event;
 353                         event.type = GDK_DELETE;
 354                         event.window = dlg->window;
 355                         event.send_event = TRUE;
 356                         g_object_ref (G_OBJECT (event.window));
 357                         gtk_main_do_event ((GdkEvent*)&event);
 358                         g_object_unref (G_OBJECT (event.window));
 359 }
 360
 361 } // namespace Dialog
 362 } // namespace UI
 363 } // namespace Inkscape
 364
 365 /*
 366   Local Variables:
 367   mode:c++
 368   c-file-style:"stroustrup"
 369   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 370   indent-tabs-mode:nil
 371   fill-column:99
 372   End:
 373 */
 374 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :