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     gboolean floating = FALSE;
 200     if (GDL_IS_DOCK (gdl_dock_object_get_parent_object (GDL_DOCK_OBJECT (_gdl_dock_item)))) {
 201         GdlDock* dock = GDL_DOCK (gdl_dock_object_get_parent_object (GDL_DOCK_OBJECT (_gdl_dock_item)));
 202         g_object_get (dock,
 203                       "floating", &floating,
 204                       NULL);
 205     }
 206     return floating;
 207 }
 208
 209 bool
 210 DockItem::isIconified() const
 211 {
 212     return GDL_DOCK_ITEM_ICONIFIED (_gdl_dock_item);
 213 }
 214
 215 DockItem::State
 216 DockItem::getState() const
 217 {
 218     return (isAttached() ? (isFloating() ? FLOATING_STATE : DOCKED_STATE) : UNATTACHED);
 219 }
 220
 221 DockItem::State
 222 DockItem::getPrevState() const
 223 {
 224     return _prev_state;
 225 }
 226
 227 DockItem::Placement
 228 DockItem::getPlacement() const
 229 {
 230     GdlDockPlacement placement = (GdlDockPlacement)NONE;
 231     gdl_dock_object_child_placement(gdl_dock_object_get_parent_object (GDL_DOCK_OBJECT(_gdl_dock_item)),
 232                                     GDL_DOCK_OBJECT(_gdl_dock_item),
 233                                     &placement);
 234     return (Placement)placement;
 235 }
 236
 237
 238 void
 239 DockItem::addButton(Gtk::Button* button, int response_id)
 240 {
 241     // Create a button box for the response buttons if it's the first button to be added
 242     if (!_dock_item_action_area) {
 243         _dock_item_action_area = new Gtk::HButtonBox(Gtk::BUTTONBOX_END, 6);
 244         _dock_item_box.pack_end(*_dock_item_action_area, Gtk::PACK_SHRINK, 0);
 245         _dock_item_action_area->set_border_width(6);
 246     }
 247
 248     _dock_item_action_area->pack_start(*button);
 249 }
 250
 251 void
 252 DockItem::hide()
 253 {
 254     gdl_dock_item_hide_item (GDL_DOCK_ITEM(_gdl_dock_item));
 255 }
 256
 257 void
 258 DockItem::show()
 259 {
 260     gdl_dock_item_show_item (GDL_DOCK_ITEM(_gdl_dock_item));
 261 }
 262
 263 void
 264 DockItem::show_all()
 265 {
 266     gtk_widget_show_all(_gdl_dock_item);
 267 }
 268
 269 void
 270 DockItem::present()
 271 {
 272     // iconified or unattached
 273     if (isIconified() || !isAttached()) {
 274         show();
 275     }
 276
 277     // tabbed
 278     else if (getPlacement() == CENTER) {
 279         int i = gtk_notebook_page_num (GTK_NOTEBOOK (_gdl_dock_item->parent),
 280                                        GTK_WIDGET (_gdl_dock_item));
 281         if (i >= 0)
 282             gtk_notebook_set_current_page (GTK_NOTEBOOK (_gdl_dock_item->parent), i);
 283         return;
 284     }
 285
 286     // always grab focus, even if we're already present
 287     grab_focus();
 288 }
 289
 290
 291 void
 292 DockItem::grab_focus()
 293 {
 294     if (GTK_WIDGET_REALIZED (_gdl_dock_item))
 295         gtk_widget_grab_focus (_gdl_dock_item);
 296     else
 297         _grab_focus_on_realize = true;
 298 }
 299
 300
 301 /* Signal wrappers */
 302
 303 Glib::SignalProxy0<void>
 304 DockItem::signal_show()
 305 {
 306     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 307                                     &_signal_show_proxy);
 308 }
 309
 310 Glib::SignalProxy0<void>
 311 DockItem::signal_hide()
 312 {
 313     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 314                                     &_signal_hide_proxy);
 315 }
 316
 317 Glib::SignalProxy1<bool, GdkEventAny *>
 318 DockItem::signal_delete_event()
 319 {
 320     return Glib::SignalProxy1<bool, GdkEventAny *>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 321                                                   &_signal_delete_event_proxy);
 322 }
 323
 324 Glib::SignalProxy1<void, int>
 325 DockItem::signal_response()
 326 {
 327     return Glib::SignalProxy1<void, int>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 328                                          &_signal_response_proxy);
 329 }
 330
 331 Glib::SignalProxy0<void>
 332 DockItem::signal_drag_begin()
 333 {
 334     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 335                                     &_signal_drag_begin_proxy);
 336 }
 337
 338 Glib::SignalProxy1<void, bool>
 339 DockItem::signal_drag_end()
 340 {
 341     return Glib::SignalProxy1<void, bool>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 342                                           &_signal_drag_end_proxy);
 343 }
 344
 345 Glib::SignalProxy0<void>
 346 DockItem::signal_realize()
 347 {
 348     return Glib::SignalProxy0<void>(Glib::wrap(GTK_WIDGET(_gdl_dock_item)),
 349                                     &_signal_realize_proxy);
 350 }
 351
 352 sigc::signal<void, DockItem::State, DockItem::State>
 353 DockItem::signal_state_changed()
 354 {
 355     return _signal_state_changed;
 356 }
 357
 358 void
 359 DockItem::_onHideWindow()
 360 {
 361     if (_window)
 362         _window->get_position(_x, _y);
 363 }
 364
 365 void
 366 DockItem::_onHide()
 367 {
 368     _signal_state_changed.emit(UNATTACHED, getState());
 369 }
 370
 371 void
 372 DockItem::_onShow()
 373 {
 374     _signal_state_changed.emit(UNATTACHED, getState());
 375 }
 376
 377 void
 378 DockItem::_onDragBegin()
 379 {
 380     _prev_state = getState();
 381     if (_prev_state == FLOATING_STATE)
 382         _dock.toggleDockable(getWidget().get_width(), getWidget().get_height());
 383 }
 384
 385 void
 386 DockItem::_onDragEnd(bool)
 387 {
 388     State state = getState();
 389
 390     if (state != _prev_state)
 391         _signal_state_changed.emit(_prev_state, state);
 392
 393     if (state == FLOATING_STATE) {
 394         if (_prev_state == FLOATING_STATE)
 395             _dock.toggleDockable();
 396     }
 397
 398     _prev_state = state;
 399 }
 400
 401 void
 402 DockItem::_onRealize()
 403 {
 404     if (_grab_focus_on_realize) {
 405         _grab_focus_on_realize = false;
 406         grab_focus();
 407     }
 408 }
 409
 410 bool
 411 DockItem::_onKeyPress(GdkEventKey *event)
 412 {
 413     gboolean return_value;
 414     g_signal_emit_by_name (_gdl_dock_item, "key_press_event", event, &return_value);
 415     return return_value;
 416 }
 417
 418 void
 419 DockItem::_onStateChanged(State prev_state, State new_state)
 420 {
 421     _window = getWindow();
 422
 423     if (new_state == FLOATING_STATE) {
 424         _window->signal_hide().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onHideWindow));
 425         _signal_key_press_event_connection =
 426             _window->signal_key_press_event().connect(sigc::mem_fun(*this, &Inkscape::UI::Widget::DockItem::_onKeyPress));
 427     }
 428 }
 429
 430
 431 bool
 432 DockItem::_onDeleteEvent(GdkEventAny *event)
 433 {
 434     hide();
 435     return false;
 436 }
 437
 438
 439 Gtk::Window *
 440 DockItem::getWindow()
 441 {
 442     g_return_val_if_fail(_gdl_dock_item, 0);
 443     Gtk::Container *parent = getWidget().get_parent();
 444     parent = (parent ? parent->get_parent() : 0);
 445     return (parent ? dynamic_cast<Gtk::Window *>(parent) : 0);
 446 }
 447
 448 const Glib::SignalProxyInfo
 449 DockItem::_signal_show_proxy =
 450 {
 451     "show",
 452     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 453     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 454 };
 455
 456 const Glib::SignalProxyInfo
 457 DockItem::_signal_hide_proxy =
 458 {
 459     "hide",
 460     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 461     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 462 };
 463
 464
 465 const Glib::SignalProxyInfo
 466 DockItem::_signal_delete_event_proxy =
 467 {
 468     "delete_event",
 469     (GCallback) &_signal_delete_event_callback,
 470     (GCallback) &_signal_delete_event_callback
 471 };
 472
 473
 474 const Glib::SignalProxyInfo
 475 DockItem::_signal_response_proxy =
 476 {
 477     "signal_response",
 478     (GCallback) &_signal_response_callback,
 479     (GCallback) &_signal_response_callback
 480 };
 481
 482 const Glib::SignalProxyInfo
 483 DockItem::_signal_drag_begin_proxy =
 484 {
 485     "dock-drag-begin",
 486     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 487     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 488 };
 489
 490
 491 const Glib::SignalProxyInfo
 492 DockItem::_signal_drag_end_proxy =
 493 {
 494     "dock_drag_end",
 495     (GCallback) &_signal_drag_end_callback,
 496     (GCallback) &_signal_drag_end_callback
 497 };
 498
 499
 500 const Glib::SignalProxyInfo
 501 DockItem::_signal_realize_proxy =
 502 {
 503     "realize",
 504     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 505     (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 506 };
 507
 508
 509 gboolean
 510 DockItem::_signal_delete_event_callback(GtkWidget *self, GdkEventAny *event, void *data)
 511 {
 512     using namespace Gtk;
 513     typedef sigc::slot<bool, GdkEventAny *> SlotType;
 514
 515     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 516         try {
 517             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 518                 return static_cast<int>( (*static_cast<SlotType*>(slot))(event) );
 519         } catch(...) {
 520             Glib::exception_handlers_invoke();
 521         }
 522     }
 523
 524     typedef gboolean RType;
 525     return RType();
 526 }
 527
 528 void
 529 DockItem::_signal_response_callback(GtkWidget *self, gint response_id, void *data)
 530 {
 531     using namespace Gtk;
 532     typedef sigc::slot<void, int> SlotType;
 533
 534     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 535         try {
 536             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 537                 (*static_cast<SlotType *>(slot))(response_id);
 538         } catch(...) {
 539             Glib::exception_handlers_invoke();
 540         }
 541     }
 542 }
 543
 544 void
 545 DockItem::_signal_drag_end_callback(GtkWidget *self, gboolean cancelled, void *data)
 546 {
 547     using namespace Gtk;
 548     typedef sigc::slot<void, bool> SlotType;
 549
 550     if (Glib::ObjectBase::_get_current_wrapper((GObject *) self)) {
 551         try {
 552             if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 553                 (*static_cast<SlotType *>(slot))(cancelled);
 554         } catch(...) {
 555             Glib::exception_handlers_invoke();
 556         }
 557     }
 558 }
 559
 560
 561 } // namespace Widget
 562 } // namespace UI
 563 } // namespace Inkscape
 564
 565 /*
 566   Local Variables:
 567   mode:c++
 568   c-file-style:"stroustrup"
 569   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 570   indent-tabs-mode:nil
 571   fill-column:99
 572   End:
 573 */
 574 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :