PresetHistoryDock Class Reference

#include <presethistory_dock.h>

Inheritance diagram for PresetHistoryDock:

Public Types
enum	DisplayOrder { Static = 0 , MostRecent = 1 , Bubbling = 2 }
enum	HistoryDataRole { ResourceID = Qt::UserRole , BubbleMarkerRole = Qt::UserRole + 1 }

Public Slots
void	slotScrollerStateChanged (QScroller::State state)

Public Member Functions
QString	observerName () override
	PresetHistoryDock ()
void	setCanvas (KoCanvasBase *canvas) override
void	unsetCanvas () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Private Slots
void	canvasResourceChanged (int key, const QVariant &v)
void	presetSelected (QListWidgetItem *item)
void	showPresetLimitDialog ()
void	slotContextMenuRequest (const QPoint &pos)
void	slotPresetLimitChanged (int presetLimit)
void	slotSortingModeChanged (QAction *action)
void	updatePresets ()

Private Member Functions
void	addPreset (QString name, QIcon icon, int resourceId)
int	bubblePreset (int position)
void	updatePresetState (int position)

Private Attributes
QAction *	m_actionSortBubble
QAction *	m_actionSortMostRecent
QAction *	m_actionSortStatic
bool	m_block {false}
QPointer< KisCanvas2 >	m_canvas
bool	m_initialized {false}
PresetHistoryList *	m_presetHistory
int	m_presetLimit
KisResourceModel *	m_resourceModel {0}
DisplayOrder	m_sorting {Static}
QActionGroup *	m_sortingModes

Additional Inherited Members

Detailed Description

Definition at line 33 of file presethistory_dock.h.

Member Enumeration Documentation

DisplayOrder

enum PresetHistoryDock::DisplayOrder

Enumerator
Static
MostRecent
Bubbling

Definition at line 41 of file presethistory_dock.h.

                      {
        Static = 0,
        MostRecent = 1,
        Bubbling = 2
    };

HistoryDataRole

enum PresetHistoryDock::HistoryDataRole

Enumerator
ResourceID
BubbleMarkerRole

Definition at line 36 of file presethistory_dock.h.

                         {
        ResourceID = Qt::UserRole,
        BubbleMarkerRole = Qt::UserRole + 1
    };

Constructor & Destructor Documentation

PresetHistoryDock()

PresetHistoryDock::PresetHistoryDock

(

)

Definition at line 48 of file presethistory_dock.cpp.

    : QDockWidget(i18n("Brush Preset History"))
{
    m_presetHistory = new PresetHistoryList(this);
    m_presetHistory->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
    m_presetHistory->setDragEnabled(false);
    m_presetHistory->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_presetHistory->setSelectionMode(QAbstractItemView::SingleSelection);
    m_presetHistory->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
    m_presetHistory->setContextMenuPolicy(Qt::CustomContextMenu);
    setWidget(m_presetHistory);
 
    m_sortingModes = new QActionGroup(this);
    m_actionSortStatic = new QAction(i18n("Static Positions"), m_sortingModes);
    m_actionSortStatic->setCheckable(true);
    m_actionSortMostRecent = new QAction(i18n("Move to Top on Use"), m_sortingModes);
    m_actionSortMostRecent->setCheckable(true);
    m_actionSortBubble = new QAction(i18n("Bubble Up on Repeated Use"), m_sortingModes);
    m_actionSortBubble->setCheckable(true);
 
    QScroller* scroller = KisKineticScroller::createPreconfiguredScroller(m_presetHistory);
    if( scroller ) {
        connect(scroller, SIGNAL(stateChanged(QScroller::State)), this, SLOT(slotScrollerStateChanged(QScroller::State)));
    }
 
    m_resourceModel = KisResourceServerProvider::instance()->paintOpPresetServer()->resourceModel();
 
    connect(m_resourceModel, SIGNAL(modelReset()), this, SLOT(updatePresets()));
    connect(m_resourceModel, SIGNAL(rowsRemoved(const QModelIndex, int, int)), this, SLOT(updatePresets()));
    connect(m_resourceModel, SIGNAL(dataChanged(const QModelIndex, const QModelIndex, const QVector<int>)), this, SLOT(updatePresets()));
 
    connect(m_presetHistory, SIGNAL(mouseReleased(QListWidgetItem*)), SLOT(presetSelected(QListWidgetItem*)));
    connect(m_sortingModes, SIGNAL(triggered(QAction*)), SLOT(slotSortingModeChanged(QAction*)));
    connect(m_presetHistory, SIGNAL(customContextMenuRequested(QPoint)), SLOT(slotContextMenuRequest(QPoint)));
}

References connect(), KisKineticScroller::createPreconfiguredScroller(), ICON_SIZE, KisResourceServerProvider::instance(), m_actionSortBubble, m_actionSortMostRecent, m_actionSortStatic, m_presetHistory, m_resourceModel, m_sortingModes, KisResourceServerProvider::paintOpPresetServer(), presetSelected(), KoResourceServer< T >::resourceModel(), slotContextMenuRequest(), slotScrollerStateChanged(), slotSortingModeChanged(), and updatePresets().

Member Function Documentation

addPreset()

void PresetHistoryDock::addPreset ( QString name, QIcon icon, int resourceId )

private

Definition at line 266 of file presethistory_dock.cpp.

{
    if (resourceId >= 0) {
        QListWidgetItem *item = new QListWidgetItem(icon, name);
        item->setData(BubbleMarkerRole, QVariant(false));
        item->setData(ResourceID, resourceId);
        m_presetHistory->insertItem(0, item);
        m_presetHistory->setCurrentRow(0);
        if (m_presetHistory->count() > m_presetLimit) {
            delete m_presetHistory->takeItem(m_presetLimit);
        }
    }
 
}

References BubbleMarkerRole, m_presetHistory, m_presetLimit, and ResourceID.

bubblePreset()

int PresetHistoryDock::bubblePreset ( int position )

private

Definition at line 225 of file presethistory_dock.cpp.

{
    QListWidgetItem *item = m_presetHistory->item(position);
    if (position == 0) {
        // topmost item cannot bubble, its bubble state stays until
        // below item tries to bubble, so state can be set unconditionally
        item->setData(BubbleMarkerRole, QVariant(true));
        return position;
    }
 
    if (!item->data(BubbleMarkerRole).toBool()) {
        // first activation effectively makes the entry rival the list position above
        // (unless that one is already marked to bubble too) but it won't raise in position
        // until it gets activated again so its position is clearly defined as above
        item->setData(BubbleMarkerRole, QVariant(true));
        return position;
    }
    else {
        item->setData(BubbleMarkerRole, QVariant(false));
        int topPosition = position - 1;
        for (; topPosition >= 0; --topPosition) {
            QListWidgetItem *topItem = m_presetHistory->item(topPosition);
            if (topItem->data(BubbleMarkerRole).toBool()) {
                topItem->setData(BubbleMarkerRole, QVariant(false));
            }
            else {
                break;
            }
        }
        // if all above items want to bubble too, nothing happens besides resetting bubble state
        if (topPosition >= 0) {
            // since a group of items may bubble together, the net effect is
            // that the item above this range moves below that group
            QListWidgetItem *topItem = m_presetHistory->takeItem(topPosition);
            m_presetHistory->insertItem(position, topItem);
            return position - 1;
        }
    }
    return position;
}

References BubbleMarkerRole, and m_presetHistory.

canvasResourceChanged

void PresetHistoryDock::canvasResourceChanged ( int key, const QVariant & v )

privateslot

Definition at line 159 of file presethistory_dock.cpp.

{
    if (m_block) return;
 
    if (m_canvas && key == KoCanvasResource::CurrentPaintOpPreset) {
        KisPaintOpPresetSP preset = v.value<KisPaintOpPresetSP>();
        if (preset) {
            for (int i = 0; i < m_presetHistory->count(); ++i) {
                if (preset->name() == m_presetHistory->item(i)->text()) {
                    updatePresetState(i);
                    return;
                }
            }
            addPreset(preset->name(), QPixmap::fromImage(preset->image()), preset->resourceId());
        }
    }
}

References addPreset(), KoCanvasResource::CurrentPaintOpPreset, m_block, m_canvas, m_presetHistory, updatePresetState(), and v.

observerName()

QString PresetHistoryDock::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 48 of file presethistory_dock.h.

{ return "PresetHistoryDock"; }

presetSelected

void PresetHistoryDock::presetSelected ( QListWidgetItem * item )

privateslot

Definition at line 146 of file presethistory_dock.cpp.

{
    if (item) {
        int oldPosition = m_presetHistory->currentRow();
        updatePresetState(oldPosition);
        int id = item->data(ResourceID).toInt();
        KisPaintOpPresetSP preset = m_resourceModel->resourceForId(id).dynamicCast<KisPaintOpPreset>();
        m_block = true;
        m_canvas->viewManager()->paintOpBox()->resourceSelected(preset);
        m_block = false;
    }
}

References m_block, m_canvas, m_presetHistory, m_resourceModel, KisResourceModel::resourceForId(), ResourceID, and updatePresetState().

setCanvas()

void PresetHistoryDock::setCanvas ( KoCanvasBase * canvas )

overridevirtual

re-implement this method in your canvas observer. It will be called whenever a canvas becomes active. Note that you are responsible for not connecting more than one time to the signals of a canvas or any of the QObjects you can access through the canvas.

Implements KoCanvasObserverBase.

Definition at line 84 of file presethistory_dock.cpp.

{
    setEnabled(canvas != 0);
 
    if (m_canvas) {
        m_canvas->disconnectCanvasObserver(this);
        disconnect(m_canvas->resourceManager());
    }
 
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
    if (!m_canvas || !m_canvas->viewManager() || !m_canvas->resourceManager()) return;
 
    connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)), SLOT(canvasResourceChanged(int,QVariant)));
 
    if (!m_initialized) {
        KisConfig cfg(true);
        QStringList presetHistory = cfg.readEntry<QString>("presethistory", "").split(",", Qt::SkipEmptyParts);
 
        m_presetLimit = cfg.readEntry("presethistoryLimit", 10);
 
        Q_FOREACH (const QString &p, presetHistory) {
            if (m_resourceModel->resourcesForName(p).count()>0) {
                KoResourceSP resource = m_resourceModel->resourcesForName(p).first();
                if (resource) {
                    addPreset(p, QPixmap::fromImage(resource->image()), resource->resourceId());
                }
            }
        }
        int ordering = cfg.readEntry("presethistorySorting", int(DisplayOrder::Static));
        m_sorting = qBound(DisplayOrder::Static, static_cast<DisplayOrder>(ordering), DisplayOrder::Bubbling);
 
        switch (m_sorting) {
        case DisplayOrder::Static:
            m_actionSortStatic->setChecked(true);
            break;
        case DisplayOrder::MostRecent:
            m_actionSortMostRecent->setChecked(true);
            break;
        case DisplayOrder::Bubbling:
            m_actionSortBubble->setChecked(true);
        }
 
        QVariant currentPreset = m_canvas->resourceManager()->resource(KoCanvasResource::CurrentPaintOpPreset);
        canvasResourceChanged(KoCanvasResource::CurrentPaintOpPreset, currentPreset);
        m_initialized = true;
    }
}

References addPreset(), Bubbling, canvasResourceChanged(), connect(), KoCanvasResource::CurrentPaintOpPreset, m_actionSortBubble, m_actionSortMostRecent, m_actionSortStatic, m_canvas, m_initialized, m_presetLimit, m_resourceModel, m_sorting, MostRecent, p, KisConfig::readEntry(), KisResourceModel::resourcesForName(), and Static.

showPresetLimitDialog

void PresetHistoryDock::showPresetLimitDialog ( )

privateslot

Definition at line 200 of file presethistory_dock.cpp.

                                              {
    bool ok;
    int i = QInputDialog::getInt(this, i18n("Set Number of Brushes Shown"),
                                 i18n("Number of Brushes Shown:"), m_presetLimit, 1, 100, 10, &ok);
    if (ok && i != m_presetLimit) {
        slotPresetLimitChanged(i);
    }
}

References m_presetLimit, and slotPresetLimitChanged().

slotContextMenuRequest

void PresetHistoryDock::slotContextMenuRequest ( const QPoint & pos )

privateslot

Definition at line 296 of file presethistory_dock.cpp.

{
    QMenu contextMenu;
    QListWidgetItem *presetItem = m_presetHistory->itemAt(pos);
    QAction *actionForget = 0;
    if (presetItem) {
        actionForget = new QAction(i18n("Forget \"%1\"", presetItem->text()), &contextMenu);
        contextMenu.addAction(actionForget);
    }
    contextMenu.addAction(i18n("Clear History"), m_presetHistory, SLOT(clear()));
    contextMenu.addSeparator();
    contextMenu.addSection(i18n("History Behavior:"));
    contextMenu.addAction(m_actionSortStatic);
    contextMenu.addAction(m_actionSortMostRecent);
    contextMenu.addAction(m_actionSortBubble);
    contextMenu.addSeparator();
    contextMenu.addAction(i18n("Configure Number of Brushes Shown..."), this, SLOT(showPresetLimitDialog()));
    QAction *triggered = contextMenu.exec(m_presetHistory->mapToGlobal(pos));
 
    if (presetItem && triggered == actionForget) {
        // deleting a QListWidgetItem removes it from the QListWidget automatically
        delete presetItem;
    }
}

References m_actionSortBubble, m_actionSortMostRecent, m_actionSortStatic, m_presetHistory, and showPresetLimitDialog().

slotPresetLimitChanged

void PresetHistoryDock::slotPresetLimitChanged ( int presetLimit )

privateslot

Definition at line 190 of file presethistory_dock.cpp.

{
    m_presetLimit = presetLimit;
    while (m_presetHistory->count() > m_presetLimit) {
        delete m_presetHistory->takeItem(m_presetHistory->count()-1);
    }
    KisConfig cfg(false);
    cfg.writeEntry("presethistoryLimit", m_presetLimit);
}

References m_presetHistory, m_presetLimit, and KisConfig::writeEntry().

slotScrollerStateChanged

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

inlineslot

Definition at line 52 of file presethistory_dock.h.

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

References KisKineticScroller::updateCursor().

slotSortingModeChanged

void PresetHistoryDock::slotSortingModeChanged ( QAction * action )

privateslot

Definition at line 177 of file presethistory_dock.cpp.

{
    if (action == m_actionSortStatic) {
        m_sorting = DisplayOrder::Static;
    } else if (action == m_actionSortMostRecent) {
        m_sorting = DisplayOrder::MostRecent;
    } else if (action == m_actionSortBubble) {
        m_sorting = DisplayOrder::Bubbling;
    }
    KisConfig cfg(false);
    cfg.writeEntry("presethistorySorting", int(m_sorting));
}

References Bubbling, m_actionSortBubble, m_actionSortMostRecent, m_actionSortStatic, m_sorting, MostRecent, Static, and KisConfig::writeEntry().

unsetCanvas()

void PresetHistoryDock::unsetCanvas ( )

overridevirtual

Re-implement to notify the observer that its canvas is no longer among the living. The daisies, it is pushing up. This means you don't have to disconnect, it's dead.

The old canvas should be deleted already, so if you stored a pointer to it, don't touch!

Note that currently there is a bug where in certain specific circumstances unsetCanvas can be called when it shouldn't, see for example KWStatisticsDocker for a workaround for this problem.

Implements KoCanvasObserverBase.

Definition at line 133 of file presethistory_dock.cpp.

{
    m_canvas = 0;
    setEnabled(false);
    QStringList presetHistory;
    for(int i = 0; i < m_presetHistory->count(); i++) {
        QListWidgetItem *item = m_presetHistory->item(i);
        presetHistory.insert(0, item->text());
    }
    KisConfig cfg(false);
    cfg.writeEntry("presethistory", presetHistory.join(","));
}

References m_canvas, m_presetHistory, and KisConfig::writeEntry().

updatePresets

void PresetHistoryDock::updatePresets ( )

privateslot

Definition at line 281 of file presethistory_dock.cpp.

{
    for (int i = 0; i < m_presetHistory->count(); ++i) {
        QListWidgetItem *item = m_presetHistory->item(i);
        int id = item->data(ResourceID).toInt();
        QModelIndex index = m_resourceModel->indexForResourceId(id);
        if (index.isValid()) {
            item->setIcon(QPixmap::fromImage(index.data(Qt::UserRole + KisAbstractResourceModel::Thumbnail).value<QImage>()));
            item->setText(index.data(Qt::UserRole + KisAbstractResourceModel::Name).toString());
        } else {
            delete m_presetHistory->takeItem(i);
        }
    }
}

References KisResourceModel::indexForResourceId(), m_presetHistory, m_resourceModel, KisAbstractResourceModel::Name, ResourceID, and KisAbstractResourceModel::Thumbnail.

updatePresetState()

void PresetHistoryDock::updatePresetState ( int position )

private

Definition at line 209 of file presethistory_dock.cpp.

{
    switch (m_sorting) {
    case Static:
        m_presetHistory->setCurrentRow(position);
        break;
    case MostRecent:
        m_presetHistory->insertItem(0, m_presetHistory->takeItem(position));
        m_presetHistory->setCurrentRow(0);
        break;
    case Bubbling:
        position = bubblePreset(position);
        m_presetHistory->setCurrentRow(position);
    };
}

References bubblePreset(), Bubbling, m_presetHistory, m_sorting, MostRecent, and Static.

Member Data Documentation

m_actionSortBubble

QAction* PresetHistoryDock::m_actionSortBubble

private

Definition at line 70 of file presethistory_dock.h.

m_actionSortMostRecent

QAction* PresetHistoryDock::m_actionSortMostRecent

private

Definition at line 69 of file presethistory_dock.h.

m_actionSortStatic

QAction* PresetHistoryDock::m_actionSortStatic

private

Definition at line 68 of file presethistory_dock.h.

m_block

bool PresetHistoryDock::m_block {false}

private

Definition at line 75 of file presethistory_dock.h.

{false};

m_canvas

QPointer<KisCanvas2> PresetHistoryDock::m_canvas

private

Definition at line 66 of file presethistory_dock.h.

m_initialized

bool PresetHistoryDock::m_initialized {false}

private

Definition at line 76 of file presethistory_dock.h.

{false};

m_presetHistory

PresetHistoryList* PresetHistoryDock::m_presetHistory

private

Definition at line 67 of file presethistory_dock.h.

m_presetLimit

int PresetHistoryDock::m_presetLimit

private

Definition at line 73 of file presethistory_dock.h.

m_resourceModel

KisResourceModel* PresetHistoryDock::m_resourceModel {0}

private

Definition at line 74 of file presethistory_dock.h.

{0};

m_sorting

DisplayOrder PresetHistoryDock::m_sorting {Static}

private

Definition at line 72 of file presethistory_dock.h.

{Static};

m_sortingModes

QActionGroup* PresetHistoryDock::m_sortingModes

private

Definition at line 71 of file presethistory_dock.h.

---

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

• plugins/dockers/presethistory/presethistory_dock.h
• plugins/dockers/presethistory/presethistory_dock.cpp