event-log.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Author:
 *   Gustav Broberg <broberg@kth.se>
 *   Jon A. Cruz <jon@joncruz.org>
 *
 * Copyright (c) 2014 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include "event-log.h"
 
 
#include <glibmm/i18n.h>
 
#include "document.h"
#include "actions/actions-undo-document.h"
#include "util/signal-blocker.h"
 
namespace
{
 
class DialogConnection
{
public:
    DialogConnection(Gtk::TreeView *event_list_view, Inkscape::EventLog::CallbackMap *callback_connections) :
        _event_list_view(event_list_view),
        _callback_connections(callback_connections),
        _event_list_selection(_event_list_view->get_selection())
    {            
    }
 
    Gtk::TreeView *_event_list_view;
 
    // Map of connections used to temporary block/unblock callbacks in a TreeView
    Inkscape::EventLog::CallbackMap *_callback_connections;
 
    Glib::RefPtr<Gtk::TreeSelection> _event_list_selection; 
};
 
class ConnectionMatcher
{
public:
    ConnectionMatcher(Gtk::TreeView *view,
                      Inkscape::EventLog::CallbackMap *callbacks) :
        _view(view),
        _callbacks(callbacks)
    {
    }
 
    bool operator() (DialogConnection const &dlg)
    {
        return (_view == dlg._event_list_view) && (_callbacks == dlg._callback_connections);
    }
 
    Gtk::TreeView *_view;
    Inkscape::EventLog::CallbackMap *_callbacks;
};
 
void addBlocker(std::vector<std::unique_ptr<SignalBlocker<sigc::connection>>> &blockers, sigc::connection *connection)
{
    blockers.emplace_back(new SignalBlocker(*connection));
}
 
 
} // namespace
 
namespace Inkscape {
 
class EventLogPrivate
{
public:
    EventLogPrivate() :
        _connections()
    {
    }
 
    bool isConnected() const
    {
        return !_connections.empty();
    }
 
    void addDialogConnection(Gtk::TreeView *event_list_view,
                             Inkscape::EventLog::CallbackMap *callback_connections,
                             Glib::RefPtr<Gtk::TreeStore> event_list_store,
                             Inkscape::EventLog::iterator &curr_event)
    {
        if (std::find_if(_connections.begin(), _connections.end(), ConnectionMatcher(event_list_view, callback_connections)) != _connections.end()) {
            // skipping
        }
        else
        {
            DialogConnection dlg(event_list_view, callback_connections);
 
            dlg._event_list_selection->set_mode(Gtk::SelectionMode::SINGLE);
 
            {
                std::vector<std::unique_ptr<SignalBlocker<sigc::connection>>> blockers;
                addBlocker(blockers, &(*dlg._callback_connections)[Inkscape::EventLog::CALLB_SELECTION_CHANGE]);
                addBlocker(blockers, &(*dlg._callback_connections)[Inkscape::EventLog::CALLB_EXPAND]);
 
                dlg._event_list_view->expand_to_path(event_list_store->get_path(curr_event));
                dlg._event_list_selection->select(curr_event);
            }
            _connections.push_back(dlg);
        }
    }
 
    void removeDialogConnection(Gtk::TreeView *event_list_view, Inkscape::EventLog::CallbackMap *callback_connections)
    {
        std::vector<DialogConnection>::iterator it = std::find_if(_connections.begin(), _connections.end(), ConnectionMatcher(event_list_view, callback_connections));
        if (it != _connections.end()) {
            _connections.erase(it);
        }
    }
 
    void collapseRow(Gtk::TreeModel::Path const &path)
    {
        std::vector<std::unique_ptr<SignalBlocker<sigc::connection>>> blockers;
        for (auto & _connection : _connections)
        {
            addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_SELECTION_CHANGE]);
            addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_COLLAPSE]);
        }
 
        for (auto & _connection : _connections)
        {
            _connection._event_list_view->collapse_row(path);
        }
    }
 
    void selectRow(Gtk::TreeModel::Path const &path)
    {
        std::vector<std::unique_ptr<SignalBlocker<sigc::connection>>> blockers;
        for (auto & _connection : _connections)
        {
            addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_SELECTION_CHANGE]);
            addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_EXPAND]);
        }
 
        for (auto & _connection : _connections)
        {
            _connection._event_list_view->expand_to_path(path);
            _connection._event_list_selection->select(path);
            _connection._event_list_view->scroll_to_row(path);
        }
    }
 
    void clearEventList(Glib::RefPtr<Gtk::TreeStore> eventListStore)
    {
        if (eventListStore) {
            std::vector<std::unique_ptr<SignalBlocker<sigc::connection>>> blockers;
            for (auto & _connection : _connections)
            {
                addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_SELECTION_CHANGE]);
                addBlocker(blockers, &(*_connection._callback_connections)[Inkscape::EventLog::CALLB_EXPAND]);
            }
 
            eventListStore->clear();
        }
    }
 
    std::vector<DialogConnection> _connections;
};
 
const EventLog::EventModelColumns &EventLog::getColumns()
{
    static const EventModelColumns columns;
    return columns;
}
 
EventLog::EventLog(SPDocument* document) :
    UndoStackObserver(),
    _priv(new EventLogPrivate()),
    _document (document),
    _event_list_store (Gtk::TreeStore::create(getColumns())),
    _curr_event_parent (nullptr),
    _notifications_blocked (false)
{
    // add initial pseudo event
    Gtk::TreeRow curr_row = *(_event_list_store->append());
    _curr_event = _last_saved = _last_event = curr_row.get_iter();
 
    // Save it so it can be modified
    _first_event = curr_row.get_iter();
    
    auto &_columns = getColumns();
    curr_row[_columns.description] = _("[No more changes]");
    curr_row[_columns.icon_name] = "document-new";
    curr_row[_columns.child_count] = 0;
}
 
EventLog::~EventLog() {
    // avoid crash by clearing entries here (see bug #1071082)
    _priv->clearEventList(_event_list_store);
 
    delete _priv;
    _priv = nullptr;
}
 
void
EventLog::notifyUndoEvent(Event* log) 
{
    if ( !_notifications_blocked ) {
        auto &_columns = getColumns();
    
        // make sure the supplied event matches the next undoable event
        g_return_if_fail ( _getUndoEvent() && (*(_getUndoEvent()))[_columns.event] == log );
 
        // if we're on the first child event...
        if ( _curr_event->parent() &&
             _curr_event == _curr_event->parent()->children().begin() )
    {
            // ...back up to the parent
            _curr_event = _curr_event->parent();
            _curr_event_parent = (iterator)nullptr;
 
    } else {
 
            // if we're about to leave a branch, collapse it
            if ( !_curr_event->children().empty() ) {
                _priv->collapseRow(_event_list_store->get_path(_curr_event));
            }
 
            --_curr_event;
 
            // if we're entering a branch, move to the end of it
            if (!_curr_event->children().empty()) {
                _curr_event_parent = _curr_event;
                _curr_event = _curr_event->children().end();
                --_curr_event;
            }
    }
 
        checkForVirginity();
 
        // update the view
        if (_priv->isConnected()) {
            Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
            _priv->selectRow(curr_path);
        }
 
        updateUndoVerbs();
    }
 
}
 
void
EventLog::notifyRedoEvent(Event* log)
{
    if ( !_notifications_blocked ) {
        auto &_columns = getColumns();
 
        // make sure the supplied event matches the next redoable event
        g_return_if_fail ( _getRedoEvent() && (*(_getRedoEvent()))[_columns.event] == log );
 
        // if we're on a parent event...
        if ( !_curr_event->children().empty() ) {
 
            // ...move to its first child
            _curr_event_parent = _curr_event;
            _curr_event = _curr_event->children().begin();
 
        } else {
    
            ++_curr_event;
 
            // if we are about to leave a branch...
            if ( _curr_event->parent() &&
                 _curr_event == _curr_event->parent()->children().end() )
            {
 
                // ...collapse it
                _priv->collapseRow(_event_list_store->get_path(_curr_event->parent()));
 
                // ...and move to the next event at parent level
                _curr_event = _curr_event->parent();
                _curr_event_parent = (iterator)nullptr;
 
                ++_curr_event;
            }
        }
 
        checkForVirginity();
 
        // update the view
        if (_priv->isConnected()) {
            Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
            _priv->selectRow(curr_path);
        }
 
        updateUndoVerbs();
    }
 
}
 
void 
EventLog::notifyUndoCommitEvent(Event* log)
{
    _clearRedo();
 
    auto icon_name = log->icon_name;
 
    Gtk::TreeRow curr_row;
    auto &_columns = getColumns();
 
    // if the new event is of the same type as the previous then create a new branch
    if ( icon_name == Glib::ustring{(*_curr_event)[_columns.icon_name]} ) {
        if ( !_curr_event_parent ) {
            _curr_event_parent = _curr_event;
        }
        curr_row = *(_event_list_store->append(_curr_event_parent->children()));
        (*_curr_event_parent)[_columns.child_count] = _curr_event_parent->children().size() + 1;
    } else {
        curr_row = *(_event_list_store->append());
        curr_row[_columns.child_count] = 1;
 
        _curr_event = _last_event = curr_row.get_iter();
 
        // collapse if we're leaving a branch
        if (_curr_event_parent) {
            _priv->collapseRow(_event_list_store->get_path(_curr_event_parent));
        }
 
        _curr_event_parent = (iterator)(nullptr);
    }
 
    _curr_event = _last_event = curr_row.get_iter();
 
    curr_row[_columns.event] = log;
    curr_row[_columns.icon_name] = icon_name;
    curr_row[_columns.description] = log->description;
 
    checkForVirginity();
 
    // update the view
    if (_priv->isConnected()) {
        Gtk::TreePath curr_path = _event_list_store->get_path(_curr_event);
        _priv->selectRow(curr_path);
    }
 
    updateUndoVerbs();
}
 
void
EventLog::notifyUndoExpired(Event *log)
{
    auto &columns = getColumns();
 
    if (_event_list_store->children().size() == 1)
        return; // Nothing to do, nothing in the undo log
 
    // We only have to look at one item because we never expire from the middle.
    iterator iter = _event_list_store->children().begin();
 
    // Skip first item, it's the non-event label
    if (iter == _first_event)
        iter++;
 
    assert((*iter)[columns.event] == log);
 
    iterator to_remove;
    if (iter->children().size() > 0) {
        // Move first child's log to parent as the parent is being deleted
        to_remove = iter->children().begin();
 
        Event *child_log = (*to_remove)[columns.event];
        Glib::ustring desc = (*to_remove)[columns.description];
        (*iter)[columns.event] = child_log;
        (*iter)[columns.description] = desc;
    } else {
        to_remove = iter;
    }
 
    // This should never happen as we should never expire undo items from the middle.
    assert(to_remove->children().size() == 0);
 
    if (auto parent = to_remove->parent()) {
        (*parent)[columns.child_count] = to_remove->parent()->children().size() - 1;
    }
 
    _event_list_store->erase(to_remove);
 
    // Tell the user about the forgotten undo stack
    if ((*_first_event)[columns.child_count] == 0) {
        (*_first_event)[columns.description] = _("[Changes forgotten]");
    }
    (*_first_event)[columns.child_count] = (*_first_event)[columns.child_count] + 1;
}
 
void
EventLog::notifyClearUndoEvent()
{
    _clearUndo();    
    updateUndoVerbs();
}
 
void
EventLog::notifyClearRedoEvent()
{
    _clearRedo();
    updateUndoVerbs();
}
 
void  EventLog::addDialogConnection(Gtk::TreeView *event_list_view, CallbackMap *callback_connections)
{
    _priv->addDialogConnection(event_list_view, callback_connections, _event_list_store, _curr_event);
}
 
void EventLog::removeDialogConnection(Gtk::TreeView *event_list_view, CallbackMap *callback_connections)
{
    _priv->removeDialogConnection(event_list_view, callback_connections);
}
 
// Enable/disable undo/redo GUI items.
void
EventLog::updateUndoVerbs()
{
    if (_document) {
        enable_undo_actions(_document, static_cast<bool>(_getUndoEvent()), static_cast<bool>(_getRedoEvent()));
    }
}
 
 
EventLog::const_iterator
EventLog::_getUndoEvent() const
{
    const_iterator undo_event = (const_iterator)nullptr;
    if( _curr_event != _event_list_store->children().begin() )
        undo_event = _curr_event;
    return undo_event;
}
 
EventLog::const_iterator
EventLog::_getRedoEvent() const
{
    const_iterator redo_event = (const_iterator)nullptr;
 
    if ( _curr_event != _last_event ) {
 
        if ( !_curr_event->children().empty() )
            redo_event = _curr_event->children().begin();
        else  {
            redo_event = _curr_event;
            ++redo_event;
 
            if ( redo_event->parent() &&
                 redo_event == redo_event->parent()->children().end() ) {
 
                redo_event = redo_event->parent();
                ++redo_event;
 
            }
        }
 
    }
 
    return redo_event;
}
 
void
EventLog::_clearUndo()
{
    // TODO: Implement when needed
}
 
void
EventLog::_clearRedo()
{
    if ( _last_event != _curr_event ) {
        auto &_columns = getColumns();
 
        _last_event = _curr_event;
 
        if ( !_last_event->children().empty() ) {
            _last_event = _last_event->children().begin();
        } else {
            ++_last_event;
        }
 
        while ( _last_event != _event_list_store->children().end() ) {
 
            if (_last_event->parent()) {
                while ( _last_event != _last_event->parent()->children().end() ) {
                    _last_event = _event_list_store->erase(_last_event);
                }
                _last_event = _last_event->parent();
 
                (*_last_event)[_columns.child_count] = _last_event->children().size() + 1;
 
                ++_last_event;
            } else {
                _last_event = _event_list_store->erase(_last_event);
            }
 
        }
 
    }
}
 
/* mark document as untouched if we reach a state where the document was previously saved */
void
EventLog::checkForVirginity() {
    g_return_if_fail (_document);
    if (_curr_event == _last_saved) {
        _document->setModifiedSinceSave(false);
    }
}
 
} // namespace Inkscape
 
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :