src/ui/dialog/undo-history.cpp

   1 /** @file
   2  * @brief Undo History dialog - implementation
   3  */
   4 /* Author:
   5  *   Gustav Broberg <broberg@kth.se>
   6  *   Abhishek Sharma
   7  *
   8  * Copyright (C) 2006 Authors
   9  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 # include <config.h>
  14 #endif
  15
  16 #include <glibmm/i18n.h>
  17 #include <gtk/gtkimage.h>
  18 #include <sigc++/sigc++.h>
  19
  20
  21 #include "document.h"
  22 #include "inkscape.h"
  23 #include "verbs.h"
  24 #include "desktop-handles.h"
  25
  26 #include "undo-history.h"
  27
  28 namespace Inkscape {
  29 namespace UI {
  30 namespace Dialog {
  31
  32 /* Rendering functions for custom cell renderers */
  33
  34 void
  35 CellRendererSPIcon::render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window,
  36                                  Gtk::Widget& widget,
  37                                  const Gdk::Rectangle& background_area,
  38                                  const Gdk::Rectangle& cell_area,
  39                                  const Gdk::Rectangle& expose_area,
  40                                  Gtk::CellRendererState flags)
  41 {
  42     // if this event type doesn't have an icon...
  43     if ( !Inkscape::Verb::get(_property_event_type)->get_image() ) return;
  44
  45     // if the icon isn't cached, render it to a pixbuf
  46     if ( !_icon_cache[_property_event_type] ) {
  47
  48         Glib::ustring image = Inkscape::Verb::get(_property_event_type)->get_image();
  49         Gtk::Widget* icon = sp_icon_get_icon(image, Inkscape::ICON_SIZE_MENU);
  50
  51         if (icon) {
  52
  53             // check icon type (inkscape, gtk, none)
  54             if ( SP_IS_ICON(icon->gobj()) ) {
  55                 SPIcon* sp_icon = SP_ICON(icon->gobj());
  56                 sp_icon_fetch_pixbuf(sp_icon);
  57                 _property_icon = Glib::wrap(sp_icon->pb, true);
  58             } else if ( GTK_IS_IMAGE(icon->gobj()) ) {
  59                 _property_icon = Gtk::Invisible().render_icon(Gtk::StockID(image),
  60                                                               Gtk::ICON_SIZE_MENU);
  61             } else {
  62                 delete icon;
  63                 return;
  64             }
  65
  66             delete icon;
  67             property_pixbuf() = _icon_cache[_property_event_type] = _property_icon.get_value();
  68         }
  69
  70     } else {
  71         property_pixbuf() = _icon_cache[_property_event_type];
  72     }
  73
  74     Gtk::CellRendererPixbuf::render_vfunc(window, widget, background_area,
  75                                           cell_area, expose_area, flags);
  76 }
  77
  78
  79 void
  80 CellRendererInt::render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window,
  81                               Gtk::Widget& widget,
  82                               const Gdk::Rectangle& background_area,
  83                               const Gdk::Rectangle& cell_area,
  84                               const Gdk::Rectangle& expose_area,
  85                               Gtk::CellRendererState flags)
  86 {
  87     if( _filter(_property_number) ) {
  88         std::ostringstream s;
  89         s << _property_number << std::flush;
  90         property_text() = s.str();
  91         Gtk::CellRendererText::render_vfunc(window, widget, background_area,
  92                                             cell_area, expose_area, flags);
  93     }
  94 }
  95
  96 const CellRendererInt::Filter& CellRendererInt::no_filter = CellRendererInt::NoFilter();
  97
  98 UndoHistory& UndoHistory::getInstance()
  99 {
 100     return *new UndoHistory();
 101 }
 102
 103 void
 104 UndoHistory::setDesktop(SPDesktop* desktop)
 105 {
 106     Panel::setDesktop(desktop);
 107
 108     if (!desktop) return;
 109
 110     _document = sp_desktop_document(desktop);
 111
 112     _event_log = desktop->event_log;
 113
 114     _callback_connections[EventLog::CALLB_SELECTION_CHANGE].block();
 115
 116     _event_list_store = _event_log->getEventListStore();
 117     _event_list_view.set_model(_event_list_store);
 118     _event_list_selection = _event_list_view.get_selection();
 119
 120     _event_log->connectWithDialog(&_event_list_view, &_callback_connections);
 121     _event_list_view.scroll_to_row(_event_list_store->get_path(_event_list_selection->get_selected()));
 122
 123     _callback_connections[EventLog::CALLB_SELECTION_CHANGE].block(false);
 124 }
 125
 126 UndoHistory::UndoHistory()
 127     : UI::Widget::Panel ("", "/dialogs/undo-history", SP_VERB_DIALOG_UNDO_HISTORY),
 128       _document (sp_desktop_document(getDesktop())),
 129       _event_log (getDesktop() ? getDesktop()->event_log : NULL),
 130       _columns (_event_log ? &_event_log->getColumns() : NULL),
 131       _event_list_selection (_event_list_view.get_selection())
 132 {
 133     if ( !_document || !_event_log || !_columns ) return;
 134
 135     set_size_request(300, 95);
 136
 137     _getContents()->pack_start(_scrolled_window);
 138     _scrolled_window.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 139
 140     _event_list_store = _event_log->getEventListStore();
 141
 142     _event_list_view.set_model(_event_list_store);
 143     _event_list_view.set_rules_hint(false);
 144     _event_list_view.set_enable_search(false);
 145     _event_list_view.set_headers_visible(false);
 146
 147     CellRendererSPIcon* icon_renderer = Gtk::manage(new CellRendererSPIcon());
 148     icon_renderer->property_xpad() = 8;
 149     icon_renderer->property_width() = 36;
 150     int cols_count = _event_list_view.append_column("Icon", *icon_renderer);
 151
 152     Gtk::TreeView::Column* icon_column = _event_list_view.get_column(cols_count-1);
 153     icon_column->add_attribute(icon_renderer->property_event_type(), _columns->type);
 154
 155     Gtk::CellRendererText* description_renderer = Gtk::manage(new Gtk::CellRendererText());
 156
 157     cols_count = _event_list_view.append_column("Description", *description_renderer);
 158     Gtk::TreeView::Column* description_column = _event_list_view.get_column(cols_count-1);
 159     description_column->add_attribute(description_renderer->property_text(), _columns->description);
 160     description_column->set_resizable();
 161
 162     _event_list_view.set_expander_column( *_event_list_view.get_column(cols_count-1) );
 163
 164     CellRendererInt* children_renderer = Gtk::manage(new CellRendererInt(greater_than_1));
 165     children_renderer->property_weight() = 600; // =Pango::WEIGHT_SEMIBOLD (not defined in old versions of pangomm)
 166     children_renderer->property_xalign() = 1.0;
 167     children_renderer->property_xpad() = 20;
 168
 169     cols_count = _event_list_view.append_column("Children", *children_renderer);
 170     Gtk::TreeView::Column* children_column = _event_list_view.get_column(cols_count-1);
 171     children_column->add_attribute(children_renderer->property_number(), _columns->child_count);
 172
 173     _scrolled_window.add(_event_list_view);
 174
 175     // connect EventLog callbacks
 176     _callback_connections[EventLog::CALLB_SELECTION_CHANGE] =
 177         _event_list_selection->signal_changed().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onListSelectionChange));
 178
 179     _callback_connections[EventLog::CALLB_EXPAND] =
 180         _event_list_view.signal_row_expanded().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onExpandEvent));
 181
 182     _callback_connections[EventLog::CALLB_COLLAPSE] =
 183         _event_list_view.signal_row_collapsed().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onCollapseEvent));
 184
 185     // connect with the EventLog
 186     _event_log->connectWithDialog(&_event_list_view, &_callback_connections);
 187
 188     show_all_children();
 189
 190     // scroll to the selected row
 191     _event_list_view.set_cursor(_event_list_store->get_path(_event_log->getCurrEvent()));
 192 }
 193
 194 UndoHistory::~UndoHistory()
 195 {
 196 }
 197
 198 void
 199 UndoHistory::_onListSelectionChange()
 200 {
 201
 202     EventLog::const_iterator selected = _event_list_selection->get_selected();
 203
 204     /* If no event is selected in the view, find the right one and select it. This happens whenever
 205      * a branch we're currently in is collapsed.
 206      */
 207     if (!selected) {
 208
 209         EventLog::iterator curr_event = _event_log->getCurrEvent();
 210
 211         if (curr_event->parent()) {
 212
 213             EventLog::iterator curr_event_parent = curr_event->parent();
 214             EventLog::iterator last = curr_event_parent->children().end();
 215
 216             _event_log->blockNotifications();
 217             for ( --last ; curr_event != last ; ++curr_event ) {
 218                 DocumentUndo::redo(_document);
 219             }
 220             _event_log->blockNotifications(false);
 221
 222             _event_log->setCurrEvent(curr_event);
 223             _event_list_selection->select(curr_event_parent);
 224
 225         } else {  // this should not happen
 226             _event_list_selection->select(curr_event);
 227         }
 228
 229     } else {
 230
 231         EventLog::const_iterator last_selected = _event_log->getCurrEvent();
 232
 233         /* Selecting a collapsed parent event is equal to selecting the last child
 234          * of that parent's branch.
 235          */
 236
 237         if ( !selected->children().empty() &&
 238              !_event_list_view.row_expanded(_event_list_store->get_path(selected)) )
 239         {
 240             selected = selected->children().end();
 241             --selected;
 242         }
 243
 244         // An event before the current one has been selected. Undo to the selected event.
 245         if ( _event_list_store->get_path(selected) <
 246              _event_list_store->get_path(last_selected) )
 247         {
 248             _event_log->blockNotifications();
 249
 250             while ( selected != last_selected ) {
 251
 252                 DocumentUndo::undo(_document);
 253
 254                 if ( last_selected->parent() &&
 255                      last_selected == last_selected->parent()->children().begin() )
 256                 {
 257                     last_selected = last_selected->parent();
 258                     _event_log->setCurrEventParent((EventLog::iterator)NULL);
 259                 } else {
 260                     --last_selected;
 261                     if ( !last_selected->children().empty() ) {
 262                         _event_log->setCurrEventParent(last_selected);
 263                         last_selected = last_selected->children().end();
 264                         --last_selected;
 265                     }
 266                 }
 267             }
 268             _event_log->blockNotifications(false);
 269             _event_log->updateUndoVerbs();
 270
 271         } else { // An event after the current one has been selected. Redo to the selected event.
 272
 273             _event_log->blockNotifications();
 274
 275             while ( selected != last_selected ) {
 276
 277                 DocumentUndo::redo(_document);
 278
 279                 if ( !last_selected->children().empty() ) {
 280                     _event_log->setCurrEventParent(last_selected);
 281                     last_selected = last_selected->children().begin();
 282                 } else {
 283                     ++last_selected;
 284                     if ( last_selected->parent() &&
 285                          last_selected == last_selected->parent()->children().end() )
 286                     {
 287                         last_selected = last_selected->parent();
 288                         ++last_selected;
 289                         _event_log->setCurrEventParent((EventLog::iterator)NULL);
 290                     }
 291                 }
 292             }
 293             _event_log->blockNotifications(false);
 294
 295         }
 296
 297         _event_log->setCurrEvent(selected);
 298         _event_log->updateUndoVerbs();
 299     }
 300
 301 }
 302
 303 void
 304 UndoHistory::_onExpandEvent(const Gtk::TreeModel::iterator &iter, const Gtk::TreeModel::Path &/*path*/)
 305 {
 306     if ( iter == _event_list_selection->get_selected() ) {
 307         _event_list_selection->select(_event_log->getCurrEvent());
 308     }
 309 }
 310
 311 void
 312 UndoHistory::_onCollapseEvent(const Gtk::TreeModel::iterator &iter, const Gtk::TreeModel::Path &/*path*/)
 313 {
 314     // Collapsing a branch we're currently in is equal to stepping to the last event in that branch
 315     if ( iter == _event_log->getCurrEvent() ) {
 316         EventLog::const_iterator curr_event_parent = _event_log->getCurrEvent();
 317         EventLog::const_iterator curr_event = curr_event_parent->children().begin();
 318         EventLog::const_iterator last = curr_event_parent->children().end();
 319
 320         _event_log->blockNotifications();
 321         DocumentUndo::redo(_document);
 322
 323         for ( --last ; curr_event != last ; ++curr_event ) {
 324             DocumentUndo::redo(_document);
 325         }
 326         _event_log->blockNotifications(false);
 327
 328         _event_log->setCurrEvent(curr_event);
 329         _event_log->setCurrEventParent(curr_event_parent);
 330         _event_list_selection->select(curr_event_parent);
 331     }
 332 }
 333
 334 const CellRendererInt::Filter& UndoHistory::greater_than_1 = UndoHistory::GreaterThan(1);
 335
 336 } // namespace Dialog
 337 } // namespace UI
 338 } // namespace Inkscape
 339
 340 /*
 341   Local Variables:
 342   mode:c++
 343   c-file-style:"stroustrup"
 344   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 345   indent-tabs-mode:nil
 346   fill-column:99
 347   End:
 348 */
 349 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :