KisAnimTimelineFrameDelegate Class Reference

#include <KisAnimTimelineFrameDelegate.h>

Inheritance diagram for KisAnimTimelineFrameDelegate:

Public Member Functions
void	drawBackground (QPainter *painter, const QModelIndex &index, const QRect &rc) const
void	drawCloneGraphics (QPainter *painter, const QRect &rect) const
void	drawFocus (QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect) const override
	KisAnimTimelineFrameDelegate (QObject *parent)
void	paint (QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
void	paintSpecialKeyframeIndicator (QPainter *painter, const QModelIndex &index, const QRect &rc) const
	the opacity keyframe
	~KisAnimTimelineFrameDelegate () override

Static Public Member Functions
static void	paintActiveFrameSelector (QPainter *painter, const QRect &rc, bool isCurrentFrame)

Private Attributes
QVector< QColor >	labelColors
QPixmap	stripes

Detailed Description

Definition at line 13 of file KisAnimTimelineFrameDelegate.h.

Constructor & Destructor Documentation

KisAnimTimelineFrameDelegate()

KisAnimTimelineFrameDelegate::KisAnimTimelineFrameDelegate

(

QObject *

parent

)

Definition at line 19 of file KisAnimTimelineFrameDelegate.cpp.

    : QItemDelegate(parent),
      stripes(64, 64)
{
    KisNodeViewColorScheme scm;
    labelColors = scm.allColorLabels();
 
    // Clone frame stripes SVG -> Pixmap..
    QImage stripesImage(":diagonal-stripe.svg", "svg");
    stripesImage.save("/tmp/krita_stripes.svg", "svg");
    stripes = QPixmap::fromImage(stripesImage);
}

References KisNodeViewColorScheme::allColorLabels(), labelColors, and stripes.

~KisAnimTimelineFrameDelegate()

KisAnimTimelineFrameDelegate::~KisAnimTimelineFrameDelegate ( )

override

Definition at line 32 of file KisAnimTimelineFrameDelegate.cpp.

{
}

Member Function Documentation

drawBackground()

void KisAnimTimelineFrameDelegate::drawBackground	(	QPainter *	painter,
		const QModelIndex &	index,
		const QRect &	rc ) const

is the current layer actively selected (this is not the same as visibility)

does keyframe exist

is layer editable

find out if frame is empty

Definition at line 122 of file KisAnimTimelineFrameDelegate.cpp.

{
    painter->save();
 
    bool hasActiveLayerRole = index.data(KisAnimTimelineFramesModel::ActiveLayerRole).toBool();
    bool doesFrameExist = index.data(KisAnimTimelineFramesModel::FrameExistsRole).toBool();   
    bool isEditable = index.data(KisAnimTimelineFramesModel::FrameEditableRole).toBool(); 
    bool hasContent = index.data(KisAnimTimelineFramesModel::FrameHasContent).toBool();     
 
    QColor color; // will get re-used for determining color
    QColor noLabelSetColor = qApp->palette().color(QPalette::Highlight); // if no color label is used
    QColor highlightColor = qApp->palette().color(QPalette::Highlight);
    QColor baseColor = qApp->palette().color(QPalette::Base);
 
 
    // pass for filling in the active row with slightly color difference
    if (hasActiveLayerRole) {
        color = KisPaintingTweaks::blendColors(baseColor, highlightColor, 0.8);
        painter->fillRect(rc, color);
    } else {
        color = KisPaintingTweaks::blendColors(baseColor, highlightColor, 0.95);
        painter->fillRect(rc, color);
    }
 
    // assign background color for frame depending on if the frame has a color label or not
    QVariant colorLabel = index.data(KisAnimTimelineFramesModel::FrameColorLabelIndexRole);
    if (colorLabel.isValid()) {
        color = labelColors.at(colorLabel.toInt());
    } else {
        color = noLabelSetColor;
    }
 
 
    // if layer is hidden, make the entire color more subtle.
    // this should be in effect for both fill color and empty outline color
    if (!isEditable) {
        color = KisPaintingTweaks::blendColors(baseColor, color, 0.7);
    }
 
 
    // how do we fill in a frame that has content
    // a keyframe will be totally filled in. A hold frame will have a line running through it
    if (hasContent && doesFrameExist) {
        painter->fillRect(rc, color);
    }
 
    // pass of outline for empty keyframes
    if (doesFrameExist && !hasContent) {
 
        QPen oldPen = painter->pen();
        QBrush oldBrush(painter->brush());
 
        painter->setPen(QPen(color, 2));
        painter->setBrush(Qt::NoBrush);
        painter->drawRect(rc);
 
        painter->setBrush(oldBrush);
        painter->setPen(oldPen);
    }
 
    // pass of hold frame line
    if (!doesFrameExist && hasContent) {
 
        // pretty much the same check as "isValid" above, but that isn't working with hold frames
         if (colorLabel.toInt() == 0) {
             color = noLabelSetColor;
 
             if (!isEditable) {
                 color = KisPaintingTweaks::blendColors(baseColor, color, 0.7);
             }
         }
 
 
        QPoint lineStart(rc.x(), (rc.y() + rc.height()/2));
        QPoint lineEnd(rc.x() + rc.width(), (rc.y() + rc.height()/2));
 
        QPen holdFramePen(color);
        holdFramePen.setWidth(1);
 
        painter->setPen(holdFramePen);
        painter->drawLine(QLine(lineStart, lineEnd));
    }
 
    painter->restore();
}

References KisAnimTimelineFramesModel::ActiveLayerRole, KisPaintingTweaks::blendColors(), KisAnimTimelineFramesModel::FrameColorLabelIndexRole, KisTimeBasedItemModel::FrameEditableRole, KisTimeBasedItemModel::FrameExistsRole, KisTimeBasedItemModel::FrameHasContent, and labelColors.

drawCloneGraphics()

void KisAnimTimelineFrameDelegate::drawCloneGraphics	(	QPainter *	painter,
		const QRect &	rect ) const

Definition at line 236 of file KisAnimTimelineFrameDelegate.cpp.

{
    painter->save();
 
    QBrush brush(stripes);
    brush.setStyle(Qt::TexturePattern);
 
    painter->setPen(Qt::NoPen);
    painter->setBrush(brush);
    painter->setOpacity(0.25f);
    painter->drawRect(rect);
 
    painter->restore();
}

References stripes.

drawFocus()

void KisAnimTimelineFrameDelegate::drawFocus ( QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect ) const

override

Definition at line 209 of file KisAnimTimelineFrameDelegate.cpp.

{
    // copied from Qt 4.8!
    if ((option.state & QStyle::State_HasFocus) == 0 || !rect.isValid())
        return;
 
    painter->save();
 
 
    QStyleOptionFocusRect o;
    o.QStyleOption::operator=(option);
    o.rect = rect;
    o.state |= QStyle::State_KeyboardFocusChange;
    o.state |= QStyle::State_Item;
    QPalette::ColorGroup cg = (option.state & QStyle::State_Enabled)
                              ? QPalette::Normal : QPalette::Disabled;
    o.backgroundColor = option.palette.color(cg, (option.state & QStyle::State_Selected)
                                             ? QPalette::Highlight : QPalette::Window);
    const QWidget *widget = qobject_cast<QWidget*>(parent());
    QStyle *style = widget ? widget->style() : QApplication::style();
    style->drawPrimitive(QStyle::PE_FrameFocusRect, &o, painter, widget);
 
    painter->restore();
}

paint()

void KisAnimTimelineFrameDelegate::paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const

override

Definition at line 251 of file KisAnimTimelineFrameDelegate.cpp.

{
    // draws background as well as fills normal keyframes
    drawBackground(painter, index, option.rect);
 
    // Clone graphics..
    if (index.data(KisAnimTimelineFramesModel::CloneOfActiveFrame).toBool() && index.data(KisAnimTimelineFramesModel::ActiveLayerRole).toBool()) {
        drawCloneGraphics(painter, option.rect);
    }
 
    // creates a semi transparent orange rectangle in the frame that is actively selected on the active row
    if (option.showDecorationSelected &&
        (option.state & QStyle::State_Selected)) {
        painter->save();
 
        const QVariant data = index.data(KisAnimTimelineFramesModel::FrameEditableRole);
        bool isEditable = data.isValid() ? data.toBool() : true;
 
        QColor highlightColor = KisAnimTimelineColors::instance()->selectionColor();
        highlightColor.setAlpha(isEditable ? 128 : 64);
        QBrush brush = highlightColor;
        painter->fillRect(option.rect, brush);
 
        painter->restore();
    }
 
    // not sure what this is drawing
    drawFocus(painter, option, option.rect);
 
    // opacity keyframe, but NOT normal keyframes
    bool specialKeys = index.data(KisAnimTimelineFramesModel::SpecialKeyframeExists).toBool();
    if (specialKeys) {
        paintSpecialKeyframeIndicator(painter, index, option.rect);
    }
 
    // creates a border and dot on the selected frame on the active row
    bool active = index.data(KisAnimTimelineFramesModel::ActiveFrameRole).toBool();
    bool layerIsCurrent = index.data(KisAnimTimelineFramesModel::ActiveLayerRole).toBool();
    if (active) {
        paintActiveFrameSelector(painter, option.rect, layerIsCurrent);
    }
 
    { // Shade over anything that's outside of the animation range...
        if (index.data(KisAnimTimelineFramesModel::WithinClipRange).toBool() == false) {
            painter->save();
 
            painter->setOpacity(0.50f);
            painter->fillRect(option.rect, qApp->palette().color(QPalette::Base).darker(110));
 
            painter->restore();
        }
    }
}

References KisTimeBasedItemModel::ActiveFrameRole, KisAnimTimelineFramesModel::ActiveLayerRole, KisTimeBasedItemModel::CloneOfActiveFrame, drawBackground(), drawCloneGraphics(), drawFocus(), KisTimeBasedItemModel::FrameEditableRole, KisAnimTimelineColors::instance(), paintActiveFrameSelector(), paintSpecialKeyframeIndicator(), KisAnimTimelineColors::selectionColor(), KisTimeBasedItemModel::SpecialKeyframeExists, and KisTimeBasedItemModel::WithinClipRange.

paintActiveFrameSelector()

void KisAnimTimelineFrameDelegate::paintActiveFrameSelector ( QPainter * painter, const QRect & rc, bool isCurrentFrame )

static

Definition at line 36 of file KisAnimTimelineFrameDelegate.cpp.

{
    painter->save();
 
    QColor lineColor = KisAnimTimelineColors::instance()->selectorColor();
    const int lineWidth = rc.width() > 20 ? 4 : 2;
 
    const int x0 = rc.x();
    const int y0 = rc.y();
    const int x1 = rc.right();
    const int y1 = rc.bottom();
 
    QVector<QLine> linesDark;
    linesDark << QLine(x0 + lineWidth / 2, y0, x0  + lineWidth / 2, y1);
    linesDark << QLine(x1 -  lineWidth / 2 + 1, y0, x1 - lineWidth / 2 + 1, y1);
 
    QPen oldPen = painter->pen();
    painter->setPen(QPen(lineColor, lineWidth));
    painter->drawLines(linesDark);
    painter->setPen(oldPen);
 
    if (isCurrentFrame) {
        QPen oldPen = painter->pen();
        QBrush oldBrush(painter->brush());
 
        painter->setPen(QPen(lineColor, 0));
        painter->setBrush(lineColor);
 
        painter->drawEllipse(rc.center(), 2,2);
 
        painter->setBrush(oldBrush);
        painter->setPen(oldPen);
    }
 
    painter->restore();
}

References KisAnimTimelineColors::instance(), and KisAnimTimelineColors::selectorColor().

paintSpecialKeyframeIndicator()

void KisAnimTimelineFrameDelegate::paintSpecialKeyframeIndicator	(	QPainter *	painter,
		const QModelIndex &	index,
		const QRect &	rc ) const

the opacity keyframe

does normal keyframe exist

find out if frame is empty

Definition at line 73 of file KisAnimTimelineFrameDelegate.cpp.

{
    painter->save();
 
    bool doesFrameExist = index.data(KisAnimTimelineFramesModel::FrameExistsRole).toBool();   
    bool isEditable = index.data(KisAnimTimelineFramesModel::FrameEditableRole).toBool();
    bool hasContent = index.data(KisAnimTimelineFramesModel::FrameHasContent).toBool();     
 
    QColor color = qApp->palette().color(QPalette::Highlight);
    QColor baseColor = qApp->palette().color(QPalette::Base);
    QColor noLabelSetColor = qApp->palette().color(QPalette::Highlight); // if no color label is used
 
    // use color label if it exists. coloring follows very similar logic to the drawBackground() function except this is a bit simpler
    QVariant colorLabel = index.data(KisAnimTimelineFramesModel::FrameColorLabelIndexRole);
    if (colorLabel.isValid()) {
        color = labelColors.at(colorLabel.toInt());
    } else {
        color = noLabelSetColor;
    }
 
    if (!isEditable) {
        color = KisPaintingTweaks::blendColors(baseColor, color, 0.5);
    }
 
    if (doesFrameExist && hasContent) {
        color = baseColor; // special keyframe will be over filled in frame, so switch color so it is shown
    }
 
    QPen oldPen = painter->pen();
    QBrush oldBrush(painter->brush());
 
    painter->setPen(QPen(color, 0));
    painter->setBrush(color);
 
    QPointF center = rc.center();
    QPointF points[4] = {
        QPointF(center.x() + 4, center.y()   ),
        QPointF(center.x()    , center.y() - 4),
        QPointF(center.x() - 4, center.y()   ),
        QPointF(center.x()    , center.y() + 4)
    };
    painter->drawConvexPolygon(points, 4);
 
    painter->setBrush(oldBrush);
    painter->setPen(oldPen);
 
    painter->restore();
}

References KisPaintingTweaks::blendColors(), KisAnimTimelineFramesModel::FrameColorLabelIndexRole, KisTimeBasedItemModel::FrameEditableRole, KisTimeBasedItemModel::FrameExistsRole, KisTimeBasedItemModel::FrameHasContent, and labelColors.

Member Data Documentation

labelColors

QVector<QColor> KisAnimTimelineFrameDelegate::labelColors

private

Definition at line 33 of file KisAnimTimelineFrameDelegate.h.

stripes

QPixmap KisAnimTimelineFrameDelegate::stripes

private

Definition at line 34 of file KisAnimTimelineFrameDelegate.h.

---

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

• plugins/dockers/animation/KisAnimTimelineFrameDelegate.h
• plugins/dockers/animation/KisAnimTimelineFrameDelegate.cpp