KisColorPatchesTableView Class Reference

#include <KisColorPatchesTableView.h>

Inheritance diagram for KisColorPatchesTableView:

Classes
struct	Private

Public Slots
void	slotScrollerStateChanged (QScroller::State state)

Public Member Functions
void	addColorPatch (const KoColor &color)
QSize	cellSize () const
boost::optional< KoColor >	colorPatchAt (const QPoint &pos) const
QList< KoColor >	colors () const
	KisColorPatchesTableView (const QString &configPrefix, QWidget *parent=nullptr)
void	mousePressEvent (QMouseEvent *event) override
void	mouseReleaseEvent (QMouseEvent *event) override
int	patchCount () const
void	reloadWidgetConfig ()
void	setColors (const QList< KoColor > &colors)
void	wheelEvent (QWheelEvent *event) override
	~KisColorPatchesTableView () override

Private Member Functions
void	redraw ()

Private Attributes
QScopedPointer< Private >	m_d

Detailed Description

Definition at line 20 of file KisColorPatchesTableView.h.

Constructor & Destructor Documentation

KisColorPatchesTableView()

KisColorPatchesTableView::KisColorPatchesTableView	(	const QString &	configPrefix,
		QWidget *	parent = nullptr )

Definition at line 60 of file KisColorPatchesTableView.cpp.

    : QTableView(parent)
    , m_d(new KisColorPatchesTableView::Private(configPrefix))
{
    setShowGrid(false);
    setSelectionBehavior(QAbstractItemView::SelectItems);
    setSelectionMode(QAbstractItemView::NoSelection);
    // makes sure that the patches don't go out of bounds, one can notice if kinetic scrolling enabled.
    setStyleSheet("QTableView{ border: 0px}");
    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
    setEditTriggers(QAbstractItemView::NoEditTriggers);
 
    reloadWidgetConfig();
 
    QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this);
    if (scroller) {
        QScrollerProperties props;
        props.setScrollMetric(QScrollerProperties::VerticalOvershootPolicy,
                              QScrollerProperties::OvershootAlwaysOff);
        props.setScrollMetric(QScrollerProperties::HorizontalOvershootPolicy,
                              QScrollerProperties::OvershootAlwaysOff);
        scroller->setScrollerProperties(props);
        connect(scroller,
                SIGNAL(stateChanged(QScroller::State)),
                this,
                SLOT(slotScrollerStateChanged(QScroller::State)));
    }
    reloadWidgetConfig();
}

References connect(), KisKineticScroller::createPreconfiguredScroller(), reloadWidgetConfig(), and slotScrollerStateChanged().

~KisColorPatchesTableView()

KisColorPatchesTableView::~KisColorPatchesTableView ( )

override

Definition at line 90 of file KisColorPatchesTableView.cpp.

{
}

Member Function Documentation

addColorPatch()

void KisColorPatchesTableView::addColorPatch

(

const KoColor &

color

)

Definition at line 191 of file KisColorPatchesTableView.cpp.

{
    m_d->colorPatches.removeAll(color);
    m_d->colorPatches.prepend(color);
 
    if (m_d->colorPatches.size() > 200) {
        m_d->colorPatches.pop_back();
    }
 
    redraw();
}

References m_d, and redraw().

cellSize()

QSize KisColorPatchesTableView::cellSize

(

)

const

Definition at line 181 of file KisColorPatchesTableView.cpp.

{
    return QSize(m_d->patchWidth, m_d->patchHeight);
}

References m_d.

colorPatchAt()

boost::optional< KoColor > KisColorPatchesTableView::colorPatchAt

(

const QPoint &

pos

)

const

Definition at line 282 of file KisColorPatchesTableView.cpp.

{
    // TODO(sh_zam): Is there a better way that doesn't have to involve mapFromGlobal?
    const QModelIndex index = indexAt(mapFromGlobal(pos));
    if (!index.isValid()) {
        return boost::none;
    }
    int linearIndex = 0;
    if (m_d->direction == KisColorPatches::Vertical) {
        linearIndex = index.row() * m_d->model->columnCount() + index.column();
    } else {
        linearIndex = index.column() * m_d->model->rowCount() + index.row();
    }
    // since (0, 0) index has the additional button.
    linearIndex -= 1;
 
    if (linearIndex < 0 || linearIndex >= m_d->colorPatches.size()) {
        return boost::none;
    }
    return m_d->colorPatches[linearIndex];
}

References m_d, and KisColorPatches::Vertical.

colors()

QList< KoColor > KisColorPatchesTableView::colors

(

)

const

Definition at line 101 of file KisColorPatchesTableView.cpp.

{
    return m_d->colorPatches;
}

References m_d.

mousePressEvent()

void KisColorPatchesTableView::mousePressEvent ( QMouseEvent * event )

override

Definition at line 226 of file KisColorPatchesTableView.cpp.

{
    event->ignore();
}

mouseReleaseEvent()

void KisColorPatchesTableView::mouseReleaseEvent ( QMouseEvent * event )

override

Definition at line 231 of file KisColorPatchesTableView.cpp.

{
    event->ignore();
}

patchCount()

int KisColorPatchesTableView::patchCount

(

)

const

Definition at line 186 of file KisColorPatchesTableView.cpp.

{
    return m_d->patchCount;
}

References m_d.

redraw()

void KisColorPatchesTableView::redraw ( )

private

Definition at line 236 of file KisColorPatchesTableView.cpp.

{
    m_d->model->clear();
 
    if (m_d->colorPatches.isEmpty()) {
        return;
    }
 
    // a simple index, keeping count of how many patches have been put in the model.
    int linearIndex = 0;
    // sorry for the lack of term, think of pointer as pointing to an array and index iterating inside that
    // array.
    const int limit = ((m_d->direction == KisColorPatches::Vertical) ? m_d->numCols : m_d->numRows);
    int pointer = 0;
    // index should start from 1, because the first item is the "extra" button we have to take care of.
    int index = 1 % limit;
 
    Q_FOREACH (const KoColor &color, m_d->colorPatches) {
        if (linearIndex > m_d->patchCount) {
            break;
        }
        // We handle two cases:
        // (1) say if numColumn = 1 and we are on row = 0, then we should add a row than trying to draw in
        // i + 1 column (since column never changes in this case).
        // (2) we have reached the end of the "array". Create a new sequence.
        if (index == 0) {
            pointer++;
            if (m_d->direction == KisColorPatches::Vertical) {
                m_d->model->insertRow(pointer);
            } else {
                m_d->model->insertColumn(pointer);
            }
        }
        QStandardItem *item = new QStandardItem;
        item->setData(QVariant(), Qt::DisplayRole);
        item->setData(color.toQColor(), Qt::UserRole);
        if (m_d->direction == KisColorPatches::Vertical) {
            m_d->model->setItem(pointer, index, item);
        } else {
            m_d->model->setItem(index, pointer, item);
        }
        index = (index + 1) % limit;
        linearIndex++;
    }
}

References m_d, KoColor::toQColor(), and KisColorPatches::Vertical.

reloadWidgetConfig()

void KisColorPatchesTableView::reloadWidgetConfig

(

)

Definition at line 106 of file KisColorPatchesTableView.cpp.

{
    const KConfigGroup cfg = KSharedConfig::openConfig()->group("advancedColorSelector");
 
    m_d->numCols = cfg.readEntry(m_d->configPrefix + "NumCols", 1);
    m_d->numRows = cfg.readEntry(m_d->configPrefix + "NumRows", 1);
 
    m_d->patchWidth = cfg.readEntry(m_d->configPrefix + "Width", 20);
    m_d->patchHeight = cfg.readEntry(m_d->configPrefix + "Height", 20);
    if (cfg.readEntry(m_d->configPrefix + "Alignment", false)) {
        m_d->direction = KisColorPatches::Vertical;
    } else {
        m_d->direction = KisColorPatches::Horizontal;
    }
    m_d->patchCount = cfg.readEntry(m_d->configPrefix + "Count", 15);
    const bool allowScrolling = cfg.readEntry(m_d->configPrefix + "Scrolling", true);
    if (!allowScrolling) {
        QScroller::scroller(this)->ungrabGesture(this);
        horizontalScrollBar()->setEnabled(false);
        verticalScrollBar()->setEnabled(false);
        m_d->wasScrollingDisabled = true;
    } else if (m_d->wasScrollingDisabled) {
        QScroller *scroller = QScroller::scroller(this);
        scroller->grabGesture(this, KisKineticScroller::getConfiguredGestureType());
        horizontalScrollBar()->setEnabled(true);
        verticalScrollBar()->setEnabled(true);
        m_d->wasScrollingDisabled = false;
    }
 
    m_d->model.reset(new QStandardItemModel(m_d->numRows, m_d->numCols, this));
 
    if (m_d->direction == KisColorPatches::Vertical) {
        setMinimumWidth((m_d->patchWidth + 0) * m_d->numCols);
        setMaximumWidth((m_d->patchWidth + 0) * m_d->numCols);
 
        // reset if this was previously Horizontal
        setMinimumHeight(m_d->patchHeight);
        setMaximumHeight(QWIDGETSIZE_MAX);
 
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
    } else {
        setMinimumHeight((m_d->patchHeight + 0) * m_d->numRows);
        setMaximumHeight((m_d->patchHeight + 0) * m_d->numRows);
 
        // reset if this was previously Vertical
        setMinimumWidth(m_d->patchWidth);
        setMaximumWidth(QWIDGETSIZE_MAX);
 
        setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
    }
 
    // minimum should always be set before default.
    verticalHeader()->setMinimumSectionSize(m_d->patchHeight);
    verticalHeader()->setMaximumSectionSize(m_d->patchHeight);
    verticalHeader()->setDefaultSectionSize(m_d->patchHeight);
    horizontalHeader()->setMinimumSectionSize(m_d->patchWidth);
    horizontalHeader()->setMaximumSectionSize(m_d->patchWidth);
    horizontalHeader()->setDefaultSectionSize(m_d->patchWidth);
 
    // don't let the user resize us.
    verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
    horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed);
 
    verticalHeader()->hide();
    horizontalHeader()->hide();
 
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
    setModel(m_d->model.data());
    setItemDelegate(new KisColorPatchesTableDelegate(this));
 
    redraw();
}

References KisKineticScroller::getConfiguredGestureType(), KisColorPatches::Horizontal, m_d, redraw(), and KisColorPatches::Vertical.

setColors()

void KisColorPatchesTableView::setColors

(

const QList< KoColor > &

colors

)

Definition at line 94 of file KisColorPatchesTableView.cpp.

{
    m_d->colorPatches.clear();
    m_d->colorPatches = colors;
    redraw();
}

References colors(), m_d, and redraw().

slotScrollerStateChanged

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

inlineslot

Definition at line 41 of file KisColorPatchesTableView.h.

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

References KisKineticScroller::updateCursor().

wheelEvent()

void KisColorPatchesTableView::wheelEvent ( QWheelEvent * event )

override

Definition at line 203 of file KisColorPatchesTableView.cpp.

{
    if (m_d->direction == KisColorPatches::Horizontal) {
        bool horizontal = qAbs(event->angleDelta().x()) > qAbs(event->angleDelta().y());
        if (!horizontal) {
            // HACK: here we make our normal vertical scroller, also do a horizontal scroll
            QPoint modifiedAngleDelta = {event->angleDelta().y(), event->angleDelta().x()};
            QWheelEvent modifiedEvent(event->position(),
                                      event->globalPosition(),
                                      event->pixelDelta(),
                                      modifiedAngleDelta,
                                      event->buttons(),
                                      event->modifiers(),
                                      event->phase(),
                                      event->inverted());
            horizontalScrollBar()->event(&modifiedEvent);
            event->accept();
            return;
        }
    }
    QTableView::wheelEvent(event);
}

References KisColorPatches::Horizontal, and m_d.

Member Data Documentation

m_d

QScopedPointer<Private> KisColorPatchesTableView::m_d

private

Definition at line 51 of file KisColorPatchesTableView.h.

---

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

• plugins/dockers/advancedcolorselector/KisColorPatchesTableView.h
• plugins/dockers/advancedcolorselector/KisColorPatchesTableView.cpp