CompositionDockerDock Class Reference

#include <compositiondocker_dock.h>

Inheritance diagram for CompositionDockerDock:

Public Slots
void	slotScrollerStateChanged (QScroller::State state)

Public Member Functions
	CompositionDockerDock ()
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
void	unsetCanvas () override
void	updateModel ()
	~CompositionDockerDock () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Protected Member Functions
bool	eventFilter (QObject *obj, QEvent *event) override

Private Slots
void	activateCurrentIndex ()
void	activated (const QModelIndex &index)
void	customContextMenuRequested (QPoint pos)
void	deleteClicked ()
void	exportAnimationClicked ()
void	exportImageClicked ()
void	moveCompositionDown ()
void	moveCompositionUp ()
void	renameComposition ()
void	saveClicked ()
void	updateComposition ()

Private Attributes
QVector< KisAction * >	m_actions
QPointer< KisCanvas2 >	m_canvas
CompositionModel *	m_model

Detailed Description

Definition at line 24 of file compositiondocker_dock.h.

Constructor & Destructor Documentation

CompositionDockerDock()

CompositionDockerDock::CompositionDockerDock

(

)

Definition at line 52 of file compositiondocker_dock.cpp.

    : QDockWidget(i18n("Compositions"))
    , m_canvas(0)
{
    QWidget* widget = new QWidget(this);
    setupUi(widget);
    m_model = new CompositionModel(this);
    compositionView->setModel(m_model);
    compositionView->installEventFilter(this);
    deleteButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
    saveButton->setIcon(KisIconUtils::loadIcon("list-add"));
    moveUpButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
    moveDownButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
 
    deleteButton->setToolTip(i18n("Delete Composition"));
    saveButton->setToolTip(i18n("New Composition"));
    exportCompositions->setToolTip(i18n("Export Composition"));
    moveUpButton->setToolTip(i18n("Move Composition Up"));
    moveDownButton->setToolTip(i18n("Move Composition Down"));
 
    setWidget(widget);
 
    connect( compositionView, SIGNAL(doubleClicked(QModelIndex)),
             this, SLOT(activated(QModelIndex)) );
 
    compositionView->setContextMenuPolicy(Qt::CustomContextMenu);
    connect( compositionView, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(customContextMenuRequested(QPoint)));
 
    connect( deleteButton, SIGNAL(clicked(bool)), this, SLOT(deleteClicked()));
    connect( saveButton, SIGNAL(clicked(bool)), this, SLOT(saveClicked()));
    connect( moveUpButton, SIGNAL(clicked(bool)), this, SLOT(moveCompositionUp()));
    connect( moveDownButton, SIGNAL(clicked(bool)), this, SLOT(moveCompositionDown()));
 
    QAction* imageAction = new QAction(KisIconUtils::loadIcon("document-export-16"), i18n("Export Images"), this);
    connect(imageAction, SIGNAL(triggered(bool)), this, SLOT(exportImageClicked()));
 
    QAction* animationAction = new QAction(KisIconUtils::loadIcon("addblankframe-16"), i18n("Export Animations"), this);
    connect(animationAction, SIGNAL(triggered(bool)), this, SLOT(exportAnimationClicked()));
 
    exportCompositions->setDefaultAction(imageAction);
 
    QMenu* exportMenu = new QMenu(this);
    exportMenu->addAction(imageAction);
    exportMenu->addAction(animationAction);
 
    exportCompositions->setMenu(exportMenu);
 
    connect(exportMenu, &QMenu::triggered, [this](QAction* triggered){
        exportCompositions->setDefaultAction(triggered);
    });
 
    saveNameEdit->setPlaceholderText(i18n("Insert Name"));
 
    QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(compositionView);
    if (scroller) {
        connect(scroller, SIGNAL(stateChanged(QScroller::State)), this, SLOT(slotScrollerStateChanged(QScroller::State)));
    }
 
}

References activated(), connect(), KisKineticScroller::createPreconfiguredScroller(), customContextMenuRequested(), deleteClicked(), exportAnimationClicked(), exportImageClicked(), KisIconUtils::loadIcon(), m_model, moveCompositionDown(), moveCompositionUp(), saveClicked(), and slotScrollerStateChanged().

~CompositionDockerDock()

CompositionDockerDock::~CompositionDockerDock ( )

override

Definition at line 113 of file compositiondocker_dock.cpp.

{
 
}

Member Function Documentation

activateCurrentIndex

void CompositionDockerDock::activateCurrentIndex ( )

privateslot

Definition at line 416 of file compositiondocker_dock.cpp.

{
    QModelIndex index = compositionView->currentIndex();
    if (index.isValid()) {
        activated(index);
    }
}

References activated().

activated

void CompositionDockerDock::activated ( const QModelIndex & index )

privateslot

Definition at line 156 of file compositiondocker_dock.cpp.

{
    KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
    composition->apply();
}

References CompositionModel::compositionFromIndex(), and m_model.

customContextMenuRequested

void CompositionDockerDock::customContextMenuRequested ( QPoint pos )

privateslot

Definition at line 424 of file compositiondocker_dock.cpp.

{
    if (m_actions.isEmpty()) return;
 
    QMenu menu;
    Q_FOREACH (KisAction *action, m_actions) {
        menu.addAction(action);
 
    }
    menu.exec(compositionView->mapToGlobal(pos));
}

References m_actions.

deleteClicked

void CompositionDockerDock::deleteClicked ( )

privateslot

Definition at line 162 of file compositiondocker_dock.cpp.

{
    QModelIndex index = compositionView->currentIndex();
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
        KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
        m_canvas->viewManager()->image()->removeComposition(composition);
        updateModel();
 
        const int compositionCount = compositionView->model()->rowCount();
        if (compositionCount > 0) {
            if (index.row() == compositionCount) {
                compositionView->setCurrentIndex(index.siblingAtRow(compositionCount-1));
            } else {
                compositionView->setCurrentIndex(index);
            }
        }
    }
}

References CompositionModel::compositionFromIndex(), m_canvas, m_model, and updateModel().

eventFilter()

bool CompositionDockerDock::eventFilter ( QObject * obj, QEvent * event )

overrideprotected

Definition at line 402 of file compositiondocker_dock.cpp.

{
    if (event->type() == QEvent::KeyPress ) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Up || keyEvent->key() == Qt::Key_Down) {
            // new index will be set after the method is called
            QTimer::singleShot(0, this, SLOT(activateCurrentIndex()));
        }
        return false;
    } else {
        return QObject::eventFilter(obj, event);
    }
}

References activateCurrentIndex().

exportAnimationClicked

void CompositionDockerDock::exportAnimationClicked ( )

privateslot

Definition at line 334 of file compositiondocker_dock.cpp.

{
    KisConfig cfg(true);
    KisPropertiesConfigurationSP settings = cfg.exportConfiguration("ANIMATION_EXPORT");
    KisAnimationRenderingOptions exportOptions;
    exportOptions.fromProperties(settings);
 
    if (m_canvas &&
        m_canvas->viewManager() &&
        m_canvas->viewManager()->image() &&
        m_canvas->viewManager()->image()->animationInterface() &&
        m_canvas->viewManager()->document()) {
 
        QString path;
 
        KoFileDialog dialog(0, KoFileDialog::OpenDirectory, "compositiondockerdock");
        dialog.setCaption(i18n("Select a Directory"));
        dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
        path = dialog.filename();
 
        if (path.isNull()) return;
 
        if (!path.endsWith('/')) {
            path.append('/');
        }
 
        KisImageSP image = m_canvas->viewManager()->image();
        QString filename = m_canvas->viewManager()->document()->localFilePath();
        if (!filename.isEmpty()) {
            QFileInfo info(filename);
            path += info.completeBaseName();
        }
 
        KisLayerCompositionSP currentComposition = toQShared(new KisLayerComposition(image, "temp"));
        currentComposition->store();
 
        const QString videoExtension = KisMimeDatabase::suffixesForMimeType(exportOptions.videoMimeType).first();
 
        Q_FOREACH (KisLayerCompositionSP composition, image->compositions()) {
            if(!composition->isExportEnabled())
                continue;
 
            composition->apply();
            image->refreshGraphAsync();
            image->waitForDone();
 
            KisTimeSpan range = image->animationInterface()->documentPlaybackRange();
 
            exportOptions.firstFrame = range.start();
            exportOptions.lastFrame = range.end();
            exportOptions.width = image->width();
            exportOptions.height = image->height();
            exportOptions.basename = QString("frame");
            exportOptions.videoFileName = QString("%1/%2/video.%3").arg(path, composition->name(), videoExtension);
            exportOptions.directory = QString("%1/%2").arg(path, composition->name());
            exportOptions.wantsOnlyUniqueFrameSequence = true;
 
            bool success = KisAnimationRender::render(m_canvas->viewManager()->document(), m_canvas->viewManager(), exportOptions);
 
            if (!success) break;
        }
 
        currentComposition->apply();
        image->refreshGraphAsync();
        image->waitForDone();
    }
}

References KisImage::animationInterface(), KisAnimationRenderingOptions::basename, KisImage::compositions(), KisAnimationRenderingOptions::directory, KisImageAnimationInterface::documentPlaybackRange(), KisTimeSpan::end(), KisConfig::exportConfiguration(), KisAnimationRenderingOptions::firstFrame, KisAnimationRenderingOptions::fromProperties(), KisImage::height(), KisAnimationRenderingOptions::height, KisAnimationRenderingOptions::lastFrame, m_canvas, KoFileDialog::OpenDirectory, KisImage::refreshGraphAsync(), KisAnimationRender::render(), KisTimeSpan::start(), KisMimeDatabase::suffixesForMimeType(), toQShared(), KisAnimationRenderingOptions::videoFileName, KisAnimationRenderingOptions::videoMimeType, KisImage::waitForDone(), KisAnimationRenderingOptions::wantsOnlyUniqueFrameSequence, KisImage::width(), and KisAnimationRenderingOptions::width.

exportImageClicked

void CompositionDockerDock::exportImageClicked ( )

privateslot

Definition at line 241 of file compositiondocker_dock.cpp.

{
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image()) {
        QString path;
 
        KoFileDialog dialog(0, KoFileDialog::OpenDirectory, "compositiondockerdock");
        dialog.setCaption(i18n("Select a Directory"));
        dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
        path = dialog.filename();
 
        if (path.isNull()) return;
 
        if (!path.endsWith('/')) {
            path.append('/');
        }
 
        KisImageSP image = m_canvas->viewManager()->image();
        QString filename = m_canvas->viewManager()->document()->localFilePath();
        if (!filename.isEmpty()) {
            QFileInfo info(filename);
            path += info.completeBaseName() + '_';
        }
 
        KisLayerCompositionSP currentComposition = toQShared(new KisLayerComposition(image, "temp"));
        currentComposition->store();
 
        const QString exportWindowTitle = i18n("Exporting Compositions...");
        QSharedPointer<QProgressDialog> m_progressBar(new QProgressDialog(exportWindowTitle, i18n("Cancel"), 0, 0, this));
        const int compositionCount = image->compositions().size();
        m_progressBar->setCancelButton(0); //  TODO: This task should be threaded in the future so that canceling is possible,
                                           // Additionally, we should also be copying the image and working off that copy to
                                           // improve runtime performance and allow for the current krita instance to work
                                           // without locking up. **For now, we will simply make this operation uncancelable.**
        m_progressBar->setMaximum(compositionCount);
        m_progressBar->setMinimum(0);
        m_progressBar->setValue(0);
        int compositionsExported = 0;
 
        Q_FOREACH (KisLayerCompositionSP composition, image->compositions()) {
            if (m_progressBar->wasCanceled()) {
                break;
            }
 
            if (!composition->isExportEnabled()) {
                compositionsExported++;
                continue;
            }
 
            if (m_progressBar->isHidden()) {
                m_progressBar->show();
            }
 
            m_progressBar->setLabelText(i18n("Exporting composition: %1...", composition->name()));
 
            // TODO: Extension of above, but this algorithm is highly inefficient.
            // We should simply a) Deep Copy Image, b) Apply Composition, c) RefreshImageGraph,
            // d) Export Image.
            // This task can then be threaded to work in parallel.
            composition->apply();
            image->refreshGraphAsync();
            image->waitForDone();
 
            QRect r = image->bounds();
 
            KisDocument *d = KisPart::instance()->createDocument();
 
            KisImageSP dst = new KisImage(d->createUndoStore(), r.width(), r.height(), image->colorSpace(), composition->name());
            dst->setResolution(image->xRes(), image->yRes());
            d->setCurrentImage(dst);
            KisPaintLayer* paintLayer = new KisPaintLayer(dst, "projection", OPACITY_OPAQUE_U8);
            KisPainter gc(paintLayer->paintDevice());
            gc.bitBlt(QPoint(0, 0), image->rootLayer()->projection(), r);
            dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
            dst->refreshGraphAsync();
            dst->waitForDone();
 
            d->setFileBatchMode(true);
 
            d->exportDocumentSync(path + composition->name() + ".png", "image/png");
            compositionsExported++;
            m_progressBar->setValue(compositionsExported);
            d->deleteLater();
        }
 
        currentComposition->apply();
 
        image->refreshGraphAsync();
        image->waitForDone();
    }
 
}

References KisNodeFacade::addNode(), KisPainter::bitBlt(), KisImage::bounds(), KisImage::colorSpace(), KisImage::compositions(), KisPart::createDocument(), KoCanvasObserverBase::d, KisPart::instance(), m_canvas, OPACITY_OPAQUE_U8, KoFileDialog::OpenDirectory, KisPaintLayer::paintDevice, KisLayer::projection(), KisImage::refreshGraphAsync(), KisImage::rootLayer(), KisImage::setResolution(), toQShared(), KisImage::waitForDone(), KisImage::xRes(), and KisImage::yRes().

moveCompositionDown

void CompositionDockerDock::moveCompositionDown ( )

privateslot

Definition at line 223 of file compositiondocker_dock.cpp.

{
    QModelIndex index = compositionView->currentIndex();
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
        KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
        m_canvas->viewManager()->image()->moveCompositionDown(composition);
        updateModel();
        compositionView->setCurrentIndex(m_model->index(m_canvas->viewManager()->image()->compositions().indexOf(composition),0));
    }
}

References CompositionModel::compositionFromIndex(), m_canvas, m_model, and updateModel().

moveCompositionUp

void CompositionDockerDock::moveCompositionUp ( )

privateslot

Definition at line 212 of file compositiondocker_dock.cpp.

{
    QModelIndex index = compositionView->currentIndex();
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
        KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
        m_canvas->viewManager()->image()->moveCompositionUp(composition);
        updateModel();
        compositionView->setCurrentIndex(m_model->index(m_canvas->viewManager()->image()->compositions().indexOf(composition),0));
    }
}

References CompositionModel::compositionFromIndex(), m_canvas, m_model, and updateModel().

observerName()

QString CompositionDockerDock::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 29 of file compositiondocker_dock.h.

{ return "CompositionDockerDock"; }

renameComposition

void CompositionDockerDock::renameComposition ( )

privateslot

Definition at line 446 of file compositiondocker_dock.cpp.

{
    dbgKrita << "rename";
    QModelIndex index = compositionView->currentIndex();
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
        KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
        bool ok;
        QString name = QInputDialog::getText(this, i18n("Rename Composition"),
                                             i18n("New Name:"), QLineEdit::Normal,
                                             composition->name(), &ok);
        if (ok && !name.isEmpty()) {
            composition->setName(name);
            m_canvas->image()->setModifiedWithoutUndo();
        }
    }
}

References CompositionModel::compositionFromIndex(), dbgKrita, m_canvas, and m_model.

saveClicked

void CompositionDockerDock::saveClicked ( )

privateslot

Definition at line 181 of file compositiondocker_dock.cpp.

{
    KisImageWSP image = m_canvas->viewManager()->image();
    if (!image) return;
 
    // format as 001, 002 ...
    QString name = saveNameEdit->text();
    if (name.isEmpty()) {
        bool found = false;
        int i = 1;
        do {
            name = QString("%1").arg(i, 3, 10, QChar('0'));
            found = false;
            Q_FOREACH (KisLayerCompositionSP composition, m_canvas->viewManager()->image()->compositions()) {
                if (composition->name() == name) {
                    found = true;
                    break;
                }
            }
            i++;
        } while(found && i < 1000);
    }
    KisLayerCompositionSP composition(new KisLayerComposition(image, name));
    composition->store();
    image->addComposition(composition);
    saveNameEdit->clear();
    updateModel();
    compositionView->setCurrentIndex(m_model->index(image->compositions().count()-1, 0));
    image->setModifiedWithoutUndo();
}

References KisImage::addComposition(), KisImage::compositions(), m_canvas, m_model, KisImage::setModifiedWithoutUndo(), and updateModel().

setCanvas()

void CompositionDockerDock::setCanvas ( KoCanvasBase * canvas )

overridevirtual

re-implement this method in your canvas observer. It will be called whenever a canvas becomes active. Note that you are responsible for not connecting more than one time to the signals of a canvas or any of the QObjects you can access through the canvas.

Implements KoCanvasObserverBase.

Definition at line 118 of file compositiondocker_dock.cpp.

{
    if (m_canvas && m_canvas->viewManager()) {
        Q_FOREACH (KisAction *action, m_actions) {
            m_canvas->viewManager()->actionManager()->takeAction(action);
        }
    }
 
    unsetCanvas();
    setEnabled(canvas != 0);
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
    if (m_canvas && m_canvas->viewManager()) {
        if (m_actions.isEmpty()) {
            KisAction *updateAction = m_canvas->viewManager()->actionManager()->createAction("update_composition");
            connect(updateAction, SIGNAL(triggered()), this, SLOT(updateComposition()));
            m_actions.append(updateAction);
 
            KisAction *renameAction = m_canvas->viewManager()->actionManager()->createAction("rename_composition");
            connect(renameAction, SIGNAL(triggered()), this, SLOT(renameComposition()));
            m_actions.append(renameAction);
 
        } else {
            Q_FOREACH (KisAction *action, m_actions) {
                m_canvas->viewManager()->actionManager()->addAction(action->objectName(), action);
            }
        }
        updateModel();
    }
}

References connect(), m_actions, m_canvas, renameComposition(), unsetCanvas(), updateComposition(), and updateModel().

slotScrollerStateChanged

void CompositionDockerDock::slotScrollerStateChanged ( QScroller::State state )

inlineslot

Definition at line 38 of file compositiondocker_dock.h.

{ KisKineticScroller::updateCursor(this, state); }

References KisKineticScroller::updateCursor().

unsetCanvas()

void CompositionDockerDock::unsetCanvas ( )

overridevirtual

Re-implement to notify the observer that its canvas is no longer among the living. The daisies, it is pushing up. This means you don't have to disconnect, it's dead.

The old canvas should be deleted already, so if you stored a pointer to it, don't touch!

Note that currently there is a bug where in certain specific circumstances unsetCanvas can be called when it shouldn't, see for example KWStatisticsDocker for a workaround for this problem.

Implements KoCanvasObserverBase.

Definition at line 149 of file compositiondocker_dock.cpp.

{
    setEnabled(false);
    m_canvas = 0;
    m_model->setCompositions(QList<KisLayerCompositionSP>());
}

References m_canvas, m_model, and CompositionModel::setCompositions().

updateComposition

void CompositionDockerDock::updateComposition ( )

privateslot

Definition at line 436 of file compositiondocker_dock.cpp.

{
    QModelIndex index = compositionView->currentIndex();
    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
        KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
        composition->store();
        m_canvas->image()->setModifiedWithoutUndo();
    }
}

References CompositionModel::compositionFromIndex(), m_canvas, and m_model.

updateModel()

void CompositionDockerDock::updateModel

(

)

Definition at line 234 of file compositiondocker_dock.cpp.

{
    if (m_model && m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image()) {
        m_model->setCompositions(m_canvas->viewManager()->image()->compositions());
    }
}

References m_canvas, m_model, and CompositionModel::setCompositions().

Member Data Documentation

m_actions

QVector<KisAction*> CompositionDockerDock::m_actions

private

Definition at line 57 of file compositiondocker_dock.h.

m_canvas

QPointer<KisCanvas2> CompositionDockerDock::m_canvas

private

Definition at line 54 of file compositiondocker_dock.h.

m_model

CompositionModel* CompositionDockerDock::m_model

private

Definition at line 55 of file compositiondocker_dock.h.

---

The documentation for this class was generated from the following files:

• plugins/dockers/compositiondocker/compositiondocker_dock.h
• plugins/dockers/compositiondocker/compositiondocker_dock.cpp