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 56 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(), KisKineticScroller::createPreconfiguredScroller(), customContextMenuRequested(), deleteClicked(), exportAnimationClicked(), exportImageClicked(), KisIconUtils::loadIcon(), m_model, moveCompositionDown(), moveCompositionUp(), saveClicked(), and slotScrollerStateChanged().

~CompositionDockerDock()

CompositionDockerDock::~CompositionDockerDock ( )

override

Definition at line 117 of file compositiondocker_dock.cpp.

{
 
}

Member Function Documentation

activateCurrentIndex

void CompositionDockerDock::activateCurrentIndex ( )

privateslot

Definition at line 439 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 160 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 447 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 166 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 425 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 338 of file compositiondocker_dock.cpp.

{
    KisConfig cfg(true);
    KisPropertiesConfigurationSP settings = cfg.exportConfiguration("ANIMATION_EXPORT");
    KisAnimationRenderingOptions exportOptions;
    exportOptions.fromProperties(settings);
 
#ifdef Q_OS_ANDROID
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(exportOptions.videoFormatKey);
    // If there's no format configured, try to grab the first available one.
    if (!format) {
        const QVector<KisMediaEncoderFormat *> &supportedFormats = KisMediaEncoderWrapper::getSupportedFormats();
        if (!supportedFormats.isEmpty()) {
            format = supportedFormats.first();
        }
    }
    // If there's still none, bail out.
    if (!format) {
        return;
    }
#endif
 
    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();
 
#ifdef Q_OS_ANDROID
        const QString videoExtension = format->extension();
#else
        const QString videoExtension = KisMimeDatabase::suffixesForMimeType(exportOptions.videoMimeType).first();
#endif
 
        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(), KisMediaEncoderFormat::extension(), KisAnimationRenderingOptions::firstFrame, KisAnimationRenderingOptions::fromProperties(), KisMediaEncoderWrapper::getFormatByKey(), KisMediaEncoderWrapper::getSupportedFormats(), 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 245 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 227 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 216 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 469 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 185 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 122 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 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 153 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 459 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 238 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