KisAnimTimelineTimeHeader Class Reference

#include <KisAnimTimelineTimeHeader.h>

Inheritance diagram for KisAnimTimelineTimeHeader:

Classes
struct	Private

Public Slots
void	slotSaveThrottle (qreal value)

Signals
void	sigClearCache ()
void	sigCopyColumns ()
void	sigCutColumns ()
void	sigInsertColumnLeft ()
void	sigInsertColumnRight ()
void	sigInsertHoldColumns ()
void	sigInsertHoldColumnsCustom ()
void	sigInsertMultipleColumns ()
void	sigMirrorColumns ()
void	sigPasteColumns ()
void	sigRemoveColumns ()
void	sigRemoveColumnsAndShift ()
void	sigRemoveHoldColumns ()
void	sigRemoveHoldColumnsCustom ()
void	sigZoomChanged (qreal zoom)

Public Member Functions
int	estimateFirstVisibleColumn ()
int	estimateLastVisibleColumn ()
	KisAnimTimelineTimeHeader (QWidget *parent=0)
void	mouseMoveEvent (QMouseEvent *e) override
void	setActionManager (KisActionManager *actionManager)
void	setFramePerSecond (int fps)
void	setModel (QAbstractItemModel *model) override
void	setPixelOffset (qreal offset)
bool	setZoom (qreal zoomLevel)
qreal	zoom ()
void	zoomToFitFrameRange (int start, int end)
	~KisAnimTimelineTimeHeader () override

Protected Member Functions
void	changeEvent (QEvent *event) override
void	mousePressEvent (QMouseEvent *e) override
void	mouseReleaseEvent (QMouseEvent *e) override
void	paintEvent (QPaintEvent *e) override
void	paintSection (QPainter *painter, const QRect &rect, int logicalIndex) const override
void	paintSection1 (QPainter *painter, const QRect &rect, int logicalIndex) const

Private Member Functions
void	paintSpan (QPainter *painter, int userFrameId, const QRect &spanRect, bool isIntegralLine, bool isPrevIntegralLine, QStyle *style, const QPalette &palette, const QPen &gridPen) const
void	updateMinimumSize ()

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 18 of file KisAnimTimelineTimeHeader.h.

Constructor & Destructor Documentation

KisAnimTimelineTimeHeader()

KisAnimTimelineTimeHeader::KisAnimTimelineTimeHeader

(

QWidget *

parent = 0

)

Definition at line 66 of file KisAnimTimelineTimeHeader.cpp.

    : QHeaderView(Qt::Horizontal, parent)
    , m_d(new Private)
{
    setSectionResizeMode(QHeaderView::Fixed);
    setDefaultSectionSize(18);
    setMinimumSectionSize(8);
}

~KisAnimTimelineTimeHeader()

KisAnimTimelineTimeHeader::~KisAnimTimelineTimeHeader ( )

override

Definition at line 75 of file KisAnimTimelineTimeHeader.cpp.

{
}

Member Function Documentation

changeEvent()

void KisAnimTimelineTimeHeader::changeEvent ( QEvent * event )

overrideprotected

Definition at line 400 of file KisAnimTimelineTimeHeader.cpp.

{
    Q_UNUSED(event);
 
    updateMinimumSize();
}

References updateMinimumSize().

estimateFirstVisibleColumn()

int KisAnimTimelineTimeHeader::estimateFirstVisibleColumn

(

)

Definition at line 595 of file KisAnimTimelineTimeHeader.cpp.

{
    const int sectionWidth = defaultSectionSize();
    return ceil(qreal(m_d->offset) / sectionWidth);
}

References m_d.

estimateLastVisibleColumn()

int KisAnimTimelineTimeHeader::estimateLastVisibleColumn

(

)

Definition at line 589 of file KisAnimTimelineTimeHeader.cpp.

{
    const int sectionWidth = defaultSectionSize();
    return (m_d->offset + width() - 1) / sectionWidth;
}

References m_d.

mouseMoveEvent()

void KisAnimTimelineTimeHeader::mouseMoveEvent ( QMouseEvent * e )

override

Definition at line 554 of file KisAnimTimelineTimeHeader.cpp.

{
    int logical = logicalIndexAt(e->pos());
    if (logical != -1) {
 
        if (e->buttons() & Qt::LeftButton) {
 
            m_d->model->setScrubState(true);
            QVariant activeValue = model()->headerData(logical, orientation(), KisTimeBasedItemModel::ActiveFrameRole);
            KIS_ASSERT(activeValue.type() == QVariant::Bool);
            if (activeValue.toBool() != true) {
                model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
                model()->setHeaderData(logical, orientation(), QVariant(int(SEEK_PUSH_AUDIO)), KisTimeBasedItemModel::ScrubToRole);
            }
 
            if (m_d->lastPressSectionIndex >= 0 &&
                logical != m_d->lastPressSectionIndex &&
                e->modifiers() & Qt::ShiftModifier) {
 
                const int minCol = qMin(m_d->lastPressSectionIndex, logical);
                const int maxCol = qMax(m_d->lastPressSectionIndex, logical);
 
                QItemSelection sel(m_d->model->index(0, minCol), m_d->model->index(0, maxCol));
                selectionModel()->select(sel,
                                         QItemSelectionModel::Columns |
                                         QItemSelectionModel::SelectCurrent);
            }
 
        }
 
    }
 
    QHeaderView::mouseMoveEvent(e);
}

References KisTimeBasedItemModel::ActiveFrameRole, KIS_ASSERT, m_d, KisTimeBasedItemModel::ScrubToRole, and SEEK_PUSH_AUDIO.

mousePressEvent()

void KisAnimTimelineTimeHeader::mousePressEvent ( QMouseEvent * e )

overrideprotected

Definition at line 476 of file KisAnimTimelineTimeHeader.cpp.

{
    int logical = logicalIndexAt(e->pos());
    if (logical != -1) {
        QModelIndexList selectedIndexes = selectionModel()->selectedIndexes();
        int numSelectedColumns = getColumnCount(selectedIndexes, 0, 0);
 
        if (e->button() == Qt::RightButton) {
            if (numSelectedColumns <= 1) {
                model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
                model()->setHeaderData(logical, orientation(), QVariant(int(SEEK_FINALIZE | SEEK_PUSH_AUDIO)), KisTimeBasedItemModel::ScrubToRole);
            }
 
            /* Fix for safe-assert involving kis_animation_curve_docker.
             * There should probably be a more elegant way for dealing
             * with reused timeline_ruler_header instances in other
             * timeline views instead of simply animation_frame_view.
             *
             * This works for now though... */
            if(!m_d->actionMan){
                return;
            }
 
            QMenu menu;
 
            menu.addSection(i18n("Edit Columns:"));
            menu.addSeparator();
 
            KisActionManager::safePopulateMenu(&menu, "cut_columns_to_clipboard", m_d->actionMan);
            KisActionManager::safePopulateMenu(&menu, "copy_columns_to_clipboard", m_d->actionMan);
            KisActionManager::safePopulateMenu(&menu, "paste_columns_from_clipboard", m_d->actionMan);
 
            menu.addSeparator();
 
            {   //Frame Columns Submenu
                QMenu *frames = menu.addMenu(i18nc("@item:inmenu", "Keyframe Columns"));
                KisActionManager::safePopulateMenu(frames, "insert_column_left", m_d->actionMan);
                KisActionManager::safePopulateMenu(frames, "insert_column_right", m_d->actionMan);
                frames->addSeparator();
                KisActionManager::safePopulateMenu(frames, "insert_multiple_columns", m_d->actionMan);
            }
 
            {   //Hold Columns Submenu
                QMenu *hold = menu.addMenu(i18nc("@item:inmenu", "Hold Frame Columns"));
                KisActionManager::safePopulateMenu(hold, "insert_hold_column", m_d->actionMan);
                KisActionManager::safePopulateMenu(hold, "remove_hold_column", m_d->actionMan);
                hold->addSeparator();
                KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_columns", m_d->actionMan);
                KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_columns", m_d->actionMan);
            }
 
            menu.addSeparator();
 
            KisActionManager::safePopulateMenu(&menu, "remove_columns", m_d->actionMan);
            KisActionManager::safePopulateMenu(&menu, "remove_columns_and_pull", m_d->actionMan);
 
            if (numSelectedColumns > 1) {
                menu.addSeparator();
                KisActionManager::safePopulateMenu(&menu, "mirror_columns", m_d->actionMan);
            }
 
            menu.addSeparator();
 
            KisActionManager::safePopulateMenu(&menu, "clear_animation_cache", m_d->actionMan);
 
            menu.exec(e->globalPos());
 
            return;
 
        } else if (e->button() == Qt::LeftButton) {
            m_d->lastPressSectionIndex = logical;
            model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
        }
    }
 
    QHeaderView::mousePressEvent(e);
}

References KisTimeBasedItemModel::ActiveFrameRole, getColumnCount(), m_d, KisActionManager::safePopulateMenu(), KisTimeBasedItemModel::ScrubToRole, SEEK_FINALIZE, and SEEK_PUSH_AUDIO.

mouseReleaseEvent()

void KisAnimTimelineTimeHeader::mouseReleaseEvent ( QMouseEvent * e )

overrideprotected

Definition at line 610 of file KisAnimTimelineTimeHeader.cpp.

{
    if (!m_d->model)
        return;
 
    if (e->button() == Qt::LeftButton) {
        int timeUnderMouse = qMax(logicalIndexAt(e->pos()), 0);
        model()->setHeaderData(timeUnderMouse, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
        if (timeUnderMouse != m_d->model->currentTime()) {
            model()->setHeaderData(timeUnderMouse, orientation(), QVariant(int(SEEK_PUSH_AUDIO | SEEK_FINALIZE)), KisTimeBasedItemModel::ScrubToRole);
        }
        m_d->model->setScrubState(false);
    }
 
    QHeaderView::mouseReleaseEvent(e);
}

References KisTimeBasedItemModel::ActiveFrameRole, m_d, KisTimeBasedItemModel::ScrubToRole, SEEK_FINALIZE, and SEEK_PUSH_AUDIO.

paintEvent()

void KisAnimTimelineTimeHeader::paintEvent ( QPaintEvent * e )

overrideprotected

Krita specific code. We should update in spans!

End of Krita specific code

Definition at line 144 of file KisAnimTimelineTimeHeader.cpp.

{
    QHeaderView::paintEvent(e);
 
    // Copied from Qt 4.8...
 
    if (count() == 0)
        return;
 
    QPainter painter(viewport());
    const QPoint offset = dirtyRegionOffset();
    QRect translatedEventRect = e->rect();
    translatedEventRect.translate(offset);
 
    int start = -1;
    int end = -1;
    if (orientation() == Qt::Horizontal) {
        start = visualIndexAt(translatedEventRect.left());
        end = visualIndexAt(translatedEventRect.right());
    } else {
        start = visualIndexAt(translatedEventRect.top());
        end = visualIndexAt(translatedEventRect.bottom());
    }
 
    const bool reverseImpl = orientation() == Qt::Horizontal && isRightToLeft();
 
    if (reverseImpl) {
        start = (start == -1 ? count() - 1 : start);
        end = (end == -1 ? 0 : end);
    } else {
        start = (start == -1 ? 0 : start);
        end = (end == -1 ? count() - 1 : end);
    }
 
    int tmp = start;
    start = qMin(start, end);
    end = qMax(tmp, end);
 
 
    const int spanStart = start - start % m_d->fps;
    const int spanEnd = end - end % m_d->fps + m_d->fps - 1;
 
    start = spanStart;
    end = qMin(count() - 1, spanEnd);
 
 
    QRect currentSectionRect;
    int logical;
    const int width = viewport()->width();
    const int height = viewport()->height();
 
    for (int i = start; i <= end; ++i) {
        // DK: cannot copy-paste easily...
        // if (d->isVisualIndexHidden(i))
        //     continue;
        painter.save();
        logical = logicalIndex(i);
        if (orientation() == Qt::Horizontal) {
            currentSectionRect.setRect(sectionViewportPosition(logical), 0, sectionSize(logical), height);
        } else {
            currentSectionRect.setRect(0, sectionViewportPosition(logical), width, sectionSize(logical));
        }
        currentSectionRect.translate(offset);
 
        QVariant variant = model()->headerData(logical, orientation(),
                                                Qt::FontRole);
        if (variant.isValid() && variant.canConvert<QFont>()) {
            QFont sectionFont = qvariant_cast<QFont>(variant);
            painter.setFont(sectionFont);
        }
        paintSection1(&painter, currentSectionRect, logical);
        painter.restore();
    }
}

References m_d, and paintSection1().

paintSection()

void KisAnimTimelineTimeHeader::paintSection ( QPainter * painter, const QRect & rect, int logicalIndex ) const

overrideprotected

Definition at line 223 of file KisAnimTimelineTimeHeader.cpp.

{
    // Base paint event should paint nothing in the sections area
 
    Q_UNUSED(painter);
    Q_UNUSED(rect);
    Q_UNUSED(logicalIndex);
}

paintSection1()

void KisAnimTimelineTimeHeader::paintSection1 ( QPainter * painter, const QRect & rect, int logicalIndex ) const

protected

Definition at line 324 of file KisAnimTimelineTimeHeader.cpp.

{
 
    if (!rect.isValid())
        return;
 
    QFontMetrics metrics(this->font());
    const int textHeight = metrics.height();
 
    QPoint p1 = rect.topLeft() + QPoint(0, textHeight);
    QPoint p2 = rect.topRight() + QPoint(0, textHeight);
 
    QRect frameRect = QRect(p1, QSize(rect.width(), rect.height() - textHeight));
 
    const int width = rect.width();
 
    int spanWidth = m_d->calcSpanWidth(width);
 
    const int internalIndex = logicalIndex % spanWidth;
    const int userFrameId = logicalIndex;
 
    const int spanEnd = qMin(count(), logicalIndex + spanWidth);
    QRect spanRect(rect.topLeft(), QSize(width * (spanEnd - logicalIndex), textHeight));
 
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QStyleOptionViewItem option = viewOptions();
#else
    QStyleOptionViewItem option;
    initViewItemOption(&option);
#endif
    const int gridHint = style()->styleHint(QStyle::SH_Table_GridLineColor, &option, this);
    const QColor gridColor = static_cast<QRgb>(gridHint);
    const QPen gridPen = QPen(gridColor);
 
    if (!internalIndex) {
        bool isIntegralLine = (logicalIndex + spanWidth) % m_d->fps == 0;
        bool isPrevIntegralLine = logicalIndex % m_d->fps == 0;
        paintSpan(painter, userFrameId, spanRect, isIntegralLine, isPrevIntegralLine, style(), palette(), gridPen);
    }
 
    {
        QBrush fillColor = KisAnimTimelineColors::instance()->headerEmpty();
 
        QVariant activeValue = model()->headerData(logicalIndex, orientation(),
                                                   KisTimeBasedItemModel::ActiveFrameRole);
 
        QVariant cachedValue = model()->headerData(logicalIndex, orientation(),
                                                   KisTimeBasedItemModel::FrameCachedRole);
 
        QVariant withinRangeValue = model()->headerData(logicalIndex, orientation(),
                                                        KisTimeBasedItemModel::WithinClipRange);
 
        const bool isActive = activeValue.isValid() && activeValue.toBool();
        const bool isCached = cachedValue.isValid() && cachedValue.toBool();
        const bool isWithinRange = withinRangeValue.isValid() && withinRangeValue.toBool();
 
        if (isActive) {
            fillColor = KisAnimTimelineColors::instance()->headerActive();
        } else if (isCached && isWithinRange) {
            fillColor = KisAnimTimelineColors::instance()->headerCachedFrame();
        }
 
        painter->fillRect(frameRect, fillColor);
 
        QVector<QLine> lines;
        lines << QLine(p1, p2);
        lines << QLine(frameRect.topRight(), frameRect.bottomRight());
        lines << QLine(frameRect.bottomLeft(), frameRect.bottomRight());
 
        QPen oldPen = painter->pen();
        painter->setPen(gridPen);
        painter->drawLines(lines);
        painter->setPen(oldPen);
    }
}

References KisTimeBasedItemModel::ActiveFrameRole, KisTimeBasedItemModel::FrameCachedRole, KisAnimTimelineColors::headerActive(), KisAnimTimelineColors::headerCachedFrame(), KisAnimTimelineColors::headerEmpty(), KisAnimTimelineColors::instance(), m_d, p1, p2, paintSpan(), palette, and KisTimeBasedItemModel::WithinClipRange.

paintSpan()

void KisAnimTimelineTimeHeader::paintSpan ( QPainter * painter, int userFrameId, const QRect & spanRect, bool isIntegralLine, bool isPrevIntegralLine, QStyle * style, const QPalette & palette, const QPen & gridPen ) const

private

Definition at line 232 of file KisAnimTimelineTimeHeader.cpp.

{
    painter->fillRect(spanRect, palette.brush(QPalette::Button));
 
    int safeRight = spanRect.right();
 
    QPen oldPen = painter->pen();
    painter->setPen(gridPen);
 
    int adjustedTop = spanRect.top() + (!isIntegralLine ? spanRect.height() / 2 : 0);
    painter->drawLine(safeRight, adjustedTop, safeRight, spanRect.bottom());
 
    if (isPrevIntegralLine) {
        painter->drawLine(spanRect.left() + 1, spanRect.top(), spanRect.left() + 1, spanRect.bottom());
    }
 
    painter->setPen(oldPen);
 
    QString frameIdText = QString::number(userFrameId);
    QRect textRect(spanRect.topLeft() + QPoint(2, 0), QSize(spanRect.width() - 2, spanRect.height()));
 
    QStyleOptionHeader opt;
    initStyleOption(&opt);
 
    QStyle::State state = QStyle::State_None;
    if (isEnabled())
        state |= QStyle::State_Enabled;
    if (window()->isActiveWindow())
        state |= QStyle::State_Active;
    opt.state |= state;
    opt.selectedPosition = QStyleOptionHeader::NotAdjacent;
 
    opt.textAlignment = Qt::AlignLeft | Qt::AlignTop;
    opt.rect = textRect;
    opt.text = frameIdText;
    style->drawControl(QStyle::CE_HeaderLabel, &opt, painter, this);
}

References palette.

setActionManager()

void KisAnimTimelineTimeHeader::setActionManager

(

KisActionManager *

actionManager

)

Definition at line 86 of file KisAnimTimelineTimeHeader.cpp.

{
    m_d->actionMan = actionManager;
 
    disconnect(this, &KisAnimTimelineTimeHeader::sigZoomChanged, this, &KisAnimTimelineTimeHeader::slotSaveThrottle);
 
    if (actionManager) {
        KisAction *action;
 
        action = actionManager->createAction("insert_column_left");
        connect(action, SIGNAL(triggered()), SIGNAL(sigInsertColumnLeft()));
 
        action = actionManager->createAction("insert_column_right");
        connect(action, SIGNAL(triggered()), SIGNAL(sigInsertColumnRight()));
 
        action = actionManager->createAction("insert_multiple_columns");
        connect(action, SIGNAL(triggered()), SIGNAL(sigInsertMultipleColumns()));
 
        action = actionManager->createAction("remove_columns_and_pull");
        connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveColumnsAndShift()));
 
        action = actionManager->createAction("remove_columns");
        connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveColumns()));
 
        action = actionManager->createAction("insert_hold_column");
        connect(action, SIGNAL(triggered()), SIGNAL(sigInsertHoldColumns()));
 
        action = actionManager->createAction("insert_multiple_hold_columns");
        connect(action, SIGNAL(triggered()), SIGNAL(sigInsertHoldColumnsCustom()));
 
        action = actionManager->createAction("remove_hold_column");
        connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveHoldColumns()));
 
        action = actionManager->createAction("remove_multiple_hold_columns");
        connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveHoldColumnsCustom()));
 
        action = actionManager->createAction("mirror_columns");
        connect(action, SIGNAL(triggered()), SIGNAL(sigMirrorColumns()));
 
        action = actionManager->createAction("clear_animation_cache");
        connect(action, SIGNAL(triggered()), SIGNAL(sigClearCache()));
 
        action = actionManager->createAction("copy_columns_to_clipboard");
        connect(action, SIGNAL(triggered()), SIGNAL(sigCopyColumns()));
 
        action = actionManager->createAction("cut_columns_to_clipboard");
        connect(action, SIGNAL(triggered()), SIGNAL(sigCutColumns()));
 
        action = actionManager->createAction("paste_columns_from_clipboard");
        connect(action, SIGNAL(triggered()), SIGNAL(sigPasteColumns()));
 
        KisConfig cfg(true);
        setZoom(cfg.timelineZoom());
        connect(this, &KisAnimTimelineTimeHeader::sigZoomChanged, this, &KisAnimTimelineTimeHeader::slotSaveThrottle);
    }
}

References connect(), KisActionManager::createAction(), m_d, setZoom(), sigClearCache(), sigCopyColumns(), sigCutColumns(), sigInsertColumnLeft(), sigInsertColumnRight(), sigInsertHoldColumns(), sigInsertHoldColumnsCustom(), sigInsertMultipleColumns(), sigMirrorColumns(), sigPasteColumns(), sigRemoveColumns(), sigRemoveColumnsAndShift(), sigRemoveHoldColumns(), sigRemoveHoldColumnsCustom(), sigZoomChanged(), slotSaveThrottle(), and KisConfig::timelineZoom().

setFramePerSecond()

void KisAnimTimelineTimeHeader::setFramePerSecond

(

int

fps

)

Definition at line 407 of file KisAnimTimelineTimeHeader.cpp.

{
    m_d->fps = fps;
    update();
}

References m_d.

setModel()

void KisAnimTimelineTimeHeader::setModel ( QAbstractItemModel * model )

override

Definition at line 448 of file KisAnimTimelineTimeHeader.cpp.

{
    KisTimeBasedItemModel *framesModel = qobject_cast<KisTimeBasedItemModel*>(model);
    m_d->model = framesModel;
 
    QHeaderView::setModel(model);
}

References m_d.

setPixelOffset()

void KisAnimTimelineTimeHeader::setPixelOffset

(

qreal

offset

)

Definition at line 79 of file KisAnimTimelineTimeHeader.cpp.

{
    m_d->offset = qMax(offset, qreal(0.f));
    setOffset(m_d->offset);
    viewport()->update();
}

References m_d.

setZoom()

bool KisAnimTimelineTimeHeader::setZoom

(

qreal

zoomLevel

)

Definition at line 413 of file KisAnimTimelineTimeHeader.cpp.

{
    qreal newSectionSize = zoom * m_d->unitSectionSize;
 
    if (newSectionSize < m_d->minSectionSize) {
        newSectionSize = m_d->minSectionSize;
        zoom = qreal(newSectionSize) / m_d->unitSectionSize;
    } else if (newSectionSize > m_d->maxSectionSize) {
        newSectionSize = m_d->maxSectionSize;
        zoom = qreal(newSectionSize) / m_d->unitSectionSize;
    }
 
    m_d->remainder = newSectionSize - floor(newSectionSize);
 
    if (newSectionSize != defaultSectionSize()) {
        setDefaultSectionSize(newSectionSize);
        Q_EMIT sigZoomChanged(zoom);
        return true;
    }
 
    return false;
}

References m_d, sigZoomChanged(), and zoom().

sigClearCache

void KisAnimTimelineTimeHeader::sigClearCache ( )

signal

sigCopyColumns

void KisAnimTimelineTimeHeader::sigCopyColumns ( )

signal

sigCutColumns

void KisAnimTimelineTimeHeader::sigCutColumns ( )

signal

sigInsertColumnLeft

void KisAnimTimelineTimeHeader::sigInsertColumnLeft ( )

signal

sigInsertColumnRight

void KisAnimTimelineTimeHeader::sigInsertColumnRight ( )

signal

sigInsertHoldColumns

void KisAnimTimelineTimeHeader::sigInsertHoldColumns ( )

signal

sigInsertHoldColumnsCustom

void KisAnimTimelineTimeHeader::sigInsertHoldColumnsCustom ( )

signal

sigInsertMultipleColumns

void KisAnimTimelineTimeHeader::sigInsertMultipleColumns ( )

signal

sigMirrorColumns

void KisAnimTimelineTimeHeader::sigMirrorColumns ( )

signal

sigPasteColumns

void KisAnimTimelineTimeHeader::sigPasteColumns ( )

signal

sigRemoveColumns

void KisAnimTimelineTimeHeader::sigRemoveColumns ( )

signal

sigRemoveColumnsAndShift

void KisAnimTimelineTimeHeader::sigRemoveColumnsAndShift ( )

signal

sigRemoveHoldColumns

void KisAnimTimelineTimeHeader::sigRemoveHoldColumns ( )

signal

sigRemoveHoldColumnsCustom

void KisAnimTimelineTimeHeader::sigRemoveHoldColumnsCustom ( )

signal

sigZoomChanged

void KisAnimTimelineTimeHeader::sigZoomChanged ( qreal zoom )

signal

slotSaveThrottle

void KisAnimTimelineTimeHeader::slotSaveThrottle ( qreal value )

slot

Definition at line 276 of file KisAnimTimelineTimeHeader.cpp.

{
    m_d->zoomSaveCompressor->start(value);
}

References m_d, and value().

updateMinimumSize()

void KisAnimTimelineTimeHeader::updateMinimumSize ( )

private

Definition at line 440 of file KisAnimTimelineTimeHeader.cpp.

{
    QFontMetrics metrics(this->font());
    const int textHeight = metrics.height();
 
    setMinimumSize(0, 1.5 * textHeight);
}

zoom()

qreal KisAnimTimelineTimeHeader::zoom

(

)

Definition at line 436 of file KisAnimTimelineTimeHeader.cpp.

                                      {
    return  (qreal(defaultSectionSize() + m_d->remainder) / m_d->unitSectionSize);
}

References m_d.

zoomToFitFrameRange()

void KisAnimTimelineTimeHeader::zoomToFitFrameRange	(	int	start,
		int	end )

Definition at line 601 of file KisAnimTimelineTimeHeader.cpp.

{
    const int PADDING = 2;
    qreal lengthSections = (end + PADDING) - start;
    qreal desiredZoom = width() / lengthSections;
 
    setZoom(desiredZoom / m_d->unitSectionSize);
}

References m_d, and setZoom().

Member Data Documentation

m_d

const QScopedPointer<Private> KisAnimTimelineTimeHeader::m_d

private

Definition at line 89 of file KisAnimTimelineTimeHeader.h.

---

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

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