src/event-log.cpp

   1 /*
   2  * Author:
   3  *   Gustav Broberg <broberg@kth.se>
   4  *
   5  * Copyright (c) 2006, 2007 Authors
   6  *
   7  * Released under GNU GPL, read the file 'COPYING' for more information
   8  */
   9
  10 #include <glibmm/i18n.h>
  11
  12 #include "desktop.h"
  13 #include "event-log.h"
  14 #include "inkscape.h"
  15 #include "util/ucompose.hpp"
  16
  17 namespace Inkscape {
  18
  19 EventLog::EventLog(SPDocument* document) :
  20     UndoStackObserver(),
  21     _connected (false),
  22     _document (document),
  23     _event_list_store (Gtk::TreeStore::create(_columns)),
  24     _event_list_selection (NULL),
  25     _event_list_view (NULL),
  26     _curr_event_parent (NULL),
  27     _notifications_blocked (false),
  28     _callback_connections (NULL)
  29 {
  30     // add initial pseudo event
  31     Gtk::TreeRow curr_row = *(_event_list_store->append());
  32     _curr_event = _last_event = curr_row;
  33
  34     curr_row[_columns.description] = _("[Unchanged]");
  35     curr_row[_columns.type] = SP_VERB_FILE_NEW;
  36 }
  37
  38 EventLog::~EventLog() { }
  39
  40 void
  41 EventLog::notifyUndoEvent(Event* log)
  42 {
  43     if ( !_notifications_blocked ) {
  44
  45         // make sure the supplied event matches the next undoable event
  46         g_return_if_fail ( _getUndoEvent() && (*(_getUndoEvent()))[_columns.event] == log );
  47
  48         // if we're on the first child event...
  49         if ( _curr_event->parent() &&
  50              _curr_event == _curr_event->parent()->children().begin() )
  51         {
  52             // ...back up to the parent
  53             _curr_event = _curr_event->parent();
  54             _curr_event_parent = (iterator)NULL;
  55
  56         } else {
  57
  58             // if we're about to leave a branch, collapse it
  59             if ( !_curr_event->children().empty() && _connected ) {
  60                 (*_callback_connections)[CALLB_COLLAPSE].block();
  61                 _event_list_view->collapse_row(_event_list_store->get_path(_curr_event));
  62                 (*_callback_connections)[CALLB_COLLAPSE].block(false);
  63             }
  64
  65             --_curr_event;
  66
  67             // if we're entering a branch, move to the end of it
  68             if (!_curr_event->children().empty()) {
  69                 _curr_event_parent = _curr_event;
  70                 _curr_event = _curr_event->children().end();
  71                 --_curr_event;
  72             }
  73         }
  74
  75         // update the view
  76         if (_connected) {
  77             (*_callback_connections)[CALLB_SELECTION_CHANGE].block();
  78             (*_callback_connections)[CALLB_EXPAND].block();
  79
  80             Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
  81             _event_list_view->expand_to_path(curr_path);
  82             _event_list_selection->select(curr_path);
  83             _event_list_view->scroll_to_row(curr_path);
  84
  85             (*_callback_connections)[CALLB_EXPAND].block(false);
  86             (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false);
  87         }
  88
  89         updateUndoVerbs();
  90     }
  91
  92 }
  93
  94 void
  95 EventLog::notifyRedoEvent(Event* log)
  96 {
  97     if ( !_notifications_blocked ) {
  98
  99         // make sure the supplied event matches the next redoable event
 100         g_return_if_fail ( _getRedoEvent() && (*(_getRedoEvent()))[_columns.event] == log );
 101
 102         // if we're on a parent event...
 103         if ( !_curr_event->children().empty() ) {
 104
 105             // ...move to its first child
 106             _curr_event_parent = _curr_event;
 107             _curr_event = _curr_event->children().begin();
 108
 109         } else {
 110
 111             ++_curr_event;
 112
 113             // if we are about to leave a branch...
 114             if ( _curr_event->parent() &&
 115                  _curr_event == _curr_event->parent()->children().end() )
 116             {
 117
 118                 // ...collapse it
 119                 if (_connected) {
 120                     (*_callback_connections)[CALLB_SELECTION_CHANGE].block();
 121                     (*_callback_connections)[CALLB_COLLAPSE].block();
 122                     _event_list_view->collapse_row(_event_list_store->get_path(_curr_event->parent()));
 123                     (*_callback_connections)[CALLB_COLLAPSE].block(false);
 124                     (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false);
 125                 }
 126
 127                 // ...and move to the next event at parent level
 128                 _curr_event = _curr_event->parent();
 129                 _curr_event_parent = (iterator)NULL;
 130
 131                 ++_curr_event;
 132             }
 133         }
 134
 135         // update the view
 136         if (_connected) {
 137             Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
 138
 139             (*_callback_connections)[CALLB_SELECTION_CHANGE].block();
 140             (*_callback_connections)[CALLB_EXPAND].block();
 141
 142             _event_list_view->expand_to_path(curr_path);
 143             _event_list_selection->select(curr_path);
 144             _event_list_view->scroll_to_row(curr_path);
 145
 146             (*_callback_connections)[CALLB_EXPAND].block(false);
 147             (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false);
 148         }
 149
 150         updateUndoVerbs();
 151     }
 152
 153 }
 154
 155 void
 156 EventLog::notifyUndoCommitEvent(Event* log)
 157 {
 158     _clearRedo();
 159
 160     const unsigned int event_type = log->type;
 161
 162     Gtk::TreeRow curr_row;
 163
 164     // if the new event is of the same type as the previous then create a new branch
 165     if ( event_type == (*_curr_event)[_columns.type] ) {
 166         if ( !_curr_event_parent ) {
 167             _curr_event_parent = _curr_event;
 168         }
 169         curr_row = *(_event_list_store->append(_curr_event_parent->children()));
 170         (*_curr_event_parent)[_columns.child_count] = _curr_event_parent->children().size() + 1;
 171     } else {
 172         curr_row = *(_event_list_store->append());
 173         curr_row[_columns.child_count] = 1;
 174
 175         _curr_event = _last_event = curr_row;
 176
 177         // collapse if we're leaving a branch
 178         if (_curr_event_parent && _connected) {
 179             (*_callback_connections)[CALLB_COLLAPSE].block();
 180             _event_list_view->collapse_row(_event_list_store->get_path(_curr_event_parent));
 181             (*_callback_connections)[CALLB_COLLAPSE].block(false);
 182         }
 183
 184         _curr_event_parent = (iterator)(NULL);
 185     }
 186
 187     _curr_event = _last_event = curr_row;
 188
 189     curr_row[_columns.event] = log;
 190     curr_row[_columns.type] = event_type;
 191     curr_row[_columns.description] = log->description;
 192
 193     // update the view
 194     if (_connected) {
 195         Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
 196
 197         (*_callback_connections)[CALLB_SELECTION_CHANGE].block();
 198         (*_callback_connections)[CALLB_EXPAND].block();
 199
 200         _event_list_view->expand_to_path(curr_path);
 201         _event_list_selection->select(curr_path);
 202         _event_list_view->scroll_to_row(curr_path);
 203
 204         (*_callback_connections)[CALLB_EXPAND].block(false);
 205         (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false);
 206     }
 207
 208     updateUndoVerbs();
 209 }
 210
 211 void
 212 EventLog::notifyClearUndoEvent()
 213 {
 214     _clearUndo();
 215     updateUndoVerbs();
 216 }
 217
 218 void
 219 EventLog::notifyClearRedoEvent()
 220 {
 221     _clearRedo();
 222     updateUndoVerbs();
 223 }
 224
 225 void
 226 EventLog::connectWithDialog(Gtk::TreeView *event_list_view, CallbackMap *callback_connections)
 227 {
 228     _event_list_view = event_list_view;
 229     _event_list_selection = event_list_view->get_selection();
 230     _event_list_selection->set_mode(Gtk::SELECTION_SINGLE);
 231
 232     _callback_connections = callback_connections;
 233
 234     (*_callback_connections)[CALLB_SELECTION_CHANGE].block();
 235     (*_callback_connections)[CALLB_EXPAND].block();
 236
 237     _event_list_view->expand_to_path(_event_list_store->get_path(_curr_event));
 238     _event_list_selection->select(_curr_event);
 239
 240     (*_callback_connections)[CALLB_EXPAND].block(false);
 241     (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false);
 242
 243     _connected = true;
 244 }
 245
 246 void
 247 EventLog::updateUndoVerbs()
 248 {
 249     if(_document) {
 250
 251         if(_getUndoEvent()) {
 252             Inkscape::Verb::get(SP_VERB_EDIT_UNDO)->sensitive(_document, true);
 253
 254             Inkscape::Verb::get(SP_VERB_EDIT_UNDO)->name(_document, String::ucompose("%1: %2",
 255                       Glib::ustring(_("_Undo")),
 256                       Glib::ustring((*_getUndoEvent())[_columns.description])));
 257         } else {
 258             Inkscape::Verb::get(SP_VERB_EDIT_UNDO)->name(_document, _("_Undo"));
 259             Inkscape::Verb::get(SP_VERB_EDIT_UNDO)->sensitive(_document, false);
 260         }
 261
 262         if(_getRedoEvent()) {
 263             Inkscape::Verb::get(SP_VERB_EDIT_REDO)->sensitive(_document, true);
 264             Inkscape::Verb::get(SP_VERB_EDIT_REDO)->name(_document, String::ucompose("%1: %2",
 265                       Glib::ustring(_("_Redo")),
 266                       Glib::ustring((*_getRedoEvent())[_columns.description])));
 267
 268         } else {
 269             Inkscape::Verb::get(SP_VERB_EDIT_REDO)->name(_document, _("_Redo"));
 270             Inkscape::Verb::get(SP_VERB_EDIT_REDO)->sensitive(_document, false);
 271         }
 272
 273     }
 274
 275 }
 276
 277
 278 EventLog::const_iterator
 279 EventLog::_getUndoEvent() const
 280 {
 281     const_iterator undo_event = (const_iterator)NULL;
 282     if( _curr_event != _event_list_store->children().begin() )
 283         undo_event = _curr_event;
 284     return undo_event;
 285 }
 286
 287 EventLog::const_iterator
 288 EventLog::_getRedoEvent() const
 289 {
 290     const_iterator redo_event = (const_iterator)NULL;
 291
 292     if ( _curr_event != _last_event ) {
 293
 294         if ( !_curr_event->children().empty() )
 295             redo_event = _curr_event->children().begin();
 296         else  {
 297             redo_event = _curr_event;
 298             ++redo_event;
 299
 300             if ( redo_event->parent() &&
 301                  redo_event == redo_event->parent()->children().end() ) {
 302
 303                 redo_event = redo_event->parent();
 304                 ++redo_event;
 305
 306             }
 307         }
 308
 309     }
 310
 311     return redo_event;
 312 }
 313
 314 void
 315 EventLog::_clearUndo()
 316 {
 317     // TODO: Implement when needed
 318 }
 319
 320 void
 321 EventLog::_clearRedo()
 322 {
 323     if ( _last_event != _curr_event ) {
 324
 325         _last_event = _curr_event;
 326
 327         if ( !_last_event->children().empty() ) {
 328             _last_event = _last_event->children().begin();
 329         } else {
 330             ++_last_event;
 331         }
 332
 333         while ( _last_event != _event_list_store->children().end() ) {
 334
 335             if (_last_event->parent()) {
 336                 while ( _last_event != _last_event->parent()->children().end() ) {
 337                     _last_event = _event_list_store->erase(_last_event);
 338                 }
 339                 _last_event = _last_event->parent();
 340
 341                 (*_last_event)[_columns.child_count] = _last_event->children().size() + 1;
 342
 343                 ++_last_event;
 344             } else {
 345                 _last_event = _event_list_store->erase(_last_event);
 346             }
 347
 348         }
 349
 350     }
 351 }
 352
 353 } // namespace Inkscape
 354
 355
 356 /*
 357   Local Variables:
 358   mode:c++
 359   c-file-style:"stroustrup"
 360   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 361   indent-tabs-mode:nil
 362   fill-column:99
 363   End:
 364 */
 365 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :