src/ui/dialog/undo-history.cpp

   1 /**
   2  * \brief Undo History dialog
   3  *
   4  * Author:
   5  *   Gustav Broberg <broberg@kth.se>
   6  *
   7  * Copyright (C) 2006 Authors
   8  *
   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 "ui/icons.h"
  24 #include "verbs.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
  99 UndoHistory::UndoHistory()
 100     : Dialog ("dialogs.undo-history", SP_VERB_DIALOG_UNDO_HISTORY),
 101       _document (SP_ACTIVE_DOCUMENT),
 102       _event_log (_document ? &_document->getEventLog() : NULL),
 103       _columns (_event_log ? &_event_log->getColumns() : NULL),
 104       _event_list_selection (_event_list_view.get_selection())
 105 {
 106     if( !_document || !_event_log || !_columns ) return;
 107
 108     set_size_request(300, 400);
 109
 110     get_vbox()->pack_start(_scrolled_window);
 111     _scrolled_window.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 112
 113     _event_list_store = _event_log->getEventListStore();
 114
 115     _event_list_view.set_model(_event_list_store);
 116     _event_list_view.set_rules_hint(false);
 117     _event_list_view.set_enable_search(false);
 118     _event_list_view.set_headers_visible(false);
 119
 120     CellRendererSPIcon* icon_renderer = Gtk::manage(new CellRendererSPIcon());
 121     icon_renderer->property_xpad() = 8;
 122     icon_renderer->property_width() = 36;
 123     int cols_count = _event_list_view.append_column("Icon", *icon_renderer);
 124
 125     Gtk::TreeView::Column* icon_column = _event_list_view.get_column(cols_count-1);
 126     icon_column->add_attribute(icon_renderer->property_event_type(), _columns->type);
 127
 128     Gtk::CellRendererText* description_renderer = Gtk::manage(new Gtk::CellRendererText());
 129
 130     cols_count = _event_list_view.append_column("Description", *description_renderer);
 131     Gtk::TreeView::Column* description_column = _event_list_view.get_column(cols_count-1);
 132     description_column->add_attribute(description_renderer->property_text(), _columns->description);
 133     description_column->set_resizable();
 134
 135     _event_list_view.set_expander_column( *_event_list_view.get_column(cols_count-1) );
 136
 137     CellRendererInt* children_renderer = Gtk::manage(new CellRendererInt(greater_than_1));
 138     children_renderer->property_weight() = 600; // =Pango::WEIGHT_SEMIBOLD (not defined in old versions of pangomm)
 139     children_renderer->property_xalign() = 1.0;
 140     children_renderer->property_xpad() = 20;
 141
 142     cols_count = _event_list_view.append_column("Children", *children_renderer);
 143     Gtk::TreeView::Column* children_column = _event_list_view.get_column(cols_count-1);
 144     children_column->add_attribute(children_renderer->property_number(), _columns->child_count);
 145
 146     _scrolled_window.add(_event_list_view);
 147
 148     // connect callbacks
 149     _callback_connections[EventLog::CALLB_SELECTION_CHANGE] =
 150         _event_list_selection->signal_changed().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onListSelectionChange));
 151
 152     _callback_connections[EventLog::CALLB_EXPAND] =
 153         _event_list_view.signal_row_expanded().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onExpandEvent));
 154
 155     _callback_connections[EventLog::CALLB_COLLAPSE] =
 156         _event_list_view.signal_row_collapsed().connect(sigc::mem_fun(*this, &Inkscape::UI::Dialog::UndoHistory::_onCollapseEvent));
 157
 158     // connect with the event log
 159     _event_log->connectWithDialog(&_event_list_view, &_callback_connections);
 160
 161     _event_list_view.scroll_to_row(_event_list_store->get_path(_event_list_selection->get_selected()));
 162
 163     show_all_children();
 164
 165 }
 166
 167 UndoHistory::~UndoHistory()
 168 {
 169 }
 170
 171 void
 172 UndoHistory::_onListSelectionChange()
 173 {
 174
 175     EventLog::const_iterator selected = _event_list_selection->get_selected();
 176
 177     /* If no event is selected in the view, find the right one and select it. This happens whenever
 178      * a branch we're currently in is collapsed.
 179      */
 180     if (!selected) {
 181
 182         EventLog::iterator curr_event = _event_log->getCurrEvent();
 183
 184         if (curr_event->parent()) {
 185
 186             EventLog::iterator curr_event_parent = curr_event->parent();
 187             EventLog::iterator last = curr_event_parent->children().end();
 188
 189             _event_log->blockNotifications();
 190             for ( --last ; curr_event != last ; ++curr_event ) {
 191                 sp_document_redo(_document);
 192             }
 193             _event_log->blockNotifications(false);
 194
 195             _event_log->setCurrEvent(curr_event);
 196             _event_list_selection->select(curr_event_parent);
 197
 198         } else {  // this should not happen
 199             _event_list_selection->select(curr_event);
 200         }
 201
 202     } else {
 203
 204         EventLog::const_iterator last_selected = _event_log->getCurrEvent();
 205
 206         /* Selecting a collapsed parent event is equal to selecting the last child
 207          * of that parent's branch.
 208          */
 209
 210         if ( !selected->children().empty() &&
 211              !_event_list_view.row_expanded(_event_list_store->get_path(selected)) )
 212         {
 213             selected = selected->children().end();
 214             --selected;
 215         }
 216
 217         // An event before the current one has been selected. Undo to the selected event.
 218         if ( _event_list_store->get_path(selected) <
 219              _event_list_store->get_path(last_selected) )
 220         {
 221             _event_log->blockNotifications();
 222
 223             while ( selected != last_selected ) {
 224
 225                 sp_document_undo(_document);
 226
 227                 if ( last_selected->parent() &&
 228                      last_selected == last_selected->parent()->children().begin() )
 229                 {
 230                     last_selected = last_selected->parent();
 231                     _event_log->setCurrEventParent((EventLog::iterator)NULL);
 232                 } else {
 233                     --last_selected;
 234                     if ( !last_selected->children().empty() ) {
 235                         _event_log->setCurrEventParent(last_selected);
 236                         last_selected = last_selected->children().end();
 237                         --last_selected;
 238                     }
 239                 }
 240             }
 241             _event_log->blockNotifications(false);
 242             _event_log->updateUndoVerbs();
 243
 244         } else { // An event after the current one has been selected. Redo to the selected event.
 245
 246             _event_log->blockNotifications();
 247
 248             while ( selected != last_selected ) {
 249
 250                 sp_document_redo(_document);
 251
 252                 if ( !last_selected->children().empty() ) {
 253                     _event_log->setCurrEventParent(last_selected);
 254                     last_selected = last_selected->children().begin();
 255                 } else {
 256                     ++last_selected;
 257                     if ( last_selected->parent() &&
 258                          last_selected == last_selected->parent()->children().end() )
 259                     {
 260                         last_selected = last_selected->parent();
 261                         ++last_selected;
 262                         _event_log->setCurrEventParent((EventLog::iterator)NULL);
 263                     }
 264                 }
 265             }
 266             _event_log->blockNotifications(false);
 267
 268         }
 269
 270         _event_log->setCurrEvent(selected);
 271         _event_log->updateUndoVerbs();
 272     }
 273
 274 }
 275
 276 void
 277 UndoHistory::_onExpandEvent(const Gtk::TreeModel::iterator &iter, const Gtk::TreeModel::Path &path)
 278 {
 279     if ( iter == _event_list_selection->get_selected() )
 280     {
 281         _event_list_selection->select(_event_log->getCurrEvent());
 282     }
 283 }
 284
 285 void
 286 UndoHistory::_onCollapseEvent(const Gtk::TreeModel::iterator &iter, const Gtk::TreeModel::Path &path)
 287 {
 288     // Collapsing a branch we're currently in is equal to stepping to the last event in that branch
 289     if ( iter == _event_log->getCurrEvent() )
 290     {
 291         EventLog::const_iterator curr_event_parent = _event_log->getCurrEvent();
 292         EventLog::const_iterator curr_event = curr_event_parent->children().begin();
 293         EventLog::const_iterator last = curr_event_parent->children().end();
 294
 295         _event_log->blockNotifications();
 296         sp_document_redo(_document);
 297
 298         for ( --last ; curr_event != last ; ++curr_event ) {
 299             sp_document_redo(_document);
 300         }
 301         _event_log->blockNotifications(false);
 302
 303         _event_log->setCurrEvent(curr_event);
 304         _event_log->setCurrEventParent(curr_event_parent);
 305         _event_list_selection->select(curr_event_parent);
 306     }
 307 }
 308
 309 const CellRendererInt::Filter& UndoHistory::greater_than_1 = UndoHistory::GreaterThan(1);
 310
 311 } // namespace Dialog
 312 } // namespace UI
 313 } // namespace Inkscape
 314
 315 /*
 316   Local Variables:
 317   mode:c++
 318   c-file-style:"stroustrup"
 319   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 320   indent-tabs-mode:nil
 321   fill-column:99
 322   End:
 323 */
 324 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :