execution-env.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Authors:
 *   Ted Gould <ted@gould.cx>
 *   Abhishek Sharma
 *
 * Copyright (C) 2007-2008 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include "execution-env.h"
 
#include <gtkmm/dialog.h>
#include <gtkmm/messagedialog.h>
 
#include "desktop.h"
#include "document-undo.h"
#include "effect.h"
#include "inkscape.h"
#include "inkscape-window.h"
#include "selection.h"
 
#include "implementation/implementation.h"
#include "prefdialog/prefdialog.h"
#include "ui/widget/canvas.h" // To get window (perverse!)
 
namespace Inkscape {
namespace Extension {
 
ExecutionEnv::ExecutionEnv (Effect * effect, SPDesktop *desktop, Implementation::ImplementationDocumentCache * docCache, bool show_working, bool show_errors) :
    _state(ExecutionEnv::INIT),
    _desktop(desktop),
    _docCache(docCache),
    _effect(effect),
    _show_working(show_working)
{
    if (_desktop) {
        _document = desktop->doc();
    }
    if (_document) {
        // Temporarily prevent undo in this scope
        Inkscape::DocumentUndo::ScopedInsensitive pauseUndo(_document);
        Inkscape::Selection *selection = desktop->getSelection();
        if (selection) {
            // Make sure all selected objects have an ID attribute
            selection->enforceIds();
        }
        genDocCache();
    }
}
 
ExecutionEnv::~ExecutionEnv () {
    if (_visibleDialog != nullptr) {
        _visibleDialog->set_visible(false);
        delete _visibleDialog;
        _visibleDialog = nullptr;
    }
    killDocCache();
    return;
}
 
void
ExecutionEnv::genDocCache () {
    if (_docCache == nullptr && _desktop) {
        // printf("Gen Doc Cache\n");
        _docCache = _effect->get_imp()->newDocCache(_effect, _desktop);
    }
    return;
}
 
void
ExecutionEnv::killDocCache () {
    if (_docCache != nullptr) {
        // printf("Killed Doc Cache\n");
        delete _docCache;
        _docCache = nullptr;
    }
    return;
}
 
void
ExecutionEnv::createWorkingDialog () {
    if (!_desktop)
        return;
 
    if (_visibleDialog != nullptr) {
        _visibleDialog->set_visible(false);
        delete _visibleDialog;
        _visibleDialog = nullptr;
    }
 
    auto const root = _desktop->getCanvas()->get_root();
    auto const window = dynamic_cast<Gtk::Window *>(root);
    if (!window) {
        return;
    }
 
    gchar * dlgmessage = g_strdup_printf(_("'%s' complete, loading result..."), _effect->get_name());
    _visibleDialog = new Gtk::MessageDialog(*window,
                               dlgmessage,
                               false, // use markup
                               Gtk::MessageType::INFO,
                               Gtk::ButtonsType::CANCEL,
                               true); // modal
    _visibleDialog->signal_response().connect(sigc::mem_fun(*this, &ExecutionEnv::workingCanceled));
    g_free(dlgmessage);
 
    Gtk::Dialog *dlg = _effect->get_pref_dialog();
    if (dlg) {
        _visibleDialog->set_transient_for(*dlg);
    } else {
        _visibleDialog->set_transient_for(*_desktop->getInkscapeWindow());
    }
}
 
void
ExecutionEnv::workingCanceled( const int /*resp*/) {
    cancel();
    undo();
    return;
}
 
void
ExecutionEnv::cancel () {
    _desktop->clearWaitingCursor();
    _effect->get_imp()->cancelProcessing();
    return;
}
 
void
ExecutionEnv::undo () {
    DocumentUndo::cancel(_document);
    return;
}
 
void
ExecutionEnv::commit () {
    DocumentUndo::done(_document, _effect->get_name(), "");
    Effect::set_last_effect(_effect);
    _effect->get_imp()->commitDocument();
    killDocCache();
    return;
}
 
void
ExecutionEnv::reselect () {
    if (_desktop && _selectionState) {
        if (auto selection = _desktop->getSelection()) {
            selection->setState(*_selectionState);
        }
    }
    return;
}
 
void
ExecutionEnv::run () {
    _state = ExecutionEnv::RUNNING;
 
    if (_desktop) {
        if (_show_working) {
            createWorkingDialog();
        }
        auto selection = _desktop->getSelection();
        // Save selection state
        _selectionState = std::make_unique<Inkscape::SelectionState>(selection->getState());
        if (_show_working) {
            _desktop->setWaitingCursor();
        }
        _effect->get_imp()->effect(_effect, this, _desktop, _docCache);
        if (_show_working) {
            _desktop->clearWaitingCursor();
        }
        // Restore selection state
        selection->setState(*_selectionState);
        _selectionState.reset();
    } else {
        _effect->get_imp()->effect(_effect, this, _document);
    }
    _state = ExecutionEnv::COMPLETE;
    // _runComplete.signal();
}
 
void
ExecutionEnv::runComplete () {
    _mainloop->quit();
}
 
bool
ExecutionEnv::wait () {
    if (_state != ExecutionEnv::COMPLETE) {
        if (_mainloop) {
            _mainloop = Glib::MainLoop::create(false);
        }
 
        sigc::connection conn = _runComplete.connect(sigc::mem_fun(*this, &ExecutionEnv::runComplete));
        _mainloop->run();
 
        conn.disconnect();
    }
 
    return true;
}
 
 
 
} }  /* namespace Inkscape, Extension */
 
 
 
/*
  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 :