StoryboardDockerDock Class Reference

#include <StoryboardDockerDock.h>

Inheritance diagram for StoryboardDockerDock:

Classes
struct	ExportPage
struct	ExportPageShot

Public Member Functions
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
void	setViewManager (KisViewManager *kisview) override
	StoryboardDockerDock ()
void	unsetCanvas () override
	~StoryboardDockerDock () override
Public Member Functions inherited from KisMainwindowObserver
	KisMainwindowObserver ()
	~KisMainwindowObserver () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Private Slots
void	notifyImageDeleted ()
	sets the image in Model to nullptr if there is no canvas set or no KisImage
void	slotExport (ExportFormat format)
	Creates the DlgExportStoryboard and performs the actual export.
void	slotExportAsPdf ()
	calls slotExport(ExportFormat) with PDF parameter.
void	slotExportAsSvg ()
	calls slotExport(ExportFormat) with SVG parameter.
void	slotLockClicked (bool)
	called when lock toggle button is clicked.
void	slotModeChanged (QAbstractButton *)
	called when a mode option is selected in Arrange menu.
void	slotModelChanged ()
	called to reflect changes to the model.
void	slotUpdateCommentModelList ()
	sets the CommentModel's comment list to be the same as KisDocument's storyboardCommentList
void	slotUpdateDocumentList ()
	sets the KisDocument's storyboardItemList to be the same as StoryboardModel's storyboardItemList and KisDocument's storyboardCommentList to be the same as CommentModel's commentList
void	slotUpdateMinimumWidth ()
	called to update minimum width on reaction to model changes. Should change based on available content.
void	slotUpdateStoryboardModelList ()
	sets the StoryboardModel's storyboardItemList to be the same as KisDocument's storyboardItemList
void	slotViewChanged (QAbstractButton *)
	called when a view option is selected in Arrange menu.

Private Member Functions
QString	buildDurationString (int seconds, int frames)
ExportPage	getPageLayout (int rows, int columns, const QRect &imageSize, const QRect &pageRect, const QFontMetrics &painter)
ExportPage	getPageLayout (QString layoutSvgFileName, QPrinter *printer)

Private Attributes
ArrangeMenu *	m_arrangeMenu
KisCanvas2 *	m_canvas
CommentMenu *	m_commentMenu
QPointer< StoryboardCommentModel >	m_commentModel
KisAction *	m_exportAsPdfAction
KisAction *	m_exportAsSvgAction
QMenu *	m_exportMenu
KisAction *	m_lockAction
QButtonGroup *	m_modeGroup
KisNodeManager *	m_nodeManager
QPointer< StoryboardDelegate >	m_storyboardDelegate
QSharedPointer< StoryboardModel >	m_storyboardModel
QScopedPointer< Ui_WdgStoryboardDock >	m_ui
QButtonGroup *	m_viewGroup

Additional Inherited Members

Detailed Description

Definition at line 31 of file StoryboardDockerDock.h.

Constructor & Destructor Documentation

StoryboardDockerDock()

StoryboardDockerDock::StoryboardDockerDock

(

)

Definition at line 170 of file StoryboardDockerDock.cpp.

    : QDockWidget(i18nc("Storyboard Docker", "Storyboard"))
    , m_canvas(0)
    , m_ui(new Ui_WdgStoryboardDock())
    , m_exportMenu(new QMenu(this))
    , m_commentModel(new StoryboardCommentModel(this))
    , m_commentMenu(new CommentMenu(this, m_commentModel))
    , m_arrangeMenu(new ArrangeMenu(this))
    , m_storyboardModel(new StoryboardModel(this))
    , m_storyboardDelegate(new StoryboardDelegate(this))
{
    QWidget* mainWidget = new QWidget(this);
    setWidget(mainWidget);
    m_ui->setupUi(mainWidget);
 
    m_ui->btnExport->setMenu(m_exportMenu);
    m_ui->btnExport->setPopupMode(QToolButton::InstantPopup);
 
    m_exportAsPdfAction = new KisAction(i18nc("Export storyboard as PDF", "Export as PDF"), m_exportMenu);
    m_exportMenu->addAction(m_exportAsPdfAction);
 
    m_exportAsSvgAction = new KisAction(i18nc("Export storyboard as SVG", "Export as SVG"), m_exportMenu);
    m_exportMenu->addAction(m_exportAsSvgAction);
    connect(m_exportAsPdfAction, SIGNAL(triggered()), this, SLOT(slotExportAsPdf()));
    connect(m_exportAsSvgAction, SIGNAL(triggered()), this, SLOT(slotExportAsSvg()));
 
    //Setup dynamic QListView Width Based on Comment Model Columns...
    connect(m_commentModel, &StoryboardCommentModel::sigCommentListChanged, this, &StoryboardDockerDock::slotUpdateMinimumWidth);
    connect(m_storyboardModel.data(), &StoryboardModel::rowsInserted, this, &StoryboardDockerDock::slotUpdateMinimumWidth);
 
    connect(m_storyboardModel.data(), &StoryboardModel::rowsInserted, this, &StoryboardDockerDock::slotModelChanged);
    connect(m_storyboardModel.data(), &StoryboardModel::rowsRemoved, this, &StoryboardDockerDock::slotModelChanged);
 
    m_ui->btnComment->setMenu(m_commentMenu);
    m_ui->btnComment->setPopupMode(QToolButton::InstantPopup);
 
    m_lockAction = new KisAction(KisIconUtils::loadIcon("unlocked"),
                                i18nc("Freeze keyframe positions and ignore storyboard adjustments", "Freeze Keyframe Data"), m_ui->btnLock);
    m_lockAction->setCheckable(true);
    m_ui->btnLock->setDefaultAction(m_lockAction);
    m_ui->btnLock->setIconSize(QSize(16, 16));
    connect(m_lockAction, SIGNAL(toggled(bool)), this, SLOT(slotLockClicked(bool)));
 
    m_ui->btnArrange->setMenu(m_arrangeMenu);
    m_ui->btnArrange->setPopupMode(QToolButton::InstantPopup);
    m_ui->btnArrange->setIcon(KisIconUtils::loadIcon("view-choose"));
    m_ui->btnArrange->setAutoRaise(true);
    m_ui->btnArrange->setIconSize(QSize(16, 16));
 
    m_modeGroup = m_arrangeMenu->getModeGroup();
    m_viewGroup = m_arrangeMenu->getViewGroup();
 
    connect(m_modeGroup, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(slotModeChanged(QAbstractButton*)));
    connect(m_viewGroup, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(slotViewChanged(QAbstractButton*)));
 
    m_storyboardDelegate->setView(m_ui->sceneView);
    m_storyboardModel->setView(m_ui->sceneView);
    m_ui->sceneView->setModel(m_storyboardModel.data());
    m_ui->sceneView->setItemDelegate(m_storyboardDelegate);
 
    m_storyboardModel->setCommentModel(m_commentModel);
 
    m_modeGroup->button(Mode::Row)->click();
    m_viewGroup->button(View::All)->click();
 
    {   // Footer section...
        QAction* action = new QAction(i18nc("Add new scene as the last storyboard", "Add Scene"), this);
        connect(action, &QAction::triggered, this, [this](bool){
            if (!m_canvas) return;
 
            QModelIndex currentSelection = m_ui->sceneView->currentIndex();
            if (currentSelection.parent().isValid()) {
                currentSelection = currentSelection.parent();
            }
 
            m_storyboardModel->insertItem(currentSelection, true);
        });
        action->setIcon(KisIconUtils::loadIcon("list-add"));
        m_ui->btnCreateScene->setAutoRaise(true);
        m_ui->btnCreateScene->setIconSize(QSize(22,22));
        m_ui->btnCreateScene->setDefaultAction(action);
 
        action = new QAction(i18nc("Remove current scene from storyboards", "Remove Scene"), this);
        connect(action, &QAction::triggered, this, [this](bool){
            if (!m_canvas) return;
 
            QModelIndex currentSelection = m_ui->sceneView->currentIndex();
            if (currentSelection.parent().isValid()) {
                currentSelection = currentSelection.parent();
            }
 
            if (currentSelection.isValid()) {
                int row = currentSelection.row();
                KisRemoveStoryboardCommand *command = new KisRemoveStoryboardCommand(row, m_storyboardModel->getData().at(row), m_storyboardModel.data());
 
                m_storyboardModel->removeItem(currentSelection, command);
                m_storyboardModel->pushUndoCommand(command);
            }
        });
        action->setIcon(KisIconUtils::loadIcon("edit-delete"));
        m_ui->btnDeleteScene->setAutoRaise(true);
        m_ui->btnDeleteScene->setIconSize(QSize(22,22));
        m_ui->btnDeleteScene->setDefaultAction(action);
    }
 
    setEnabled(false);
}

References connect(), ArrangeMenu::getModeGroup(), ArrangeMenu::getViewGroup(), KisIconUtils::loadIcon(), m_arrangeMenu, m_canvas, m_commentMenu, m_commentModel, m_exportAsPdfAction, m_exportAsSvgAction, m_exportMenu, m_lockAction, m_modeGroup, m_storyboardDelegate, m_storyboardModel, m_ui, m_viewGroup, Row, StoryboardCommentModel::sigCommentListChanged(), slotExportAsPdf(), slotExportAsSvg(), slotLockClicked(), slotModeChanged(), slotModelChanged(), slotUpdateMinimumWidth(), and slotViewChanged().

~StoryboardDockerDock()

StoryboardDockerDock::~StoryboardDockerDock ( )

override

Definition at line 278 of file StoryboardDockerDock.cpp.

{
    delete m_commentModel;
    m_storyboardModel.reset();
    delete m_storyboardDelegate;
}

References m_commentModel, m_storyboardDelegate, and m_storyboardModel.

Member Function Documentation

buildDurationString()

QString StoryboardDockerDock::buildDurationString ( int seconds, int frames )

private

Definition at line 916 of file StoryboardDockerDock.cpp.

{
    QString durationString = QString::number(seconds);
    durationString += i18nc("suffix in spin box in storyboard that means 'seconds'", "s");
    durationString += "+";
    durationString += QString::number(frames);
    durationString += i18nc("suffix in spin box in storyboard that means 'frames'", "f");
    return durationString;
}

getPageLayout() [1/2]

StoryboardDockerDock::ExportPage StoryboardDockerDock::getPageLayout ( int rows, int columns, const QRect & imageSize, const QRect & pageRect, const QFontMetrics & painter )

private

Definition at line 721 of file StoryboardDockerDock.cpp.

{
    QSizeF pageSize = pageRect.size();
    QRectF border = pageRect;
    QSizeF cellSize(pageSize.width() / columns, pageSize.height() / rows);
    QVector<QRectF> rects;
 
    int numericFontWidth = fontMetrics.horizontalAdvance("0");
 
    for (int row = 0; row < rows; row++) {
 
        QRectF cellRect = border;
        cellRect.moveTop(border.top() + row * cellSize.height());
        cellRect.setSize(cellSize - QSize(200,200));
        for (int column = 0; column < columns; column++) {
            cellRect.moveLeft(border.left() + column * cellSize.width());
            cellRect.setSize(cellSize * 0.9);
            rects.push_back(cellRect);
        }
    }
 
    QVector<ExportPageShot> elements;
 
    for (int i = 0; i < rects.length(); i++) {
        QRectF& cellRect = rects[i];
 
        const bool horizontal = cellRect.width() > cellRect.height(); // Determine general image / text flow orientation.
        ExportPageShot layout;
 
        QVector<StoryboardComment> comments = m_commentModel->getData();
        const int numComments = comments.size();
 
        if (horizontal) {
            QRectF sourceRect = cellRect;
            layout.cutDurationRect = kisTrimTop(fontMetrics.height() * 1.5, sourceRect);
            layout.cutNameRect = kisTrimLeft(layout.cutDurationRect.value().width() - numericFontWidth * 6, layout.cutDurationRect.value());
 
            const int imageWidth = sourceRect.height() * static_cast<qreal>(imageSize.width()) / static_cast<qreal>(imageSize.height());
            layout.cutImageRect = kisTrimLeft(imageWidth, sourceRect);
            const float commentWidth = sourceRect.width() / numComments;
            if (commentWidth > 100) {
                for (int i = 0; i < numComments; i++) {
                    QRectF rect = kisTrimLeft(commentWidth, sourceRect);
                    layout.commentRects.insert(comments[i].name, rect);
                }
            }
        } else {
            QRectF sourceRect = cellRect;
            layout.cutDurationRect = kisTrimTop(fontMetrics.height() * 1.5, sourceRect);
            layout.cutNameRect = kisTrimLeft(layout.cutDurationRect.value().width() - numericFontWidth * 6, layout.cutDurationRect.value());
 
            const int imageHeight = sourceRect.width() * static_cast<qreal>(imageSize.height()) / static_cast<qreal>(imageSize.width());
            layout.cutImageRect = kisTrimTop(imageHeight, sourceRect);
            const float commentHeight = sourceRect.height() / numComments;
            if (commentHeight > 200) {
                for (int i = 0; i < numComments; i++) {
                    QRectF rect = kisTrimTop(commentHeight, sourceRect);
                    layout.commentRects.insert(comments[i].name, rect);
                }
            }
        }
 
        elements.push_back(layout);
    }
 
    ExportPage layout;
    layout.elements = elements;
    return layout;
}

References kisTrimLeft(), kisTrimTop(), and m_commentModel.

getPageLayout() [2/2]

StoryboardDockerDock::ExportPage StoryboardDockerDock::getPageLayout ( QString layoutSvgFileName, QPrinter * printer )

private

Definition at line 791 of file StoryboardDockerDock.cpp.

{
    QDomDocument svgDoc;
    ExportPage page;
    QVector<ExportPageShot> elements;
 
    // Load DOM from file...
    QFile f(layoutSvgFileName);
    if (!f.open(QIODevice::ReadOnly ))
    {
        qDebug()<<"svg layout file didn't open";
        return page;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(svgDoc.setContent(&f), page);
    f.close();
 
    QDomElement eroot = svgDoc.documentElement();
 
    QStringList lst = eroot.attribute("viewBox").split(" ");
    QSizeF sizeMM(lst.at(2).toDouble(), lst.at(3).toDouble());
    printer->setPageSize(QPageSize(sizeMM, QPageSize::Millimeter));
    QSizeF size = printer->pageLayout().paintRectPixels(printer->resolution()).size();
    QSizeF scaling = QSizeF( size.width() / sizeMM.width(), size.height() / sizeMM.height());
 
    QVector<QString> commentLayers;
    Q_FOREACH( StoryboardComment channel, m_commentModel->getData()) {
        commentLayers.push_back(channel.name);
    }
 
    QMap<int, ExportPageShot> elementMap;
 
    { // Go through all root-level svg data and preconfigure...
        QMap<QString, QDomNode> groupsMap = rootItemsInSvg(svgDoc);
 
        KIS_ASSERT_RECOVER_RETURN_VALUE(groupsMap.contains("layout"), page);
 
        groupsMap["layout"].toElement().setAttribute("display", "none");
        if (groupsMap.contains("overlay")) {
            groupsMap["overlay"].toElement().setAttribute("display", "nonde");
        }
 
        QDomNodeList  nodeList = groupsMap["layout"].toElement().elementsByTagName("rect");
        for(int i = 0; i < nodeList.size(); i++) {
            QDomNode node = nodeList.at(i);
            QDomNamedNodeMap attrMap = node.attributes();
 
            for (int j = 0; j < attrMap.length(); j++) {
                QDomAttr attribute = attrMap.item(j).toAttr();
                QString afterNamespace = attribute.name().split(":").last();
 
                auto isValidLabel = [&](QString label, int& index) -> bool {
                    if (attribute.value().startsWith(label)) {
                        if (attribute.value() == label) {
                            index = 0;
                            return true;
                        }
 
                        QString indexString = attribute.value().remove(0, label.length());
                        bool ok = false;
                        index = indexString.toInt(&ok);
                        if (ok) {
                            if (!elementMap.contains(index))
                                elementMap.insert(index, ExportPageShot());
                            return true;
                        }
                    }
                    return false;
                };
 
                auto extractRect = [&](boost::optional<QRectF>& to) {
                    double x = scaling.width() * attrMap.namedItem("x").nodeValue().toDouble();
                    double y = scaling.height() * attrMap.namedItem("y").nodeValue().toDouble();
                    double width = scaling.width() * attrMap.namedItem("width").nodeValue().toDouble();
                    double height = scaling.height() * attrMap.namedItem("height").nodeValue().toDouble();
                    to = QRectF(x,y, width, height);
                };
 
                if (afterNamespace == "label") {
                    int index = 0;
                    if (isValidLabel("image", index)) {
                        extractRect(elementMap[index].cutImageRect);
                    } else if (isValidLabel("time",index)) {
                        extractRect(elementMap[index].cutDurationRect);
                    } else if (isValidLabel("name", index)) {
                        extractRect(elementMap[index].cutNameRect);
                    } else if (isValidLabel("shot", index)) {
                        extractRect(elementMap[index].cutNumberRect);
                    } else if (isValidLabel("page-time", index)) {
                        extractRect(page.pageTimeRect);
                    } else if (isValidLabel("page-number", index)) {
                        extractRect(page.pageNumberRect);
                    } else {
                        for(int commentIndex = 0; commentIndex < commentLayers.length(); commentIndex++) {
                            const QString& comment = commentLayers[commentIndex];
                            if (isValidLabel(comment.toLower(), index)) {
                                boost::optional<QRectF> rect;
                                extractRect(rect);
                                if (rect) {
                                    elementMap[index].commentRects.insert(comment, rect.value());
                                }
                            }
                        }
                    }
                }
            }
 
        }
    }
 
    // Sort fetched elements and push to array to return...
    QList<int> indices = elementMap.keys();
    std::sort(indices.begin(), indices.end(), [](const int& a, const int& b){
        return a < b;
    });
 
    Q_FOREACH(const int& index, indices){
        elements.push_back(elementMap[index]);
    }
 
    page.svg = svgDoc;
    page.elements = elements;
    return page;
}

References StoryboardDockerDock::ExportPage::elements, KIS_ASSERT_RECOVER_RETURN_VALUE, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_commentModel, StoryboardComment::name, StoryboardDockerDock::ExportPage::pageNumberRect, StoryboardDockerDock::ExportPage::pageTimeRect, rootItemsInSvg(), and StoryboardDockerDock::ExportPage::svg.

notifyImageDeleted

void StoryboardDockerDock::notifyImageDeleted ( )

privateslot

sets the image in Model to nullptr if there is no canvas set or no KisImage

Definition at line 344 of file StoryboardDockerDock.cpp.

{
    //if there is no image
    if (!m_canvas || !m_canvas->image()){
        m_storyboardModel->setImage(0);
    }
}

References KisCanvas2::image(), m_canvas, and m_storyboardModel.

observerName()

QString StoryboardDockerDock::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 36 of file StoryboardDockerDock.h.

{ return "StoryboardDockerDock"; }

setCanvas()

void StoryboardDockerDock::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 285 of file StoryboardDockerDock.cpp.

{
    if (m_canvas == canvas) {
        return;
    }
 
    if (m_canvas) {
        disconnect(m_storyboardModel.data(), SIGNAL(sigStoryboardItemListChanged()), this, SLOT(slotUpdateDocumentList()));
        disconnect(m_commentModel, SIGNAL(sigCommentListChanged()), this, SLOT(slotUpdateDocumentList()));
        disconnect(m_canvas->imageView()->document(), SIGNAL(sigStoryboardItemListChanged()), this, SLOT(slotUpdateStoryboardModelList()));
        disconnect(m_canvas->imageView()->document(), SIGNAL(sigStoryboardItemListChanged()), this, SLOT(slotUpdateCommentModelList()));
 
        //update the lists in KisDocument and empty storyboardModel's list and commentModel's list
        slotUpdateDocumentList();
        m_storyboardModel->resetData(StoryboardItemList());
        m_commentModel->resetData(QVector<StoryboardComment>());
        m_storyboardModel->slotSetActiveNode(nullptr);
    }
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
    setEnabled(m_canvas != 0);
 
    if (m_canvas && m_canvas->image()) {
        //sync data between KisDocument and models
        slotUpdateStoryboardModelList();
        slotUpdateCommentModelList();
 
        connect(m_storyboardModel.data(), SIGNAL(sigStoryboardItemListChanged()), SLOT(slotUpdateDocumentList()), Qt::UniqueConnection);
        connect(m_commentModel, SIGNAL(sigCommentListChanged()), SLOT(slotUpdateDocumentList()), Qt::UniqueConnection);
        connect(m_canvas->imageView()->document(), SIGNAL(sigStoryboardItemListChanged()), this, SLOT(slotUpdateStoryboardModelList()), Qt::UniqueConnection);
        connect(m_canvas->imageView()->document(), SIGNAL(sigStoryboardCommentListChanged()), this, SLOT(slotUpdateCommentModelList()), Qt::UniqueConnection);
 
        m_storyboardModel->setImage(m_canvas->image());
        m_storyboardDelegate->setImageSize(m_canvas->image()->size());
        connect(m_canvas->image(), SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()), Qt::UniqueConnection);
 
        if (m_nodeManager) {
            m_storyboardModel->slotSetActiveNode(m_nodeManager->activeNode());
        }
    }
 
    slotUpdateMinimumWidth();
    slotModelChanged();
}

References KisNodeManager::activeNode(), connect(), KisCanvas2::image(), KisCanvas2::imageView(), m_canvas, m_commentModel, m_nodeManager, m_storyboardDelegate, m_storyboardModel, notifyImageDeleted(), KisImage::size(), slotModelChanged(), slotUpdateCommentModelList(), slotUpdateDocumentList(), slotUpdateMinimumWidth(), and slotUpdateStoryboardModelList().

setViewManager()

void StoryboardDockerDock::setViewManager ( KisViewManager * kisview )

overridevirtual

Implements KisMainwindowObserver.

Definition at line 335 of file StoryboardDockerDock.cpp.

{
    m_nodeManager = kisview->nodeManager();
    if (m_nodeManager) {
        connect(m_nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), m_storyboardModel.data(), SLOT(slotSetActiveNode(KisNodeSP)));
    }
}

References connect(), m_nodeManager, m_storyboardModel, and KisViewManager::nodeManager().

slotExport

void StoryboardDockerDock::slotExport ( ExportFormat format )

privateslot

Creates the DlgExportStoryboard and performs the actual export.

See also

DlgExportStoryboard

Definition at line 378 of file StoryboardDockerDock.cpp.

{
    QFileInfo fileInfo(m_canvas->imageView()->document()->path());
    const QString imageFileName = fileInfo.baseName();
    const int storyboardCount = m_storyboardModel->rowCount();
    KIS_SAFE_ASSERT_RECOVER_RETURN(storyboardCount > 0);
    DlgExportStoryboard dlg(format, m_storyboardModel);
 
    if (dlg.exec() == QDialog::Accepted) {
        dlg.hide();
        KisCursorOverrideLock cursorLock(Qt::WaitCursor);
 
        ExportPage layoutPage;
        QPrinter printer(QPrinter::HighResolution);
 
        // Setup export parameters...
        QPainter painter;
        QSvgGenerator generator;
 
        QFont font = painter.font();
        font.setPointSize(dlg.fontSize());
 
        StoryboardItemList storyboardList = m_storyboardModel->getData();
 
        // Setup per-element layout details...
        bool layoutSpecifiedBySvg = dlg.layoutSpecifiedBySvgFile();
        if (layoutSpecifiedBySvg) {
            QString svgFileName = dlg.layoutSvgFile();
            layoutPage = getPageLayout(svgFileName, &printer);
        }
        else {
            int rows = dlg.rows();
            int columns = dlg.columns();
            printer.setOutputFileName(dlg.saveFileName());
            printer.setPageSize(dlg.pageSize());
            printer.setPageOrientation(dlg.pageOrientation());
            painter.begin(&printer); // We need to begin the painter temporarily for font metrics.
            painter.setFont(font);
            layoutPage = getPageLayout(rows,
                                       columns,
                                       QRect(0, 0, m_canvas->image()->width(), m_canvas->image()->height()),
                                       printer.pageLayout().paintRectPixels(printer.resolution()),
                                       painter.fontMetrics());
            painter.end(); // End temporary painter begin.
        }
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(layoutPage.elements.length() > 0);
 
        // Get a range of items to render. Used to be configurable in an older version but now simplified...
        QModelIndex firstIndex = m_storyboardModel->index(0,0);
        QModelIndex lastIndex  = m_storyboardModel->index(m_storyboardModel->rowCount() - 1, 0);
 
        if (!firstIndex.isValid() || !lastIndex.isValid()) {
            QMessageBox::warning((QWidget*)(&dlg), i18nc("@title:window", "Krita"), i18n("Please enter correct range. There are no panels in the range of frames provided."));
            return;
        }
 
        int firstItemRow = firstIndex.row();
        int lastItemRow = lastIndex.row();
 
        int numBoards = lastItemRow - firstItemRow + 1;
        if (numBoards <= 0) {
            QMessageBox::warning((QWidget*)(&dlg), i18nc("@title:window", "Krita"), i18n("Please enter correct range. There are no panels in the range of frames provided."));
            return;
        }
 
        if (dlg.format() == ExportFormat::SVG) {
            generator.setFileName(dlg.saveFileName() + "/" + imageFileName + "0.svg");
            QSize sz = printer.pageLayout().paintRectPixels(printer.resolution()).size();
            generator.setSize(sz);
            generator.setViewBox(QRect(0, 0, sz.width(), sz.height()));
            generator.setResolution(printer.resolution());
            painter.begin(&generator);
            painter.setBrush(QBrush(QColor(255,255,255)));
            painter.drawRect(QRect(0,0, sz.width(), sz.height()));
        }
        else {
            printer.setOutputFileName(dlg.saveFileName());
            printer.setOutputFormat(QPrinter::PdfFormat);
            painter.begin(&printer);
            painter.setFont(font);
            painter.setBackgroundMode(Qt::BGMode::OpaqueMode);
        }
 
        // Paint boards
        int pageNumber = 1;
        int pageDurationInFrames = 0;
 
        for (int currentBoard = 0; currentBoard < numBoards; currentBoard++) {
            if (currentBoard % layoutPage.elements.length() == 0) {
                if (dlg.format() == ExportFormat::SVG) {
                    if (currentBoard != 0) {
                        painter.end();
                        painter.eraseRect(printer.pageLayout().paintRectPixels(printer.resolution()));
                        generator.setFileName(dlg.saveFileName() + "/" + imageFileName + QString::number(currentBoard / layoutPage.elements.length()) + ".svg");
                        QSize sz = printer.pageLayout().paintRectPixels(printer.resolution()).size();
                        generator.setSize(sz);
                        generator.setViewBox(QRect(0, 0, sz.width(), sz.height()));
                        generator.setResolution(printer.resolution());
                        painter.begin(&generator);
                    }
                }
                else {
                    if (currentBoard != 0 ) { // New page!
                        printer.newPage();
 
                        pageNumber++;
                        pageDurationInFrames = 0;
                    }
 
                    if(layoutPage.svg) {
                        QMap<QString, QDomNode> groups = rootItemsInSvg(layoutPage.svg.value());
                        if (groups.contains("overlay")) {
                            QMapIterator<QString, QDomNode> iter(groups);
                            while(iter.hasNext()) {
                                iter.next();
                                if (iter.key() == "overlay" || iter.key() == "layout") {
                                    iter.value().toElement().setAttribute("display","none");
                                } else {
                                    iter.value().toElement().setAttribute("display","inline");
                                }
                            }
                        }
                        QSvgRenderer renderer(layoutPage.svg->toByteArray());
                        renderer.render(&painter);
                    }
                }
            }
 
            ThumbnailData data = qvariant_cast<ThumbnailData>(storyboardList.at(currentBoard + firstItemRow)->child(StoryboardItem::FrameNumber)->data());
            QPixmap pxmp = qvariant_cast<QPixmap>(data.pixmap);
            QVector<StoryboardComment> comments = m_commentModel->getData();
            const int numComments = comments.size();
 
            const ExportPageShot* const layoutShot = &layoutPage.elements[currentBoard % layoutPage.elements.length()];
 
            QPen pen(QColor(1, 0, 0));
            pen.setWidth(5);
            painter.setPen(pen);
 
            // Draw image
            if (layoutShot->cutImageRect.has_value()) {
                QRectF imgRect = layoutShot->cutImageRect.value();
                QSizeF resizedImage = QSizeF(pxmp.size()).scaled(layoutShot->cutImageRect->size(), Qt::KeepAspectRatio);
                const int MARGIN = -2;
                resizedImage = QSize(resizedImage.width() + MARGIN * 2, resizedImage.height() + MARGIN * 2);
                imgRect.setSize(resizedImage);
                imgRect.translate((layoutShot->cutImageRect.value().width() - imgRect.size().width()) / 2 - MARGIN,
                                  (layoutShot->cutImageRect->height() - imgRect.size().height()) / 2 - MARGIN);
                painter.drawPixmap(imgRect, pxmp, pxmp.rect());
                painter.drawRect(layoutShot->cutImageRect.value());
            }
 
            { // Insert shot text elements...
                painter.save();
                painter.setBackgroundMode(Qt::TransparentMode);
 
                // Draw shot name
                if (layoutShot->cutNameRect.has_value()) {
                    QString str = storyboardList.at(currentBoard + firstItemRow)->child(StoryboardItem::ItemName)->data().toString();
                    painter.drawText(layoutShot->cutNameRect.value().translated(painter.fontMetrics().averageCharWidth() / 2, 0), Qt::AlignLeft | Qt::AlignVCenter, str);
 
                    if (!layoutPage.svg) {
                        painter.drawRect(layoutShot->cutNameRect.value());
                    }
                }
 
                // Draw shot number
                if (layoutShot->cutNumberRect.has_value()) {
                    painter.drawText(layoutShot->cutNumberRect.value(), Qt::AlignCenter, QString::number(currentBoard + firstItemRow));
 
                    if (!layoutPage.svg) {
                        painter.drawRect(layoutShot->cutNumberRect.value());
                    }
                }
 
                QModelIndex boardIndex = m_storyboardModel->index(currentBoard + firstItemRow, 0);
 
                const int boardDurationFrames = m_storyboardModel->data(boardIndex, StoryboardModel::TotalSceneDurationInFrames).toInt();
                pageDurationInFrames += boardDurationFrames;
 
                // Draw shot duration
                if (layoutShot->cutDurationRect.has_value()) {
                    // Split shot duration into tuple of seconds + frames (remainder)..
                    int durationSecondsPart = boardDurationFrames / m_storyboardModel->getFramesPerSecond();
                    int durationFramesPart = boardDurationFrames % m_storyboardModel->getFramesPerSecond();
 
                    painter.drawText(layoutShot->cutDurationRect.value(), Qt::AlignCenter,
                                     buildDurationString(durationSecondsPart, durationFramesPart));
 
                    if (!layoutPage.svg) {
                        painter.drawRect(layoutShot->cutDurationRect.value());
                    }
                }
 
                painter.restore();
            }
 
 
            // Draw shot comments
            for (int commentIndex = 0; commentIndex < numComments; commentIndex++) {
                if (!layoutShot->commentRects.contains(comments[commentIndex].name))
                    continue;
 
                const QString& commentName = comments[commentIndex].name;
 
                QTextDocument doc;
                doc.setDocumentMargin(0);
                doc.setDefaultFont(painter.font());
                QString comment;
                comment += "<p><b>" + commentName + "</b></p>"; // if arrange options are used check for visibility
                QString originalCommentText = qvariant_cast<CommentBox>(storyboardList.at(currentBoard + firstItemRow)->child(StoryboardItem::Comments + commentIndex)->data()).content.toString();
                originalCommentText = originalCommentText.replace('\n', "</p><p>");
                comment += "<p>&nbsp;" + originalCommentText + "</p>";
                const int MARGIN = painter.fontMetrics().averageCharWidth() / 2;
 
                doc.setHtml(comment);
                doc.setTextWidth(layoutShot->commentRects[commentName].width() - MARGIN * 2);
 
                QAbstractTextDocumentLayout::PaintContext ctx;
                ctx.palette.setColor(QPalette::Text, painter.pen().color());
 
                //draw the comments
                painter.save();
                painter.translate(layoutShot->commentRects[commentName].topLeft() + QPoint(MARGIN, MARGIN));
                painter.setClipRegion(QRegion(0,0,layoutShot->commentRects[commentName].width(), layoutShot->commentRects[commentName].height() - painter.fontMetrics().height()));
                painter.setBackgroundMode(Qt::TransparentMode);
                doc.documentLayout()->draw(&painter, ctx);
                painter.restore();
 
                painter.drawRect(layoutShot->commentRects[commentName]);
            }
 
            // Draw overlays after drawing last element on page or after drawing last element in general.
            if ((currentBoard % layoutPage.elements.length()) == (layoutPage.elements.length() - 1) || (currentBoard == numBoards - 1)) {
 
                painter.save();
                painter.setBackgroundMode(Qt::TransparentMode);
 
                if (layoutPage.pageNumberRect) {
                    painter.drawText(layoutPage.pageNumberRect.value(), Qt::AlignCenter, QString::number(pageNumber));
                }
 
                if (layoutPage.pageTimeRect) {
                    int pageDurationSecondsPart = pageDurationInFrames / m_storyboardModel->getFramesPerSecond();
                    int pageDurationFramesPart = pageDurationInFrames % m_storyboardModel->getFramesPerSecond();
 
                    painter.drawText(layoutPage.pageTimeRect.value(), Qt::AlignCenter, buildDurationString(pageDurationSecondsPart, pageDurationFramesPart));
                }
 
                if (layoutPage.svg) {
                    QMap<QString, QDomNode> groups = rootItemsInSvg(layoutPage.svg.value());
                    if (groups.contains("overlay")) {
                        QMapIterator<QString, QDomNode> iter(groups);
                        while(iter.hasNext()) {
                            iter.next();
                            if (iter.key() == "overlay") {
                                iter.value().toElement().setAttribute("display","inline");
                            } else {
                                iter.value().toElement().setAttribute("display","none");
                            }
                        }
                    }
                    QSvgRenderer renderer(layoutPage.svg->toByteArray());
                    renderer.render(&painter);
                }
 
                painter.restore();
            }
        }
        painter.end();
    }
}

References buildDurationString(), DlgExportStoryboard::columns(), StoryboardDockerDock::ExportPageShot::commentRects, StoryboardItem::Comments, StoryboardDockerDock::ExportPageShot::cutDurationRect, StoryboardDockerDock::ExportPageShot::cutImageRect, StoryboardDockerDock::ExportPageShot::cutNameRect, StoryboardDockerDock::ExportPageShot::cutNumberRect, StoryboardDockerDock::ExportPage::elements, DlgExportStoryboard::fontSize(), DlgExportStoryboard::format(), StoryboardItem::FrameNumber, getPageLayout(), KisImage::height(), KisCanvas2::image(), KisCanvas2::imageView(), StoryboardItem::ItemName, KIS_SAFE_ASSERT_RECOVER_RETURN, DlgExportStoryboard::layoutSpecifiedBySvgFile(), DlgExportStoryboard::layoutSvgFile(), m_canvas, m_commentModel, m_storyboardModel, MARGIN, StoryboardDockerDock::ExportPage::pageNumberRect, DlgExportStoryboard::pageOrientation(), DlgExportStoryboard::pageSize(), StoryboardDockerDock::ExportPage::pageTimeRect, ThumbnailData::pixmap, rootItemsInSvg(), DlgExportStoryboard::rows(), DlgExportStoryboard::saveFileName(), SVG, StoryboardDockerDock::ExportPage::svg, StoryboardModel::TotalSceneDurationInFrames, and KisImage::width().

slotExportAsPdf

void StoryboardDockerDock::slotExportAsPdf ( )

privateslot

calls slotExport(ExportFormat) with PDF parameter.

Definition at line 368 of file StoryboardDockerDock.cpp.

{
    slotExport(ExportFormat::PDF);
}

References PDF, and slotExport().

slotExportAsSvg

void StoryboardDockerDock::slotExportAsSvg ( )

privateslot

calls slotExport(ExportFormat) with SVG parameter.

Definition at line 373 of file StoryboardDockerDock.cpp.

{
    slotExport(ExportFormat::SVG);
}

References slotExport(), and SVG.

slotLockClicked

void StoryboardDockerDock::slotLockClicked ( bool isLocked )

privateslot

called when lock toggle button is clicked.

Parameters

value

The new lock toggle value.

Definition at line 652 of file StoryboardDockerDock.cpp.

                                                       {
    if (isLocked) {
        m_lockAction->setIcon(KisIconUtils::loadIcon("locked"));
        m_storyboardModel->setLocked(true);
    }
    else {
        m_lockAction->setIcon(KisIconUtils::loadIcon("unlocked"));
        m_storyboardModel->setLocked(false);
    }
}

References KisIconUtils::loadIcon(), m_lockAction, and m_storyboardModel.

slotModeChanged

void StoryboardDockerDock::slotModeChanged ( QAbstractButton * button )

privateslot

called when a mode option is selected in Arrange menu.

Parameters

button

The button selected.

Definition at line 663 of file StoryboardDockerDock.cpp.

{
    int mode = m_modeGroup->id(button);
    if (mode == Mode::Column) {
        m_ui->sceneView->setFlow(QListView::LeftToRight);
        m_ui->sceneView->setWrapping(false);
        m_ui->sceneView->setItemOrientation(Qt::Vertical);
        m_viewGroup->button(View::CommentsOnly)->setEnabled(true);
    }
    else if (mode == Mode::Row) {
        m_ui->sceneView->setFlow(QListView::TopToBottom);
        m_ui->sceneView->setWrapping(false);
        m_ui->sceneView->setItemOrientation(Qt::Horizontal);
        m_viewGroup->button(View::CommentsOnly)->setEnabled(false);           //disable the comments only view
    }
    else if (mode == Mode::Grid) {
        m_ui->sceneView->setFlow(QListView::LeftToRight);
        m_ui->sceneView->setWrapping(true);
        m_ui->sceneView->setItemOrientation(Qt::Vertical);
        m_viewGroup->button(View::CommentsOnly)->setEnabled(true);
    }
    m_storyboardModel->layoutChanged();
}

References button(), Column, Grid, m_modeGroup, m_storyboardModel, m_ui, m_viewGroup, and Row.

slotModelChanged

void StoryboardDockerDock::slotModelChanged ( )

privateslot

called to reflect changes to the model.

Definition at line 714 of file StoryboardDockerDock.cpp.

{
    if (m_storyboardModel) {
        m_ui->btnExport->setDisabled(m_storyboardModel->rowCount() == 0);
    }
}

References m_storyboardModel, and m_ui.

slotUpdateCommentModelList

void StoryboardDockerDock::slotUpdateCommentModelList ( )

privateslot

sets the CommentModel's comment list to be the same as KisDocument's storyboardCommentList

Definition at line 363 of file StoryboardDockerDock.cpp.

{
    m_commentModel->resetData(m_canvas->imageView()->document()->getStoryboardCommentsList());
}

References KisCanvas2::imageView(), m_canvas, and m_commentModel.

slotUpdateDocumentList

void StoryboardDockerDock::slotUpdateDocumentList ( )

privateslot

sets the KisDocument's storyboardItemList to be the same as StoryboardModel's storyboardItemList and KisDocument's storyboardCommentList to be the same as CommentModel's commentList

Definition at line 352 of file StoryboardDockerDock.cpp.

{
    m_canvas->imageView()->document()->setStoryboardItemList(m_storyboardModel->getData());
    m_canvas->imageView()->document()->setStoryboardCommentList(m_commentModel->getData());
}

References KisCanvas2::imageView(), m_canvas, m_commentModel, and m_storyboardModel.

slotUpdateMinimumWidth

void StoryboardDockerDock::slotUpdateMinimumWidth ( )

privateslot

called to update minimum width on reaction to model changes. Should change based on available content.

Definition at line 709 of file StoryboardDockerDock.cpp.

{
    m_ui->sceneView->setMinimumSize(m_ui->sceneView->sizeHint());
}

References m_ui.

slotUpdateStoryboardModelList

void StoryboardDockerDock::slotUpdateStoryboardModelList ( )

privateslot

sets the StoryboardModel's storyboardItemList to be the same as KisDocument's storyboardItemList

Definition at line 358 of file StoryboardDockerDock.cpp.

{
    m_storyboardModel->resetData(m_canvas->imageView()->document()->getStoryboardItemList());
}

References KisCanvas2::imageView(), m_canvas, and m_storyboardModel.

slotViewChanged

void StoryboardDockerDock::slotViewChanged ( QAbstractButton * button )

privateslot

called when a view option is selected in Arrange menu.

Parameters

button

The button selected.

Definition at line 687 of file StoryboardDockerDock.cpp.

{
    int view = m_viewGroup->id(button);
    if (view == View::All) {
        m_ui->sceneView->setCommentVisibility(true);
        m_ui->sceneView->setThumbnailVisibility(true);
        m_modeGroup->button(Mode::Row)->setEnabled(true);
    }
    else if (view == View::ThumbnailsOnly) {
        m_ui->sceneView->setCommentVisibility(false);
        m_ui->sceneView->setThumbnailVisibility(true);
        m_modeGroup->button(Mode::Row)->setEnabled(true);
    }
 
    else if (view == View::CommentsOnly) {
        m_ui->sceneView->setCommentVisibility(true);
        m_ui->sceneView->setThumbnailVisibility(false);
        m_modeGroup->button(Mode::Row)->setEnabled(false);               //disable the row mode
    }
    m_storyboardModel->layoutChanged();
}

References button(), m_modeGroup, m_storyboardModel, m_ui, m_viewGroup, and Row.

unsetCanvas()

void StoryboardDockerDock::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 330 of file StoryboardDockerDock.cpp.

{
    setCanvas(0);
}

References setCanvas().

Member Data Documentation

m_arrangeMenu

ArrangeMenu* StoryboardDockerDock::m_arrangeMenu

private

Definition at line 149 of file StoryboardDockerDock.h.

m_canvas

KisCanvas2* StoryboardDockerDock::m_canvas

private

Definition at line 136 of file StoryboardDockerDock.h.

m_commentMenu

CommentMenu* StoryboardDockerDock::m_commentMenu

private

Definition at line 145 of file StoryboardDockerDock.h.

m_commentModel

QPointer<StoryboardCommentModel> StoryboardDockerDock::m_commentModel

private

Definition at line 144 of file StoryboardDockerDock.h.

m_exportAsPdfAction

KisAction* StoryboardDockerDock::m_exportAsPdfAction

private

Definition at line 141 of file StoryboardDockerDock.h.

m_exportAsSvgAction

KisAction* StoryboardDockerDock::m_exportAsSvgAction

private

Definition at line 142 of file StoryboardDockerDock.h.

m_exportMenu

QMenu* StoryboardDockerDock::m_exportMenu

private

Definition at line 140 of file StoryboardDockerDock.h.

m_lockAction

KisAction* StoryboardDockerDock::m_lockAction

private

Definition at line 147 of file StoryboardDockerDock.h.

m_modeGroup

QButtonGroup* StoryboardDockerDock::m_modeGroup

private

Definition at line 151 of file StoryboardDockerDock.h.

m_nodeManager

KisNodeManager* StoryboardDockerDock::m_nodeManager

private

Definition at line 137 of file StoryboardDockerDock.h.

m_storyboardDelegate

QPointer<StoryboardDelegate> StoryboardDockerDock::m_storyboardDelegate

private

Definition at line 155 of file StoryboardDockerDock.h.

m_storyboardModel

QSharedPointer<StoryboardModel> StoryboardDockerDock::m_storyboardModel

private

Definition at line 154 of file StoryboardDockerDock.h.

m_ui

QScopedPointer<Ui_WdgStoryboardDock> StoryboardDockerDock::m_ui

private

Definition at line 138 of file StoryboardDockerDock.h.

m_viewGroup

QButtonGroup* StoryboardDockerDock::m_viewGroup

private

Definition at line 152 of file StoryboardDockerDock.h.

---

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

• plugins/dockers/storyboarddocker/StoryboardDockerDock.h
• plugins/dockers/storyboarddocker/StoryboardDockerDock.cpp