src/ui/widget/dock-item.cpp

   1 /**
   2  * \brief A custom Inkscape wrapper around gdl_dock_item
   3  *
   4  * Author:
   5  *   Gustav Broberg <broberg@kth.se>
   6  *
   7  * Copyright (C) 2007 Authors
   8  *
   9  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  10  */
  11
  12 #include "dock-item.h"
  13 #include "desktop.h"
  14 #include "inkscape.h"
  15 #include "prefs-utils.h"
  16 #include "ui/widget/dock.h"
  17 #include "widgets/icon.h"
  18
  19 #include <gtk/gtk.h>
  20
  21 #include <gtkmm/invisible.h>
  22 #include <gtkmm/stock.h>
  23
  24 namespace Inkscape {
  25 namespace UI {
  26 namespace Widget {
  27
  28 DockItem::DockItem(Dock& dock, const Glib::ustring& name, const Glib::ustring& long_name,
  29                    const Glib::ustring& icon_name, State state) :
  30     _dock (dock),
  31     _prev_state (state),
  32     _window (NULL),
  33     _dock_item_action_area (NULL)
  34 {
  35     /* Add a "signal_response" signal to the GdlDockItem, make sure it is
  36      * only done once for the class.
  37      */
  38     static guint response_signal = 0;
  39
  40     if (response_signal == 0) {
  41         response_signal = g_signal_new ("signal_response",
  42                                         GDL_TYPE_DOCK_ITEM,
  43                                         G_SIGNAL_RUN_FIRST,
  44                                         0,
  45                                         NULL, NULL,
  46                                         g_cclosure_marshal_VOID__INT,
  47                                         G_TYPE_NONE, 1, G_TYPE_INT);
  48     }
  49
  50
  51     GdlDockItemBehavior gdl_dock_behavior =
  52         (prefs_get_int_attribute_limited ("options.dock", "cancenterdock", 1, 0, 1) == 0 ?
  53          GDL_DOCK_ITEM_BEH_CANT_DOCK_CENTER
  54          : GDL_DOCK_ITEM_BEH_NORMAL);
  55
  56     if (!icon_name.empty()) {
  57         Gtk::Widget *icon = sp_icon_get_icon(icon_name, Inkscape::ICON_SIZE_MENU);
  58         if (icon) {
  59             // check icon type (inkscape, gtk, none)
  60             if ( SP_IS_ICON(icon->gobj()) ) {
  61                 SPIcon* sp_icon = SP_ICON(icon->gobj());
  62                 sp_icon_fetch_pixbuf(sp_icon);
  63                 _icon_pixbuf = Glib::wrap(sp_icon->pb, true);
  64             } else if ( GTK_IS_IMAGE(icon->gobj()) ) {
  65                 _icon_pixbuf = Gtk::Invisible().render_icon(Gtk::StockID(icon_name),
  66                                                             Gtk::ICON_SIZE_MENU);
  67             }
  68             delete icon;
  69
  70             _gdl_dock_item =
  71                 gdl_dock_item_new_with_pixbuf_icon(name.c_str(), long_name.c_str(),
  72                                                    _icon_pixbuf->gobj(), gdl_dock_behavior);
  73         }
  74     } else {
  75         _gdl_dock_item =
  76             gdl_dock_item_new(name.c_str(), long_name.c_str(), gdl_dock_behavior);
  77     }
  78
  79     _frame.set_shadow_type(Gtk::SHADOW_IN);
  80     gtk_container_add (GTK_CONTAINER (_gdl_dock_item), GTK_WIDGET (_frame.gobj()));
  81     _frame.add(_dock_item_box);
  82     _dock_item_box.set_border_width(3);
  83
  84     signal_drag_begin().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onDragBegin));
  85     signal_drag_end().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onDragEnd));
  86     signal_hide().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onHide), false);
  87     signal_show().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onShow), false);
  88     signal_state_changed().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onStateChanged));
  89     signal_delete_event().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onDeleteEvent));
  90     signal_realize().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onRealize));
  91
  92     _dock.addItem(*this, (_prev_state == FLOATING_STATE ? FLOATING : TOP));
  93
  94     show_all();
  95 }
  96
  97 DockItem::~DockItem()
  98 {
  99     g_free(_gdl_dock_item);
 100 }
 101
 102 Gtk::Widget&
 103 DockItem::getWidget()
 104 {
 105     return *Glib::wrap(GTK_WIDGET(_gdl_dock_item));
 106 }
 107
 108 GtkWidget *
 109 DockItem::gobj()
 110 {
 111     return _gdl_dock_item;
 112 }
 113
 114 Gtk::VBox *
 115 DockItem::get_vbox()
 116 {
 117     return &_dock_item_box;
 118 }
 119
 120
 121 void
 122 DockItem::get_position(int& x, int& y)
 123 {
 124     if (getWindow()) {
 125         getWindow()->get_position(x, y);
 126     } else {
 127         x = _x;
 128         y = _y;
 129     }
 130 }
 131
 132 void
 133 DockItem::get_size(int& width, int& height)
 134 {
 135     if (_window) {
 136         _window->get_size(width, height);
 137     } else {
 138         width = get_vbox()->get_width();
 139         height = get_vbox()->get_height();
 140     }
 141 }
 142
 143
 144 void
 145 DockItem::resize(int width, int height)
 146 {
 147     if (_window)
 148         _window->resize(width, height);
 149 }
 150
 151
 152 void
 153 DockItem::move(int x, int y)
 154 {
 155     if (_window)
 156         _window->move(x, y);
 157 }
 158
 159 void
 160 DockItem::set_position(Gtk::WindowPosition position)
 161 {
 162     if (_window)
 163         _window->set_position(position);
 164 }
 165
 166 void
 167 DockItem::set_size_request(int width, int height)
 168 {
 169     getWidget().set_size_request(width, height);
 170 }
 171
 172 void
 173 DockItem::size_request(Gtk::Requisition& requisition)
 174 {
 175     getWidget().size_request(requisition);
 176 }
 177
 178 void
 179 DockItem::set_title(Glib::ustring title)
 180 {
 181     g_object_set (_gdl_dock_item,
 182                   "long-name", title.c_str(),
 183                   NULL);
 184
 185     gdl_dock_item_set_tablabel(GDL_DOCK_ITEM(_gdl_dock_item),
 186                                gtk_label_new (title.c_str()));
 187 }
 188
 189 bool
 190 DockItem::isAttached() const
 191 {
 192     return GDL_DOCK_OBJECT_ATTACHED (_gdl_dock_item);
 193 }
 194
 195
 196 bool
 197 DockItem::isFloating() const
 198 {
 199     return (GTK_WIDGET(gdl_dock_object_get_toplevel(GDL_DOCK_OBJECT (_gdl_dock_item))) !=
 200             _dock.getGdlWidget());
 201 }
 202
 203 bool
 204 DockItem::isIconified() const
 205 {
 206     return GDL_DOCK_ITEM_ICONIFIED (_gdl_dock_item);
 207 }
 208
 209 DockItem::State
 210 DockItem::getState() const
 211 {
 212     return (isAttached() ? (isFloating() ? FLOATING_STATE : DOCKED_STATE) : UNATTACHED);
 213 }
 214
 215 DockItem::State
 216 DockItem::getPrevState() const
 217 {
 218     return _prev_state;
 219 }
 220
 221 DockItem::Placement
 222 DockItem::getPlacement() const
 223 {
 224     GdlDockPlacement placement = (GdlDockPlacement)NONE;
 225     gdl_dock_object_child_placement(gdl_dock_object_get_parent_object (GDL_DOCK_OBJECT(_gdl_dock_item)),
 226                                     GDL_DOCK_OBJECT(_gdl_dock_item),
 227                                     &placement);
 228     return (Placement)placement;
 229 }
 230
 231
 232 void
 233 DockItem::addButton(Gtk::Button* button, int response_id)
 234 {
 235     // Create a button box for the response buttons if it's the first button to be added
 236     if (!_dock_item_action_area) {
 237         _dock_item_action_area = new Gtk::HButtonBox(Gtk::BUTTONBOX_END, 6);
 238         _dock_item_box.pack_end(*_dock_item_action_area, Gtk::PACK_SHRINK, 0);
 239         _dock_item_action_area->set_border_width(6);
 240     }
 241
 242     _dock_item_action_area->pack_start(*button);
 243 }
 244
 245 void
 246 DockItem::hide()
 247 {
 248     gdl_dock_item_hide_item (GDL_DOCK_ITEM(_gdl_dock_item));
 249 }
 250
 251 void
 252 DockItem::show()
 253 {
 254     gdl_dock_item_show_item (GDL_DOCK_ITEM(_gdl_dock_item));
 255 }
 256
 257 void
 258 DockItem::show_all()
 259 {
 260     gtk_widget_show_all(_gdl_dock_item);
 261 }
 262
 263 void
 264 DockItem::present()
 265 {
 266
 267     if (isIconified() || !isAttached()) {
 268         show();
 269     }
 270
 271     // tabbed
 272     else if (getPlacement() == CENTER) {
 273         int i = gtk_notebook_page_num (GTK_NOTEBOOK (_gdl_dock_item->parent),
 274                                        GTK_WIDGET (_gdl_dock_item));
 275         if (i >= 0)
 276             gtk_notebook_set_current_page (GTK_NOTEBOOK (_gdl_dock_item->parent), i);
 277     }
 278
 279     // always grab focus, even if we're already present
 280     grab_focus();
 281
 282     if (!isFloating() && getWidget().is_realized())
 283         _dock.scrollToItem(*this);
 284 }
 285
 286
 287 void
 288 DockItem::grab_focus()
 289 {
 290     if (GTK_WIDGET_REALIZED (_gdl_dock_item)) {
 291
 292         // make sure the window we're in is present
 293         Gtk::Widget *toplevel = getWidget().get_toplevel();
 294         if (Gtk::Window *window = dynamic_cast<Gtk::Window *>(toplevel)) {
 295             window->present();
 296         }
 297
 298         gtk_widget_grab_focus (_gdl_dock_item);
 299
 300     } else {
 301         _grab_focus_on_realize = true;
 302     }
 303 }
 304
 305
 306 /* Signal wrappers */
 307
 308 Glib::SignalProxy0<void>
 309 DockItem::signal_show()
 310 {
 311     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 312                                     &_signal_show_proxy);
 313 }
 314
 315 Glib::SignalProxy0<void>
 316 DockItem::signal_hide()
 317 {
 318     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 319                                     &_signal_hide_proxy);
 320 }
 321
 322 Glib::SignalProxy1<bool, GdkEventAny *>
 323 DockItem::signal_delete_event()
 324 {
 325     return Glib::SignalProxy1<bool, GdkEventAny *>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 326                                                   &_signal_delete_event_proxy);
 327 }
 328
 329 Glib::SignalProxy1<void, int>
 330 DockItem::signal_response()
 331 {
 332     return Glib::SignalProxy1<void, int>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 333                                          &_signal_response_proxy);
 334 }
 335
 336 Glib::SignalProxy0<void>
 337 DockItem::signal_drag_begin()
 338 {
 339     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 340                                     &_signal_drag_begin_proxy);
 341 }
 342
 343 Glib::SignalProxy1<void, bool>
 344 DockItem::signal_drag_end()
 345 {
 346     return Glib::SignalProxy1<void, bool>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 347                                           &_signal_drag_end_proxy);
 348 }
 349
 350 Glib::SignalProxy0<void>
 351 DockItem::signal_realize()
 352 {
 353     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 354                                     &_signal_realize_proxy);
 355 }
 356
 357 sigc::signal<void, DockItem::State, DockItem::State>
 358 DockItem::signal_state_changed()
 359 {
 360     return _signal_state_changed;
 361 }
 362
 363 void
 364 DockItem::_onHideWindow()
 365 {
 366     if (_window)
 367         _window->get_position(_x, _y);
 368 }
 369
 370 void
 371 DockItem::_onHide()
 372 {
 373     _signal_state_changed.emit(UNATTACHED, getState());
 374 }
 375
 376 void
 377 DockItem::_onShow()
 378 {
 379     _signal_state_changed.emit(UNATTACHED, getState());
 380 }
 381
 382 void
 383 DockItem::_onDragBegin()
 384 {
 385     _prev_state = getState();
 386     if (_prev_state == FLOATING_STATE)
 387         _dock.toggleDockable(getWidget().get_width(), getWidget().get_height());
 388 }
 389
 390 void
 391 DockItem::_onDragEnd(bool)
 392 {
 393     State state = getState();
 394
 395     if (state != _prev_state)
 396         _signal_state_changed.emit(_prev_state, state);
 397
 398     if (state == FLOATING_STATE) {
 399         if (_prev_state == FLOATING_STATE)
 400             _dock.toggleDockable();
 401     }
 402
 403     _prev_state = state;
 404 }
 405
 406 void
 407 DockItem::_onRealize()
 408 {
 409     if (_grab_focus_on_realize) {
 410         _grab_focus_on_realize = false;
 411         grab_focus();
 412     }
 413 }
 414
 415 bool
 416 DockItem::_onKeyPress(GdkEventKey *event)
 417 {
 418     gboolean return_value;
 419     g_signal_emit_by_name (_gdl_dock_item, "key_press_event", event, &return_value);
 420     return return_value;
 421 }
 422
 423 void
 424 DockItem::_onStateChanged(State prev_state, State new_state)
 425 {
 426     _window = getWindow();
 427
 428     if (new_state == FLOATING_STATE && _window) {
 429         _window->signal_hide().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onHideWindow));
 430         _signal_key_press_event_connection =
 431             _window->signal_key_press_event().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onKeyPress));
 432     }
 433 }
 434
 435
 436 bool
 437 DockItem::_onDeleteEvent(GdkEventAny *event)
 438 {
 439     hide();
 440     return false;
 441 }
 442
 443
 444 Gtk::Window *
 445 DockItem::getWindow()
 446 {
 447     g_return_val_if_fail(_gdl_dock_item, 0);
 448     Gtk::Container *parent = getWidget().get_parent();
 449     parent = (parent ? parent->get_parent() : 0);
 450     return (parent ? dynamic_cast<Gtk::Window *>(parent) : 0);
 451 }
 452
 453 const Glib::SignalProxyInfo
 454 DockItem::_signal_show_proxy =
 455 {
 456     "show",
 457     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 458     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 459 };
 460
 461 const Glib::SignalProxyInfo
 462 DockItem::_signal_hide_proxy =
 463 {
 464     "hide",
 465     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 466     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 467 };
 468
 469
 470 const Glib::SignalProxyInfo
 471 DockItem::_signal_delete_event_proxy =
 472 {
 473     "delete_event",
 474     (GCallback) &_signal_delete_event_callback,
 475     (GCallback) &_signal_delete_event_callback
 476 };
 477
 478
 479 const Glib::SignalProxyInfo
 480 DockItem::_signal_response_proxy =
 481 {
 482     "signal_response",
 483     (GCallback) &_signal_response_callback,
 484     (GCallback) &_signal_response_callback
 485 };
 486
 487 const Glib::SignalProxyInfo
 488 DockItem::_signal_drag_begin_proxy =
 489 {
 490     "dock-drag-begin",
 491     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 492     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 493 };
 494
 495
 496 const Glib::SignalProxyInfo
 497 DockItem::_signal_drag_end_proxy =
 498 {
 499     "dock_drag_end",
 500     (GCallback) &_signal_drag_end_callback,
 501     (GCallback) &_signal_drag_end_callback
 502 };
 503
 504
 505 const Glib::SignalProxyInfo
 506 DockItem::_signal_realize_proxy =
 507 {
 508     "realize",
 509     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 510     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 511 };
 512
 513
 514 gboolean
 515 DockItem::_signal_delete_event_callback(GtkWidget *self, GdkEventAny *event, void *data)
 516 {
 517     using namespace Gtk;
 518     typedef sigc::slot<bool, GdkEventAny *> SlotType;
 519
 520     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 521         try {
 522             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 523                 return static_cast<int>( (*static_cast<SlotType*>(slot))(event) );
 524         } catch(...) {
 525             Glib::exception_handlers_invoke();
 526         }
 527     }
 528
 529     typedef gboolean RType;
 530     return RType();
 531 }
 532
 533 void
 534 DockItem::_signal_response_callback(GtkWidget *self, gint response_id, void *data)
 535 {
 536     using namespace Gtk;
 537     typedef sigc::slot<void, int> SlotType;
 538
 539     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 540         try {
 541             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 542                 (*static_cast<SlotType *>(slot))(response_id);
 543         } catch(...) {
 544             Glib::exception_handlers_invoke();
 545         }
 546     }
 547 }
 548
 549 void
 550 DockItem::_signal_drag_end_callback(GtkWidget *self, gboolean cancelled, void *data)
 551 {
 552     using namespace Gtk;
 553     typedef sigc::slot<void, bool> SlotType;
 554
 555     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 556         try {
 557             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 558                 (*static_cast<SlotType *>(slot))(cancelled);
 559         } catch(...) {
 560             Glib::exception_handlers_invoke();
 561         }
 562     }
 563 }
 564
 565
 566 } // namespace Widget
 567 } // namespace UI
 568 } // namespace Inkscape
 569
 570 /*
 571   Local Variables:
 572   mode:c++
 573   c-file-style:"stroustrup"
 574   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 575   indent-tabs-mode:nil
 576   fill-column:99
 577   End:
 578 */
 579 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :