KisAnimCurvesView Class Reference

#include <KisAnimCurvesView.h>

Inheritance diagram for KisAnimCurvesView:

Classes
struct	Private

Public Slots
void	applyBezierMode ()
void	applyConstantMode ()
void	applyLinearMode ()
void	applySharpMode ()
void	applySmoothMode ()
void	changeZoom (Qt::Orientation orientation, qreal zoomDelta)
void	createKeyframe ()
void	removeKeyframes ()
void	slotScrollerStateChanged (QScroller::State state)
void	zoomToFitChannel ()
void	zoomToFitCurve ()

Signals
void	activeDataChanged (const QModelIndex &index)

Public Member Functions
QModelIndex	indexAt (const QPoint &point) const override
bool	indexHasKey (const QModelIndex &index)
	KisAnimCurvesView (QWidget *parent)
void	scrollTo (const QModelIndex &index, ScrollHint hint) override
void	setModel (QAbstractItemModel *model) override
QRect	visualRect (const QModelIndex &index) const override
	~KisAnimCurvesView () override

Protected Slots
void	updateGeometries () override

Protected Member Functions
int	horizontalOffset () const override
bool	isIndexHidden (const QModelIndex &index) const override
void	mouseDoubleClickEvent (QMouseEvent *) override
void	mouseMoveEvent (QMouseEvent *) override
void	mousePressEvent (QMouseEvent *) override
void	mouseReleaseEvent (QMouseEvent *) override
QModelIndex	moveCursor (CursorAction cursorAction, Qt::KeyboardModifiers modifiers) override
void	paintEvent (QPaintEvent *event) override
void	scrollContentsBy (int dx, int dy) override
void	setSelection (const QRect &rect, QItemSelectionModel::SelectionFlags flags) override
int	verticalOffset () const override
QRegion	visualRegionForSelection (const QItemSelection &selection) const override

Private Slots
void	slotDataAdded (const QModelIndex &index)
void	slotDataChanged (const QModelIndex &topLeft, const QModelIndex &bottomRight)
void	slotHeaderDataChanged (Qt::Orientation orientation, int first, int last)
void	slotRowsChanged (const QModelIndex &parentIndex, int first, int last)
void	slotUpdateHorizontalScrollbarSize ()
void	slotUpdateInfiniteFramesCount ()

Private Member Functions
void	findExtremes (qreal *minimum, qreal *maximum)
QModelIndex	findNextKeyframeIndex (int channel, int time, int selectionOffset, bool backward)
void	paintCurve (int channel, int firstFrame, int lastFrame, QPainter &painter)
void	paintCurves (QPainter &painter, int firstFrame, int lastFrame)
void	paintCurveSegment (QPainter &painter, QPointF pos1, QPointF rightTangent, QPointF leftTangent, QPointF pos2, QVariant limitData)
void	paintGrid (QPainter &painter)
void	paintKeyframes (QPainter &painter, int firstFrame, int lastFrame)

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 17 of file KisAnimCurvesView.h.

Constructor & Destructor Documentation

KisAnimCurvesView()

KisAnimCurvesView::KisAnimCurvesView

(

QWidget *

parent

)

Definition at line 58 of file KisAnimCurvesView.cpp.

    : QAbstractItemView(parent)
    , m_d(new Private())
{
    m_d->horizontalHeader = new KisAnimTimelineTimeHeader(this);
 
    m_d->verticalHeader = new KisAnimCurvesValuesHeader(this);
    m_d->itemDelegate = new KisAnimCurvesKeyDelegate(m_d->horizontalHeader, m_d->verticalHeader, this);
 
    m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
    m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
 
    setSelectionMode(QAbstractItemView::ExtendedSelection);
 
    KisZoomableScrollBar* horiZoomableBar = new KisZoomableScrollBar(this);
    setHorizontalScrollBar(horiZoomableBar);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
    connect(horiZoomableBar, &KisZoomableScrollBar::valueChanged, [this](qreal value){
        m_d->horizontalHeader->setPixelOffset(value);
        slotUpdateInfiniteFramesCount();
        viewport()->update();
    });
 
    connect(horiZoomableBar, &KisZoomableScrollBar::sliderReleased, this, &KisAnimCurvesView::slotUpdateHorizontalScrollbarSize);
 
    connect(horiZoomableBar, &KisZoomableScrollBar::overscroll, [this](qreal overscroll){
        m_d->horizontalHeader->setPixelOffset(m_d->horizontalHeader->offset() + overscroll);
        slotUpdateInfiniteFramesCount();
        slotUpdateHorizontalScrollbarSize();
        viewport()->update();
    });
 
    connect(horiZoomableBar, &KisZoomableScrollBar::zoom, [this](qreal zoomDelta){
        qreal currentZoomLevel = m_d->horizontalHeader->zoom();
        m_d->horizontalHeader->setZoom(currentZoomLevel + zoomDelta);
        slotUpdateInfiniteFramesCount();
        slotUpdateHorizontalScrollbarSize();
        viewport()->update();
    });
 
 
    KisZoomableScrollBar* vertZoomableBar = new KisZoomableScrollBar(this);
    setVerticalScrollBar(vertZoomableBar);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
    vertZoomableBar->setWheelOverscrollSensitivity( 0.04f );
 
    connect(vertZoomableBar, &KisZoomableScrollBar::zoom, [this](qreal zoomDelta){
        const qreal currentZoomLevel = m_d->verticalHeader->scale();
        m_d->verticalHeader->setScale(currentZoomLevel + zoomDelta / m_d->verticalHeader->step());
    });
 
    connect(vertZoomableBar, &KisZoomableScrollBar::overscroll, [this](qreal overscroll){
       qreal currentOffset = m_d->verticalHeader->valueOffset();
       m_d->verticalHeader->setValueOffset(currentOffset - overscroll * m_d->verticalHeader->step() * 0.25);
    });
    
    connect(m_d->verticalHeader, &KisAnimCurvesValuesHeader::scaleChanged, [this](qreal){
        viewport()->update();
    });
    
    connect(m_d->verticalHeader, &KisAnimCurvesValuesHeader::valueOffsetChanged, [this](qreal){
        viewport()->update();
    });
 
    // Kinetic scrolling via left-click completely breaks everything, it somehow
    // ends up reporting left clicks as right clicks and makes the whole curves
    // view behave erratically with regards to when it wants to scroll and when
    // you're dragging pints. So we don't enable kinetic scrolling in that case
    // and require the use of the scrollbar instead, like on the timeline.
    if (KisKineticScroller::getConfiguredGestureType() != QScroller::LeftMouseButtonGesture) {
        QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this);
        if (scroller){
            connect(scroller, SIGNAL(stateChanged(QScroller::State)),
                    this, SLOT(slotScrollerStateChanged(QScroller::State)));
 
            QScrollerProperties props = scroller->scrollerProperties();
            props.setScrollMetric(QScrollerProperties::VerticalOvershootPolicy, QScrollerProperties::OvershootAlwaysOff);
            props.setScrollMetric(QScrollerProperties::HorizontalOvershootPolicy, QScrollerProperties::OvershootAlwaysOff);
            scroller->setScrollerProperties(props);
        }
    }
}

References KisKineticScroller::createPreconfiguredScroller(), KisKineticScroller::getConfiguredGestureType(), m_d, KisZoomableScrollBar::overscroll(), KisAnimCurvesValuesHeader::scaleChanged(), slotScrollerStateChanged(), slotUpdateHorizontalScrollbarSize(), slotUpdateInfiniteFramesCount(), value(), KisAnimCurvesValuesHeader::valueOffsetChanged(), and KisZoomableScrollBar::zoom().

~KisAnimCurvesView()

KisAnimCurvesView::~KisAnimCurvesView ( )

override

Definition at line 144 of file KisAnimCurvesView.cpp.

{}

Member Function Documentation

activeDataChanged

void KisAnimCurvesView::activeDataChanged ( const QModelIndex & index )

signal

applyBezierMode

void KisAnimCurvesView::applyBezierMode ( )

slot

Definition at line 893 of file KisAnimCurvesView.cpp.

{
    m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
    Q_FOREACH(QModelIndex index, selectedIndexes()) {
        m_d->model->setData(index, KisScalarKeyframe::Bezier, KisAnimCurvesModel::InterpolationModeRole);
    }
    m_d->model->endCommand();
}

References KisScalarKeyframe::Bezier, KisAnimCurvesModel::InterpolationModeRole, kundo2_i18n(), and m_d.

applyConstantMode

void KisAnimCurvesView::applyConstantMode ( )

slot

Definition at line 875 of file KisAnimCurvesView.cpp.

{
    m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
    Q_FOREACH(QModelIndex index, selectedIndexes()) {
        m_d->model->setData(index, KisScalarKeyframe::Constant, KisAnimCurvesModel::InterpolationModeRole);
    }
    m_d->model->endCommand();
}

References KisScalarKeyframe::Constant, KisAnimCurvesModel::InterpolationModeRole, kundo2_i18n(), and m_d.

applyLinearMode

void KisAnimCurvesView::applyLinearMode ( )

slot

Definition at line 884 of file KisAnimCurvesView.cpp.

{
    m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
    Q_FOREACH(QModelIndex index, selectedIndexes()) {
        m_d->model->setData(index, KisScalarKeyframe::Linear, KisAnimCurvesModel::InterpolationModeRole);
    }
    m_d->model->endCommand();
}

References KisAnimCurvesModel::InterpolationModeRole, kundo2_i18n(), KisScalarKeyframe::Linear, and m_d.

applySharpMode

void KisAnimCurvesView::applySharpMode ( )

slot

Definition at line 930 of file KisAnimCurvesView.cpp.

{
    m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
    Q_FOREACH(QModelIndex index, selectedIndexes()) {
        model()->setData(index, KisScalarKeyframe::Sharp, KisAnimCurvesModel::TangentsModeRole);
    }
    m_d->model->endCommand();
}

References kundo2_i18n(), m_d, KisScalarKeyframe::Sharp, and KisAnimCurvesModel::TangentsModeRole.

applySmoothMode

void KisAnimCurvesView::applySmoothMode ( )

slot

Definition at line 902 of file KisAnimCurvesView.cpp.

{
    m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
    Q_FOREACH(QModelIndex index, selectedIndexes()) {
        QVector2D leftVisualTangent(m_d->itemDelegate->leftHandle(index, false));
        QVector2D rightVisualTangent(m_d->itemDelegate->rightHandle(index, false));
 
        if (leftVisualTangent.lengthSquared() > 0 && rightVisualTangent.lengthSquared() > 0) {
            float leftAngle = qAtan2(-leftVisualTangent.y(), -leftVisualTangent.x());
            float rightAngle = qAtan2(rightVisualTangent.y(), rightVisualTangent.x());
            float angle = (leftAngle + rightAngle) / 2;
            QVector2D unit(qCos(angle), qSin(angle));
 
            leftVisualTangent = -unit * QVector2D(leftVisualTangent).length();
            rightVisualTangent = unit * QVector2D(rightVisualTangent).length();
 
            QPointF leftTangent = m_d->itemDelegate->unscaledTangent(leftVisualTangent.toPointF());
            QPointF rightTangent = m_d->itemDelegate->unscaledTangent(rightVisualTangent.toPointF());
 
            model()->setData(index, leftTangent, KisAnimCurvesModel::LeftTangentRole);
            model()->setData(index, rightTangent, KisAnimCurvesModel::RightTangentRole);
        }
 
        model()->setData(index, KisScalarKeyframe::Smooth, KisAnimCurvesModel::TangentsModeRole);
    }
    m_d->model->endCommand();
}

References kundo2_i18n(), KisAnimCurvesModel::LeftTangentRole, m_d, KisAnimCurvesModel::RightTangentRole, KisScalarKeyframe::Smooth, and KisAnimCurvesModel::TangentsModeRole.

changeZoom

void KisAnimCurvesView::changeZoom ( Qt::Orientation orientation, qreal zoomDelta )

slot

Definition at line 1001 of file KisAnimCurvesView.cpp.

{
    if (orientation == Qt::Horizontal) {
        m_d->horizontalHeader->setZoom( m_d->horizontalHeader->zoom() + zoomDelta);
        slotUpdateInfiniteFramesCount();
    } else {
        const qreal currentZoomLevel = m_d->verticalHeader->scale();
        m_d->verticalHeader->setScale(currentZoomLevel + zoomDelta / m_d->verticalHeader->step());
    }
    viewport()->update();
}

References m_d, and slotUpdateInfiniteFramesCount().

createKeyframe

void KisAnimCurvesView::createKeyframe ( )

slot

Definition at line 939 of file KisAnimCurvesView.cpp.

{
    QModelIndex active = currentIndex();
    int channel = active.isValid() ? active.row() : 0;
 
    int time = m_d->model->currentTime();
    QModelIndex index = m_d->model->index(channel, time);
 
    qreal value = index.data(KisAnimCurvesModel::ScalarValueRole).toReal();
    m_d->model->setData(index, value, KisAnimCurvesModel::ScalarValueRole);
}

References m_d, KisAnimCurvesModel::ScalarValueRole, and value().

findExtremes()

void KisAnimCurvesView::findExtremes ( qreal * minimum, qreal * maximum )

private

Definition at line 426 of file KisAnimCurvesView.cpp.

{
    if (!model()) return;
 
    qreal min = qInf();
    qreal max = -qInf();
 
    int curveCount = model()->rowCount();
    for (int curveIndex = 0; curveIndex < curveCount; curveIndex++) {
        QModelIndex index = model()->index(curveIndex, 0);
        if (isIndexHidden(index)) continue;
 
        QVariant nextTime;
        do {
            qreal value = index.data(KisAnimCurvesModel::ScalarValueRole).toReal();
 
            if (value < min) min = value;
            if (value > max) max = value;
 
            const int MAX_NUM_TANGENTS = 2;
            for (int i = 0; i < MAX_NUM_TANGENTS; i++)  {
                QVariant tangent = index.data(KisAnimCurvesModel::LeftTangentRole + i);
                if (!tangent.isValid())
                    continue;
 
                QPointF tangentPointF = tangent.toPointF();
                if (value + tangentPointF.y() < min) min = value + tangentPointF.y();
                if (value + tangentPointF.y() > max) max = value + tangentPointF.y();
            }
 
            nextTime = index.data(KisAnimCurvesModel::NextKeyframeTime);
            if (nextTime.isValid()) index = model()->index(curveIndex, nextTime.toInt());
        } while (nextTime.isValid());
    }
 
    if (qIsFinite(min)) *minimum = min;
    if (qIsFinite(max)) *maximum = max;
}

References isIndexHidden(), KisAnimCurvesModel::LeftTangentRole, KisAnimCurvesModel::NextKeyframeTime, KisAnimCurvesModel::ScalarValueRole, and value().

findNextKeyframeIndex()

QModelIndex KisAnimCurvesView::findNextKeyframeIndex ( int channel, int time, int selectionOffset, bool backward )

private

Definition at line 387 of file KisAnimCurvesView.cpp.

{
    KisAnimCurvesModel::ItemDataRole role =
            backward ? KisAnimCurvesModel::PreviousKeyframeTime : KisAnimCurvesModel::NextKeyframeTime;
    QModelIndex currentIndex = model()->index(channel, time);
 
    if (!selectionOffset) {
        QVariant next = currentIndex.data(role);
        return (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
    } else {
        // Find the next unselected index
        QModelIndex nextIndex = currentIndex;
        do {
            QVariant next = nextIndex.data(role);
            nextIndex = (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
        } while(nextIndex.isValid() && selectionModel()->isSelected(nextIndex));
 
        // Find the next selected index, accounting for D&D offset
        QModelIndex draggedIndex = model()->index(channel, qMax(0, time - selectionOffset));
        do {
            QVariant next = draggedIndex.data(role);
            draggedIndex = (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
        } while(draggedIndex.isValid() && !selectionModel()->isSelected(draggedIndex));
 
        // Choose the earlier of the two
        if (draggedIndex.isValid() && nextIndex.isValid()) {
            if (draggedIndex.column() + selectionOffset <= nextIndex.column()) {
                return draggedIndex;
            } else {
                return nextIndex;
            }
        } else if (draggedIndex.isValid()) {
            return draggedIndex;
        } else {
            return nextIndex;
        }
    }
}

References KisAnimCurvesModel::NextKeyframeTime, and KisAnimCurvesModel::PreviousKeyframeTime.

horizontalOffset()

int KisAnimCurvesView::horizontalOffset ( ) const

overrideprotected

Definition at line 473 of file KisAnimCurvesView.cpp.

{
    return m_d->horizontalHeader->offset();
}

References m_d.

indexAt()

QModelIndex KisAnimCurvesView::indexAt ( const QPoint & point ) const

override

Definition at line 191 of file KisAnimCurvesView.cpp.

{
    if (!model()) return QModelIndex();
 
    int time = m_d->horizontalHeader->logicalIndexAt(point.x());
 
    int rows = model()->rowCount();
    for (int row=0; row < rows; row++) {
        QModelIndex index = model()->index(row, time);
 
        if (index.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool()
            && index.data(KisAnimCurvesModel::CurveVisibleRole).toBool()) {
            QRect nodePos = m_d->itemDelegate->itemRect(index);
 
            if (nodePos.contains(point)) {
                return index;
            }
        }
    }
 
    return QModelIndex();
}

References KisAnimCurvesModel::CurveVisibleRole, m_d, and KisTimeBasedItemModel::SpecialKeyframeExists.

indexHasKey()

bool KisAnimCurvesView::indexHasKey

(

const QModelIndex &

index

)

Definition at line 777 of file KisAnimCurvesView.cpp.

{
    const QVariant data = m_d->model->data(index, KisAnimCurvesModel::SpecialKeyframeExists);
    return data.isValid() && data.toBool();
}

References m_d, and KisTimeBasedItemModel::SpecialKeyframeExists.

isIndexHidden()

bool KisAnimCurvesView::isIndexHidden ( const QModelIndex & index ) const

overrideprotected

Definition at line 483 of file KisAnimCurvesView.cpp.

{
    return !index.data(KisAnimCurvesModel::CurveVisibleRole).toBool();
}

References KisAnimCurvesModel::CurveVisibleRole.

mouseDoubleClickEvent()

void KisAnimCurvesView::mouseDoubleClickEvent ( QMouseEvent * e )

overrideprotected

Definition at line 598 of file KisAnimCurvesView.cpp.

{
    QModelIndex clicked = indexAt(e->pos());
 
    if(clicked.isValid() && indexHasKey(clicked)) {
        selectionModel()->clear();
        bool firstSelection = true;
        if (e->modifiers() & Qt::AltModifier) {
            for (int column = 0; column <= model()->columnCount(); column++) {
                QModelIndex toSelect = model()->index(clicked.row(), column);
                const bool hasSpecial = toSelect.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool();
                const bool curveVisible = toSelect.data(KisAnimCurvesModel::CurveVisibleRole).toBool();
                if (toSelect.isValid() && hasSpecial && curveVisible) {
                    selectionModel()->select(toSelect, firstSelection ? QItemSelectionModel::SelectCurrent : QItemSelectionModel::Select);
                    firstSelection = false;
                }
            }
        } else {
            for (int row = 0; row <= model()->rowCount(); row++) {
                QModelIndex toSelect = model()->index(row, clicked.column());
                const bool hasSpecial = toSelect.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool();
                const bool curveVisible = toSelect.data(KisAnimCurvesModel::CurveVisibleRole).toBool();
                if (toSelect.isValid() && hasSpecial && curveVisible) {
                    selectionModel()->select(toSelect, firstSelection ? QItemSelectionModel::SelectCurrent : QItemSelectionModel::Select);
                    firstSelection = false;
                }
            }
        }
 
        QModelIndex oldCurrent = selectionModel()->currentIndex();
        selectionModel()->setCurrentIndex(clicked, QItemSelectionModel::NoUpdate);
        currentChanged(clicked, oldCurrent);
    } else {
        QAbstractItemView::mouseDoubleClickEvent(e);
    }
}

References KisAnimCurvesModel::CurveVisibleRole, indexAt(), indexHasKey(), and KisTimeBasedItemModel::SpecialKeyframeExists.

mouseMoveEvent()

void KisAnimCurvesView::mouseMoveEvent ( QMouseEvent * e )

overrideprotected

Definition at line 635 of file KisAnimCurvesView.cpp.

{
    if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
        if (m_d->dragPanning) {
            const int timelineScrubAmnt = m_d->panAnchor.x() - e->pos().x();
            const qreal valueScrubAmnt = m_d->verticalHeader->pixelsToValueOffset(m_d->panAnchor.y() -  e->pos().y());
 
            slotUpdateInfiniteFramesCount();
            slotUpdateHorizontalScrollbarSize();
            horizontalScrollBar()->setValue(horizontalScrollBar()->value() + timelineScrubAmnt);
 
            m_d->verticalHeader->setValueOffset(m_d->verticalHeader->valueOffset() + valueScrubAmnt);
 
            m_d->panAnchor = e->pos();
            viewport()->update();
            return;
        }
 
        if (m_d->dragZooming) {
            const qreal zoomScale = 50.0f;
            const qreal updown = ((m_d->zoomAnchor.y() - e->pos().y())) / zoomScale;
            const qreal leftright = (m_d->zoomAnchor.x() - e->pos().x()) / zoomScale;
 
            changeZoom(Qt::Vertical, updown);
            changeZoom(Qt::Horizontal, leftright * -0.5);
 
            m_d->zoomAnchor = e->pos();
            viewport()->update();
            return;
        }
 
    } else if (e->buttons() & Qt::LeftButton) {
 
        m_d->dragOffset = e->pos() - m_d->dragStart;
 
        if (m_d->isAdjustingHandle) {
            m_d->itemDelegate->setHandleAdjustment(m_d->dragOffset, m_d->adjustedHandle);
            viewport()->update();
            return;
        } else if (m_d->isDraggingKeyframe) {
            const bool axisSnap = (e->modifiers() & Qt::ShiftModifier);
            m_d->itemDelegate->setSelectedItemVisualOffset(m_d->dragOffset, axisSnap);
            viewport()->update();
            return;
        } else if (selectionModel()->hasSelection()) {
            if ((e->pos() - m_d->dragStart).manhattanLength() > QApplication::startDragDistance()) {
                m_d->isDraggingKeyframe = true;
            }
        }
    } else {
        QAbstractItemView::mouseMoveEvent(e);
    }
}

References changeZoom(), m_d, slotUpdateHorizontalScrollbarSize(), slotUpdateInfiniteFramesCount(), and value().

mousePressEvent()

void KisAnimCurvesView::mousePressEvent ( QMouseEvent * e )

overrideprotected

Definition at line 532 of file KisAnimCurvesView.cpp.

{
    if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
        if (e->button() == Qt::LeftButton) { // PAN
            m_d->dragPanning = true;
            m_d->panAnchor = e->pos();
 
        } else if (e->button() == Qt::RightButton) { // ZOOM
            m_d->dragZooming = true;
            m_d->zoomAnchor = e->pos();
        }
    } else if (e->button() == Qt::LeftButton) { // SELECT
        m_d->dragStart = e->pos();
 
        const int handleClickRadius = 16;
 
        Q_FOREACH(QModelIndex index, selectedIndexes()) {
 
            if (isIndexHidden(index)) continue;
 
            QPointF center = m_d->itemDelegate->nodeCenter(index, false);
            bool hasLeftHandle = m_d->itemDelegate->hasHandle(index, 0);
            bool hasRightHandle = m_d->itemDelegate->hasHandle(index, 1);
 
            QPointF leftHandle = center + m_d->itemDelegate->leftHandle(index, false);
            QPointF rightHandle = center + m_d->itemDelegate->rightHandle(index, false);
 
            if (hasLeftHandle && (e->localPos() - leftHandle).manhattanLength() < handleClickRadius) {
                m_d->isAdjustingHandle = true;
                m_d->adjustedHandle = 0;
                setCurrentIndex(index);
                continue;
            } else if (hasRightHandle && (e->localPos() - rightHandle).manhattanLength() < handleClickRadius) {
                m_d->isAdjustingHandle = true;
                m_d->adjustedHandle = 1;
                setCurrentIndex(index);
                continue;
            }
        }
 
    }
 
    QModelIndex clickedIndex = indexAt(e->pos());
    if(indexHasKey(clickedIndex)) {
        if ((e->modifiers() & Qt::ShiftModifier) == 0 && selectionModel()->currentIndex() != clickedIndex) {
            clearSelection();
        }
 
        if (clickedIndex == selectionModel()->currentIndex() && selectionModel()->hasSelection()) {
            m_d->deselectIntended = true;
            m_d->toDeselect = clickedIndex;
        } else {
            QModelIndex prevCurrent = selectionModel()->currentIndex();
            selectionModel()->select(clickedIndex, QItemSelectionModel::Select);
            selectionModel()->setCurrentIndex(clickedIndex, QItemSelectionModel::NoUpdate);
            Q_EMIT currentChanged(clickedIndex, prevCurrent);
        }
 
        Q_EMIT clicked(clickedIndex);
        Q_EMIT activeDataChanged(selectionModel()->currentIndex());
    } else {
        QAbstractItemView::mousePressEvent(e);
    }
}

References activeDataChanged(), indexAt(), indexHasKey(), isIndexHidden(), and m_d.

mouseReleaseEvent()

void KisAnimCurvesView::mouseReleaseEvent ( QMouseEvent * e )

overrideprotected

Definition at line 689 of file KisAnimCurvesView.cpp.

{
 
    if (e->button() == Qt::LeftButton) {
        m_d->dragPanning = false;
        m_d->dragZooming = false;
 
        if (m_d->isDraggingKeyframe) {
            const QModelIndexList indices = selectedIndexes();
            const QPointF largestOffset = qAbs(m_d->dragOffset.y()) > qAbs(m_d->dragOffset.x()) ? QPointF(0.0f, m_d->dragOffset.y()) :
                                                                                                  QPointF(m_d->dragOffset.x(), 0.0f);
 
            //Only use the largest offset when axis snap is enabled on mouse button release..
            const bool axisSnap = (e->modifiers() & Qt::ShiftModifier);
            const QPointF offset = axisSnap ? largestOffset : m_d->dragOffset;
            const int timeOffset = qRound( qreal(offset.x()) / m_d->horizontalHeader->defaultSectionSize() );
            const qreal valueOffset = m_d->verticalHeader->pixelsToValueOffset(offset.y());
 
            KisAnimCurvesModel *curvesModel = dynamic_cast<KisAnimCurvesModel*>(model());
            KIS_SAFE_ASSERT_RECOVER_RETURN(curvesModel);
            curvesModel->adjustKeyframes(indices, timeOffset, valueOffset);
 
            //Adjust selection to match new keyframe adjustment.
            Q_FOREACH(const QModelIndex& index, indices) {
                const bool wasCurrent = (index == selectionModel()->currentIndex());
                selectionModel()->select(index, QItemSelectionModel::Deselect);
                const QModelIndex newIndex = m_d->model->index(index.row(), index.column() + timeOffset);
                if (wasCurrent) {
                    selectionModel()->setCurrentIndex(newIndex, QItemSelectionModel::SelectCurrent);
                } else {
                    selectionModel()->select(newIndex, QItemSelectionModel::Select);
                }
            }
 
            m_d->isDraggingKeyframe = false;
            m_d->itemDelegate->setSelectedItemVisualOffset(QPointF());
            viewport()->update();
        } else if (m_d->isAdjustingHandle) {
            QModelIndex index = currentIndex();
            int mode = index.data(KisAnimCurvesModel::TangentsModeRole).toInt();
 
            m_d->model->beginCommand(kundo2_i18n("Adjust tangent"));
 
            if (mode == KisScalarKeyframe::Smooth) {
                QPointF leftHandle = m_d->itemDelegate->leftHandle(index, true);
                QPointF rightHandle = m_d->itemDelegate->rightHandle(index, true);
 
                QPointF leftTangent = m_d->itemDelegate->unscaledTangent(leftHandle);
                QPointF rightTangent = m_d->itemDelegate->unscaledTangent(rightHandle);
 
                model()->setData(index, leftTangent, KisAnimCurvesModel::LeftTangentRole);
                model()->setData(index, rightTangent, KisAnimCurvesModel::RightTangentRole);
            } else {
                if (m_d->adjustedHandle == 0) {
                    QPointF leftHandle = m_d->itemDelegate->leftHandle(index, true);
                    model()->setData(index, m_d->itemDelegate->unscaledTangent(leftHandle), KisAnimCurvesModel::LeftTangentRole);
                } else {
                    QPointF rightHandle = m_d->itemDelegate->rightHandle(index, true);
                    model()->setData(index, m_d->itemDelegate->unscaledTangent(rightHandle), KisAnimCurvesModel::RightTangentRole);
                }
            }
 
            m_d->model->endCommand();
 
            m_d->isAdjustingHandle = false;
            m_d->itemDelegate->setHandleAdjustment(QPointF(), m_d->adjustedHandle);
        } else {
 
            if (m_d->deselectIntended){
                selectionModel()->select(m_d->toDeselect, QItemSelectionModel::Deselect);
            }
 
        }
 
        m_d->deselectIntended = false;
        m_d->toDeselect = QModelIndex();
    }
 
    QAbstractItemView::mouseReleaseEvent(e);
}

References KisAnimCurvesModel::adjustKeyframes(), KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), KisAnimCurvesModel::LeftTangentRole, m_d, KisAnimCurvesModel::RightTangentRole, KisScalarKeyframe::Smooth, and KisAnimCurvesModel::TangentsModeRole.

moveCursor()

QModelIndex KisAnimCurvesView::moveCursor ( CursorAction cursorAction, Qt::KeyboardModifiers modifiers )

overrideprotected

Definition at line 465 of file KisAnimCurvesView.cpp.

{
    // TODO
    Q_UNUSED(cursorAction);
    Q_UNUSED(modifiers);
    return QModelIndex();
}

paintCurve()

void KisAnimCurvesView::paintCurve ( int channel, int firstFrame, int lastFrame, QPainter & painter )

private

Definition at line 301 of file KisAnimCurvesView.cpp.

{
    int selectionOffset = m_d->isDraggingKeyframe ? (m_d->dragOffset.x() / m_d->horizontalHeader->defaultSectionSize()) : 0;
 
    QModelIndex index = findNextKeyframeIndex(channel, firstFrame+1, selectionOffset, true);
    if (!index.isValid()) {
        index = findNextKeyframeIndex(channel, firstFrame, selectionOffset, false);
    }
    if (!index.isValid()) return;
 
    QPointF previousKeyPos = m_d->itemDelegate->nodeCenter(index, selectionModel()->isSelected(index));
    QPointF rightTangent = m_d->itemDelegate->rightHandle(index, index == currentIndex());
 
    while(index.column() <= lastFrame) {
        int interpolationMode = index.data(KisAnimCurvesModel::InterpolationModeRole).toInt();
 
        int time = (m_d->isDraggingKeyframe && selectionModel()->isSelected(index)) ? index.column() + selectionOffset : index.column();
        index = findNextKeyframeIndex(channel, time, selectionOffset, false);
        if (!index.isValid()) return;
 
        bool active = (index == currentIndex());
        QPointF nextKeyPos = m_d->itemDelegate->nodeCenter(index, selectionModel()->isSelected(index));
        QPointF leftTangent = m_d->itemDelegate->leftHandle(index, active);
 
        if (interpolationMode == KisScalarKeyframe::Constant) {
            painter.drawLine(previousKeyPos, QPointF(nextKeyPos.x(), previousKeyPos.y()));
        } else if (interpolationMode == KisScalarKeyframe::Linear) {
            painter.drawLine(previousKeyPos, nextKeyPos);
        } else {
            QVariant limitData = m_d->model->data(m_d->model->index(channel, index.column()), KisAnimCurvesModel::ChannelLimits);
            paintCurveSegment(painter, previousKeyPos, rightTangent, leftTangent, nextKeyPos, limitData);
        }
 
        previousKeyPos = nextKeyPos;
        rightTangent = m_d->itemDelegate->rightHandle(index, active);
    }
}

References KisAnimCurvesModel::ChannelLimits, KisScalarKeyframe::Constant, findNextKeyframeIndex(), KisAnimCurvesModel::InterpolationModeRole, KisScalarKeyframe::Linear, m_d, and paintCurveSegment().

paintCurves()

void KisAnimCurvesView::paintCurves ( QPainter & painter, int firstFrame, int lastFrame )

private

Definition at line 285 of file KisAnimCurvesView.cpp.

{
    int channels = model()->rowCount();
    for (int channel = 0; channel < channels; channel++) {
        QModelIndex index0 = model()->index(channel, 0);
 
        if (!isIndexHidden(index0)) {
            QColor color = index0.data(KisAnimCurvesModel::CurveColorRole).value<QColor>();
            painter.setPen(QPen(color, 1));
            painter.setRenderHint(QPainter::Antialiasing);
 
            paintCurve(channel, firstFrame, lastFrame, painter);
        }
    }
}

References KisAnimCurvesModel::CurveColorRole, isIndexHidden(), and paintCurve().

paintCurveSegment()

void KisAnimCurvesView::paintCurveSegment ( QPainter & painter, QPointF pos1, QPointF rightTangent, QPointF leftTangent, QPointF pos2, QVariant limitData )

private

Definition at line 339 of file KisAnimCurvesView.cpp.

                                                                                                                                                      {
    const int steps = 32;
    QPointF previousPos;
 
    for (int step = 0; step <= steps; step++) {
        qreal t = 1.0 * step / steps;
 
        QPointF nextPos = KisScalarKeyframeChannel::interpolate(pos1, rightTangent, leftTangent, pos2, t);
        if (limitData.isValid()) {
            ChannelLimitsMetatype limits = limitData.value<ChannelLimitsMetatype>();
 
            nextPos.setY(qMin(nextPos.y(), m_d->verticalHeader->valueToWidget(limits.first)));
            nextPos.setY(qMax(nextPos.y(), m_d->verticalHeader->valueToWidget(limits.second)));
        }
 
        if (step > 0) {
            painter.drawLine(previousPos, nextPos);
        }
 
        previousPos = nextPos;
    }
}

References KisScalarKeyframeChannel::interpolate(), and m_d.

paintEvent()

void KisAnimCurvesView::paintEvent ( QPaintEvent * event )

overrideprotected

Definition at line 214 of file KisAnimCurvesView.cpp.

{
    QPainter painter(viewport());
 
    QRect rect = event->rect();
    rect.translate(dirtyRegionOffset());
 
    int firstFrame = m_d->horizontalHeader->logicalIndexAt(rect.left());
    int lastFrame = m_d->horizontalHeader->logicalIndexAt(rect.right());
    if (lastFrame == -1) lastFrame = model()->columnCount();
 
    paintGrid(painter);
    paintCurves(painter, firstFrame, lastFrame);
    paintKeyframes(painter, firstFrame, lastFrame);
}

References m_d, paintCurves(), paintGrid(), and paintKeyframes().

paintGrid()

void KisAnimCurvesView::paintGrid ( QPainter & painter )

private

Definition at line 230 of file KisAnimCurvesView.cpp.

{
    const QColor backgroundColor = qApp->palette().window().color();
    const QColor textColor = qApp->palette().text().color();
    const QColor lineColor = KisPaintingTweaks::blendColors(textColor, backgroundColor, 0.1);
    const QColor zeroLineColor = qApp->palette().highlight().color();
    const QColor activeFrameColor = KisAnimTimelineColors::instance()->headerActive().color();
 
    // Draw vertical lines..
    const int visibleFrames = m_d->horizontalHeader->estimateLastVisibleColumn() - m_d->horizontalHeader->estimateFirstVisibleColumn() + 1;
    const int firstVisibleFrame = qMax( m_d->horizontalHeader->estimateFirstVisibleColumn() - 1, 0);
    for (int time = 0; time <= visibleFrames; time++) {
        QVariant data = m_d->model->headerData(firstVisibleFrame + time, Qt::Horizontal, KisTimeBasedItemModel::ActiveFrameRole);
        const bool activeFrame = data.isValid() && data.toBool();
 
        data = m_d->model->headerData(firstVisibleFrame + time, Qt::Horizontal, KisTimeBasedItemModel::WithinClipRange);
        const bool withinClipRange = data.isValid() && data.toBool();
 
        const int offsetHori = m_d->horizontalHeader ? m_d->horizontalHeader->offset() : 0;
        const int stepHori = m_d->horizontalHeader->defaultSectionSize();
        const int xPosition = stepHori * (firstVisibleFrame + time) - offsetHori;
 
        QRect frameRect = QRect(xPosition, -10, stepHori, 9999);
 
        const QPoint top = frameRect.topLeft() + 0.5 * (frameRect.topRight() - frameRect.topLeft());
        const QPoint bottom = frameRect.bottomLeft() + 0.5 * (frameRect.bottomRight() - frameRect.bottomLeft());
 
        QColor fadedLineColor = lineColor;
        fadedLineColor.setAlphaF(0.33);
 
        QColor finalColor = withinClipRange ? lineColor : fadedLineColor;
        finalColor = activeFrame ? activeFrameColor : finalColor;
 
        painter.setPen(finalColor);
        painter.drawLine(top, bottom);
    }
 
    // Draw horizontal lines..
    const int visibleSteps = m_d->verticalHeader->visibleValueDifference() / m_d->verticalHeader->step();
    const qreal stepAmount = m_d->verticalHeader->step();
    for (int step = 0; step <= visibleSteps; step++) {
        const qreal value = m_d->verticalHeader->firstVisibleStep() + stepAmount * step;
        const int CORRECTION = -1;
        int yPosition = m_d->verticalHeader->valueToWidget(value);
 
        QRect frameRect = QRect(-10, yPosition + CORRECTION, 9999, 1);
 
        const QPoint left = frameRect.topLeft();
        const QPoint right = frameRect.topRight();
 
        painter.setPen(value == 0 ? zeroLineColor : lineColor);
        painter.drawLine(left, right);
    }
}

References KisTimeBasedItemModel::ActiveFrameRole, KisPaintingTweaks::blendColors(), KisAnimTimelineColors::headerActive(), KisAnimTimelineColors::instance(), m_d, value(), and KisTimeBasedItemModel::WithinClipRange.

paintKeyframes()

void KisAnimCurvesView::paintKeyframes ( QPainter & painter, int firstFrame, int lastFrame )

private

Definition at line 362 of file KisAnimCurvesView.cpp.

{
    int channels = model()->rowCount();
    for (int channel = 0; channel < channels; channel++) {
        for (int time=firstFrame; time <= lastFrame; time++) {
            QModelIndex index = model()->index(channel, time);
            bool keyframeExists = model()->data(index, KisAnimCurvesModel::SpecialKeyframeExists).toReal();
 
            if (keyframeExists && !isIndexHidden(index)) {
                QStyleOptionViewItem opt;
 
                if (selectionModel()->isSelected(index)) {
                    opt.state |= QStyle::State_Selected;
                }
 
                if (index == selectionModel()->currentIndex()) {
                    opt.state |= QStyle::State_HasFocus;
                }
 
                m_d->itemDelegate->paint(&painter, opt, index);
            }
        }
    }
}

References isIndexHidden(), m_d, and KisTimeBasedItemModel::SpecialKeyframeExists.

removeKeyframes

void KisAnimCurvesView::removeKeyframes ( )

slot

Definition at line 951 of file KisAnimCurvesView.cpp.

{
    m_d->model->removeFrames(selectedIndexes());
}

References m_d.

scrollContentsBy()

void KisAnimCurvesView::scrollContentsBy ( int dx, int dy )

overrideprotected

Definition at line 770 of file KisAnimCurvesView.cpp.

{
    scrollDirtyRegion(dx, dy);
    viewport()->scroll(dx, dy);
    viewport()->update();
}

scrollTo()

void KisAnimCurvesView::scrollTo ( const QModelIndex & index, ScrollHint hint )

override

Definition at line 184 of file KisAnimCurvesView.cpp.

{
    // TODO
    Q_UNUSED(index);
    Q_UNUSED(hint);
}

setModel()

void KisAnimCurvesView::setModel ( QAbstractItemModel * model )

override

Definition at line 147 of file KisAnimCurvesView.cpp.

{
    m_d->model = dynamic_cast<KisAnimCurvesModel*>(model);
 
    QAbstractItemView::setModel(model);
    m_d->horizontalHeader->setModel(model);
 
    connect(model, &QAbstractItemModel::rowsInserted,
            this, &KisAnimCurvesView::slotRowsChanged);
 
    connect(model, &QAbstractItemModel::rowsRemoved,
            this, &KisAnimCurvesView::slotRowsChanged);
 
    connect(model, &QAbstractItemModel::dataChanged,
            this, &KisAnimCurvesView::slotDataChanged);
 
    connect(model, &QAbstractItemModel::headerDataChanged,
            this, &KisAnimCurvesView::slotHeaderDataChanged);
 
    connect(selectionModel(), &QItemSelectionModel::selectionChanged,
        [this](const QItemSelection& newSelection, const QItemSelection& /*oldSelection*/) {
            if (newSelection.count() == 0) {
                activeDataChanged(QModelIndex());
            } else {
                activeDataChanged(selectionModel()->currentIndex());
            }
        });
 
    connect(m_d->model, &KisAnimCurvesModel::dataAdded,
            this, &KisAnimCurvesView::slotDataAdded);
}

References KisAnimCurvesModel::dataAdded(), m_d, slotDataAdded(), slotDataChanged(), slotHeaderDataChanged(), and slotRowsChanged().

setSelection()

void KisAnimCurvesView::setSelection ( const QRect & rect, QItemSelectionModel::SelectionFlags flags )

overrideprotected

Definition at line 488 of file KisAnimCurvesView.cpp.

{
    int timeFrom = m_d->horizontalHeader->logicalIndexAt(rect.left());
    int timeTo = m_d->horizontalHeader->logicalIndexAt(rect.right());
 
    QItemSelection selection;
 
    int rows = model()->rowCount();
    for (int row=0; row < rows; row++) {
        for (int time = timeFrom; time <= timeTo; time++) {
 
            QModelIndex index = model()->index(row, time);
 
            if (isIndexHidden(index)) continue;
 
            if (index.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool()) {
                QRect itemRect = m_d->itemDelegate->itemRect(index);
 
                if (itemRect.intersects(rect)) {
                    selection.select(index, index);
                }
            }
        }
    }
 
    if (!selection.contains(selectionModel()->currentIndex()) && selection.size() > 0) {
        selectionModel()->setCurrentIndex(selection.first().topLeft(), flags);
    }
 
    selectionModel()->select(selection, flags);
    activated(selectionModel()->currentIndex());
}

References isIndexHidden(), m_d, and KisTimeBasedItemModel::SpecialKeyframeExists.

slotDataAdded

void KisAnimCurvesView::slotDataAdded ( const QModelIndex & index )

privateslot

Definition at line 829 of file KisAnimCurvesView.cpp.

{
    const qreal lastVisibleValue = m_d->verticalHeader->visibleValueMax();
    const qreal firstVisibleValue = m_d->verticalHeader->visibleValueMin();
 
    qreal value = index.data(KisAnimCurvesModel::ScalarValueRole).toReal();
    if ( value < firstVisibleValue || value > lastVisibleValue) {
        qreal min, max;
        findExtremes(&min, &max);
        qreal padding = (max - min) * 0.1;
        m_d->verticalHeader->zoomToFitRange(min - padding, max + padding);
        viewport()->update();
    }
 
    selectionModel()->clear();
    selectionModel()->setCurrentIndex(index, QItemSelectionModel::SelectCurrent);
}

References findExtremes(), m_d, KisAnimCurvesModel::ScalarValueRole, and value().

slotDataChanged

void KisAnimCurvesView::slotDataChanged ( const QModelIndex & topLeft, const QModelIndex & bottomRight )

privateslot

Definition at line 811 of file KisAnimCurvesView.cpp.

{
    Q_UNUSED(topLeft);
    Q_UNUSED(bottomRight);
 
    viewport()->update();
 
    // this forces the horizontal ruler to refresh. Repaint() doesn't do it for some reason
    // If you remove this, scrubbing the timeline will probably stop updating the indicator
    m_d->horizontalHeader->resize(m_d->horizontalHeader->width()-1, m_d->horizontalHeader->height());
    m_d->horizontalHeader->resize(m_d->horizontalHeader->width()+1, m_d->horizontalHeader->height());
 
    if (selectionModel()->selection().count() != 0 &&
        selectionModel()->currentIndex().isValid()) {
        Q_EMIT activeDataChanged(selectionModel()->currentIndex());
    }
}

References activeDataChanged(), and m_d.

slotHeaderDataChanged

void KisAnimCurvesView::slotHeaderDataChanged ( Qt::Orientation orientation, int first, int last )

privateslot

Definition at line 847 of file KisAnimCurvesView.cpp.

{
    Q_UNUSED(orientation);
    Q_UNUSED(first);
    Q_UNUSED(last);
    viewport()->update();
}

slotRowsChanged

void KisAnimCurvesView::slotRowsChanged ( const QModelIndex & parentIndex, int first, int last )

privateslot

Definition at line 802 of file KisAnimCurvesView.cpp.

{
    Q_UNUSED(parentIndex);
    Q_UNUSED(first);
    Q_UNUSED(last);
    zoomToFitChannel();
    viewport()->update();
}

References zoomToFitChannel().

slotScrollerStateChanged

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

inlineslot

Definition at line 63 of file KisAnimCurvesView.h.

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

References KisKineticScroller::updateCursor().

slotUpdateHorizontalScrollbarSize

void KisAnimCurvesView::slotUpdateHorizontalScrollbarSize ( )

privateslot

Definition at line 863 of file KisAnimCurvesView.cpp.

{
    if (m_d->model) {
        const int lastColumn = qMax( m_d->horizontalHeader->estimateLastVisibleColumn(), m_d->model->columnCount());
        const int numberOfColumnsOnScreen = lastColumn - m_d->horizontalHeader->estimateFirstVisibleColumn();
        const int overallSize = lastColumn * m_d->horizontalHeader->defaultSectionSize();
        const int pageStep = overallSize * (qreal(numberOfColumnsOnScreen) / lastColumn);
        horizontalScrollBar()->setRange(0, overallSize + pageStep);
        horizontalScrollBar()->setPageStep(pageStep);
    }
}

References m_d.

slotUpdateInfiniteFramesCount

void KisAnimCurvesView::slotUpdateInfiniteFramesCount ( )

privateslot

Definition at line 855 of file KisAnimCurvesView.cpp.

{
    if (m_d->model) {
        const int lastColumn = m_d->horizontalHeader->estimateLastVisibleColumn();
        m_d->model->setLastVisibleFrame(lastColumn);
    }
}

References m_d.

updateGeometries

void KisAnimCurvesView::updateGeometries ( )

overrideprotectedslot

Definition at line 783 of file KisAnimCurvesView.cpp.

{
    int topMargin = qMax(m_d->horizontalHeader->minimumHeight(),
                         m_d->horizontalHeader->sizeHint().height());
 
    int leftMargin = m_d->verticalHeader->sizeHint().width();
 
    setViewportMargins(leftMargin, topMargin, 0, 0);
 
    QRect viewRect = viewport()->geometry();
    m_d->horizontalHeader->setGeometry(leftMargin, 0, viewRect.width(), topMargin);
    m_d->verticalHeader->setGeometry(0, topMargin, leftMargin, viewRect.height());
    if (m_d->model) {
        slotUpdateInfiniteFramesCount();
    }
 
    QAbstractItemView::updateGeometries();
}

References m_d, and slotUpdateInfiniteFramesCount().

verticalOffset()

int KisAnimCurvesView::verticalOffset ( ) const

overrideprotected

Definition at line 478 of file KisAnimCurvesView.cpp.

{
    return m_d->verticalHeader->valueOffset();
}

References m_d.

visualRect()

QRect KisAnimCurvesView::visualRect ( const QModelIndex & index ) const

override

Definition at line 179 of file KisAnimCurvesView.cpp.

{
    return m_d->itemDelegate->itemRect(index);
}

References m_d.

visualRegionForSelection()

QRegion KisAnimCurvesView::visualRegionForSelection ( const QItemSelection & selection ) const

overrideprotected

Definition at line 521 of file KisAnimCurvesView.cpp.

{
    QRegion region;
 
    Q_FOREACH(QModelIndex index, selection.indexes()) {
        region += m_d->itemDelegate->visualRect(index);
    }
 
    return region;
}

References m_d.

zoomToFitChannel

void KisAnimCurvesView::zoomToFitChannel ( )

slot

Definition at line 969 of file KisAnimCurvesView.cpp.

{
    if (!model()) return;
 
    const int channels = model()->rowCount();
 
    qreal min = 0;
    qreal max = min;
 
    for (int channel = 0; channel < channels; channel++) {
        QModelIndex index = m_d->model->index(channel, 0);
        QVariant variant = m_d->model->data(index, KisAnimCurvesModel::ChannelLimits);
 
        if (!variant.isValid())
            continue;
 
        ChannelLimitsMetatype limits = variant.value<ChannelLimitsMetatype>();
        min = qMin(limits.first, min);
        max = qMax(limits.second, max);
    }
 
    if (min == max)
    {
        zoomToFitCurve();
        return;
    }
 
    const qreal padding = (max - min) * 0.1;
    m_d->verticalHeader->zoomToFitRange(min - padding, max + padding);
    viewport()->update();
}

References KisAnimCurvesModel::ChannelLimits, m_d, and zoomToFitCurve().

zoomToFitCurve

void KisAnimCurvesView::zoomToFitCurve ( )

slot

Definition at line 957 of file KisAnimCurvesView.cpp.

{
    if (!model()) return;
 
    qreal min, max;
    findExtremes(&min, &max);
 
    const qreal padding = (min != max) ? (max - min) * 0.1 : 10.0f;
    m_d->verticalHeader->zoomToFitRange(min - padding, max + padding);
    viewport()->update();
}

References findExtremes(), and m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisAnimCurvesView::m_d

private

Definition at line 78 of file KisAnimCurvesView.h.

---

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

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