KisPaletteEditor Class Reference

The PaletteEditor class this class manipulates a KisPaletteModel using GUI elements and communicates with KisDocument. More...

#include <KisPaletteEditor.h>

Inheritance diagram for KisPaletteEditor:

Classes
struct	PaletteInfo
struct	Private

Public Member Functions
void	addEntry (const KoColor &color)
QString	addGroup ()
	Stage the addition of a new swatch group.
KoColorSetSP	addPalette ()
void	changeColumnCount (int)
	Stage a change of the palette's column count.
void	changeGroupRowCount (const QString &name, int newRowCount)
	Stage a change to the row count of a group.
void	clearStagedChanges ()
void	endEditing (bool applyChanges=true)
	End editing and either apply or discard staged changes.
KoColorSetSP	importPalette ()
bool	isModified () const
	KisPaletteEditor (QObject *parent=0)
void	modifyEntry (const QModelIndex &index)
QString	oldNameFromNewName (const QString &newName) const
	oldNameFromNewName
void	removeEntry (const QModelIndex &index)
bool	removeGroup (const QString &name)
	Stage the removal of a group.
void	removePalette (KoColorSetSP)
void	rename (const QString &newName)
	Stage a palette rename.
QString	renameGroup (const QString &oldName)
	Stage a rename of a group.
int	rowCountOfGroup (const QString &originalName) const
	rowCountOfGroup
void	saveNewPaletteVersion ()
	saveNewPaletteVersion
void	setEntry (const KoColor &color, const QModelIndex &index)
void	setPaletteModel (KisPaletteModel *model)
void	setStorageLocation (QString location)
void	setView (KisViewManager *view)
void	startEditing ()
	Start editing the current palette.
	~KisPaletteEditor ()

Private Slots
void	slotGroupNameChanged (const QString &newName)
void	slotPaletteChanged ()
void	slotSetDocumentModified ()

Private Member Functions
bool	duplicateExistsGroupName (const QString &name) const
bool	duplicateExistsOriginalGroupName (const QString &name) const
QString	filenameFromPath (const QString &path) const
QString	newGroupName () const

Private Attributes
QScopedPointer< Private >	m_d

Detailed Description

The PaletteEditor class this class manipulates a KisPaletteModel using GUI elements and communicates with KisDocument.

Changes made in this class won't be done to the palette if the palette is read only (not editable, isEditable() == false)

Definition at line 30 of file KisPaletteEditor.h.

Constructor & Destructor Documentation

KisPaletteEditor()

KisPaletteEditor::KisPaletteEditor ( QObject * parent = 0 )

explicit

Definition at line 62 of file KisPaletteEditor.cpp.

    : QObject(parent)
    , m_d(new Private)
{
    m_d->rServer = KoResourceServerProvider::instance()->paletteServer();
    m_d->warnPalette.setColor(QPalette::Text, Qt::red);
}

References KoResourceServerProvider::instance(), m_d, and KoResourceServerProvider::paletteServer.

~KisPaletteEditor()

KisPaletteEditor::~KisPaletteEditor

(

)

Definition at line 70 of file KisPaletteEditor.cpp.

{ }

Member Function Documentation

addEntry()

void KisPaletteEditor::addEntry

(

const KoColor &

color

)

Definition at line 430 of file KisPaletteEditor.cpp.

{
    Q_ASSERT(m_d->model);
    if (!m_d->view) { return; }
    if (!m_d->view->document()) { return; }
 
    KoDialog dialog;
    dialog.setWindowTitle(i18nc("@title:dialog", "Add a new Color Swatch"));
 
    QFormLayout *editableItems = new QFormLayout(dialog.mainWidget());
 
    QComboBox *cmbGroups = new QComboBox();
    cmbGroups->addItems(m_d->model->colorSet()->swatchGroupNames());
    cmbGroups->setCurrentIndex(0);
 
    QLineEdit *lnIDName = new QLineEdit();
    lnIDName->setText(QString::number(m_d->model->colorSet()->colorCount() + 1));
 
    QLineEdit *lnName = new QLineEdit();
    lnName->setText(i18nc("Default name for a color swatch","Color %1", QString::number(m_d->model->colorSet()->colorCount()+1)));
 
    KisColorButton *bnColor = new KisColorButton();
    bnColor->setColor(color);
 
    QCheckBox *chkSpot = new QCheckBox();
    chkSpot->setChecked(false);
    chkSpot->setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
 
    editableItems->addRow(i18n("Swatch Group:"), cmbGroups);
    editableItems->addRow(i18n("Swatch ID:"), lnIDName);
    editableItems->addRow(i18n("Color swatch name:"), lnName);
    editableItems->addRow(i18nc("Color as the Color of a Swatch in a Palette", "Color:"), bnColor);
    editableItems->addRow(i18n("Spot color:"), chkSpot);
 
    if (dialog.exec() != KoDialog::Accepted) { return; }
 
    QString groupName = cmbGroups->currentText();
 
    KisSwatch newSwatch;
    newSwatch.setColor(bnColor->color());
    newSwatch.setName(lnName->text());
    newSwatch.setId(lnIDName->text());
    newSwatch.setSpotColor(chkSpot->isChecked());
    m_d->model->addSwatch(newSwatch, groupName);
    m_d->modifiedGroupNames.insert(groupName);
    // TODO: This is getting called when startEditing is never called. This avoids the crash, but what is its purpose?
    if (m_d->isEditing) {
        KisSwatchGroupSP cs = m_d->modifiedPaletteInfo.groups.value(groupName);
        cs->addSwatch(newSwatch);
        if (!m_d->modifiedPaletteInfo.groups.contains(groupName)) {
            m_d->modifiedPaletteInfo.groups.insert(groupName, cs);
        }
    }
}

References KisColorButton::color, m_d, KisColorButton::setColor(), KisSwatch::setColor(), KisSwatch::setId(), KisSwatch::setName(), and KisSwatch::setSpotColor().

addGroup()

QString KisPaletteEditor::addGroup

(

)

Stage the addition of a new swatch group.

Returns

new group's name if change accepted, empty string if cancelled

Definition at line 235 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return QString();
    }
    KoDialog dialog;
    m_d->query = &dialog;
 
    QVBoxLayout *layout = new QVBoxLayout(dialog.mainWidget());
 
    layout->addWidget(new QLabel(i18n("New swatch group name:")));
    QLineEdit *leName = new QLineEdit(newGroupName());
    connect(leName, SIGNAL(textChanged(QString)), SLOT(slotGroupNameChanged(QString)));
    layout->addWidget(leName);
    layout->addWidget(new QLabel(i18n("Rows of swatches in group:")));
    QSpinBox *spxRow = new QSpinBox();
    spxRow->setValue(20);
    layout->addWidget(spxRow);
 
    if (dialog.exec() != QDialog::Accepted) { return QString(); }
    if (duplicateExistsGroupName(leName->text())) { return QString(); }
 
    QString realName = leName->text();
    QString name = realName;
    if (duplicateExistsOriginalGroupName(name)) {
        name = newGroupName();
    }
    m_d->modifiedPaletteInfo.groups[name].reset(new KisSwatchGroup);
    KisSwatchGroupSP newGroup = m_d->modifiedPaletteInfo.groups[name];
    newGroup->setName(realName);
    m_d->newGroupNames.insert(name);
    newGroup->setRowCount(spxRow->value());
    return realName;
}

References connect(), duplicateExistsGroupName(), duplicateExistsOriginalGroupName(), m_d, newGroupName(), and slotGroupNameChanged().

addPalette()

KoColorSetSP KisPaletteEditor::addPalette

(

)

Definition at line 90 of file KisPaletteEditor.cpp.

{
    if (!m_d->view) { return 0; }
    if (!m_d->view->document()) { return 0; }
 
    KoColorSetSP colorSet(new KoColorSet());
 
    KoDialog dialog;
    QFormLayout *layout = new QFormLayout(dialog.mainWidget());
    QLineEdit *le = new QLineEdit(i18nc("Default name for a new palette","New Palette"));
    layout->addRow(i18n("New palette name:"), le);
 
    QComboBox *cmbPaletteType = new QComboBox();
    cmbPaletteType->addItem(i18nc("Palette File Type", "Krita Palette (KPL)"));
    cmbPaletteType->addItem(i18nc("Palette File Type", "GIMP Palette (GPL)"));
    layout->addRow(cmbPaletteType);
 
    QCheckBox *chkSaveInDocument = new QCheckBox(i18n("Save Palette in the Current Document"));
    chkSaveInDocument->setChecked(false);
    layout->addRow(chkSaveInDocument);
 
 
    if (dialog.exec() != QDialog::Accepted) { return 0; }
 
    QString name = le->text();
    if (cmbPaletteType->currentIndex() == 0) {
        colorSet->setPaletteType(KoColorSet::KPL);
    }
    else {
        colorSet->setPaletteType(KoColorSet::GPL);
    }
    colorSet->setValid(true);
    colorSet->setName(name);
    colorSet->setFilename(name.split(" ").join("_")+colorSet->defaultFileExtension());
 
    QString resourceLocation = "";
    if (chkSaveInDocument->isChecked()) {
        resourceLocation = m_d->view->document()->linkedResourcesStorageId();
    }
 
    if (KisResourceUserOperations::addResourceWithUserInput(m_d->view->mainWindowAsQWidget(), colorSet, resourceLocation)) {
        return colorSet;
 
    }
 
    return 0;
}

References KisResourceUserOperations::addResourceWithUserInput(), KoColorSet::GPL, KoColorSet::KPL, and m_d.

changeColumnCount()

void KisPaletteEditor::changeColumnCount

(

int

newCount

)

Stage a change of the palette's column count.

Definition at line 227 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return;
    }
    m_d->modifiedPaletteInfo.columnCount = newCount;
}

References m_d.

changeGroupRowCount()

void KisPaletteEditor::changeGroupRowCount	(	const QString &	name,
		int	newRowCount )

Stage a change to the row count of a group.

Parameters

name
newRowCount

Definition at line 336 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return;
    }
    if (!m_d->modifiedPaletteInfo.groups.contains(name)) { return; }
    m_d->modifiedPaletteInfo.groups[name]->setRowCount(newRowCount);
    m_d->modifiedGroupNames.insert(name);
}

References m_d.

clearStagedChanges()

void KisPaletteEditor::clearStagedChanges

(

)

Definition at line 572 of file KisPaletteEditor.cpp.

{
    m_d->modifiedPaletteInfo.groups.clear();
    m_d->keepColorGroups.clear();
    m_d->newGroupNames.clear();
    m_d->modifiedGroupNames.clear();
    m_d->isEditing = false;
}

References m_d.

duplicateExistsGroupName()

bool KisPaletteEditor::duplicateExistsGroupName ( const QString & name ) const

private

Definition at line 194 of file KisPaletteEditor.cpp.

{
    if (name == m_d->groupBeingRenamed) { return false; }
    Q_FOREACH (const KisSwatchGroupSP group, m_d->modifiedPaletteInfo.groups.values()) {
        if (name == group->name()) { return true; }
    }
    return false;
}

References m_d.

duplicateExistsOriginalGroupName()

bool KisPaletteEditor::duplicateExistsOriginalGroupName ( const QString & name ) const

private

Definition at line 203 of file KisPaletteEditor.cpp.

{
    return m_d->modifiedPaletteInfo.groups.contains(name);
}

References m_d.

endEditing()

void KisPaletteEditor::endEditing

(

bool

applyChanges = true

)

End editing and either apply or discard staged changes.

Parameters

applyChanges

If set to false, the palette remains unchanged and staged changes are discarded.

Definition at line 519 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        qWarning("KisPaletteEditor::endEditing(): not in editing state; ignoring.");
        return;
    }
 
    if (!applyChanges) {
        clearStagedChanges();
        return;
    }
 
    if (!m_d->model) return;
    if (!m_d->model->colorSet()) return;
    if (!m_d->view) return;
    if (!m_d->view->document()) return;
 
    KoColorSetSP palette = m_d->model->colorSet();
    PaletteInfo &modified = m_d->modifiedPaletteInfo;
 
    if (modified.columnCount != palette->columnCount()) {
        m_d->model->setColumnCount(modified.columnCount);
    }
    if (modified.name != palette->name()) {
        KisResourceUserOperations::renameResourceWithUserInput(m_d->view->mainWindowAsQWidget(), palette, m_d->modifiedPaletteInfo.name);
    }
    QString resourceLocation = m_d->model->colorSet()->storageLocation();
    if (resourceLocation != m_d->modifiedPaletteInfo.storageLocation) {
        // We need functionality for moving the resource to the new resource storage...
    }
 
    Q_FOREACH (const QString &groupName, palette->swatchGroupNames()) {
        if (!modified.groups.contains(groupName)) {
            m_d->model->removeGroup(groupName, m_d->keepColorGroups.contains(groupName));
        }
    }
    Q_FOREACH (const QString &groupName, palette->swatchGroupNames()) {
        if (m_d->modifiedGroupNames.contains(groupName)) {
            m_d->model->setRowCountForGroup(groupName, modified.groups[groupName]->rowCount());
            if (groupName != modified.groups[groupName]->name()) {
                m_d->model->changeGroupName(groupName, modified.groups[groupName]->name());
                modified.groups[modified.groups[groupName]->name()] = modified.groups[groupName];
                modified.groups.remove(groupName);
            }
        }
    }
    Q_FOREACH (const QString &newGroupName, m_d->newGroupNames) {
        m_d->model->addGroup(newGroupName, palette->columnCount(), m_d->modifiedPaletteInfo.groups[newGroupName]->rowCount());
    }
 
    clearStagedChanges();
}

References clearStagedChanges(), KisPaletteEditor::PaletteInfo::columnCount, KisPaletteEditor::PaletteInfo::groups, m_d, KisPaletteEditor::PaletteInfo::name, newGroupName(), palette, and KisResourceUserOperations::renameResourceWithUserInput().

filenameFromPath()

QString KisPaletteEditor::filenameFromPath ( const QString & path ) const

private

Definition at line 625 of file KisPaletteEditor.cpp.

{
    return QDir::fromNativeSeparators(path).section('/', -1, -1);
}

importPalette()

KoColorSetSP KisPaletteEditor::importPalette

(

)

Definition at line 138 of file KisPaletteEditor.cpp.

{
    KoFileDialog dialog(nullptr, KoFileDialog::OpenFile, "Open Palette");
    dialog.setCaption(i18n("Import Palette"));
 
    dialog.setDefaultDir(QDir::homePath());
    dialog.setMimeTypeFilters(QStringList() << "application/x-krita-palette" << "application/x-gimp-color-palette");
 
    QString filename = dialog.filename();
    if (filename.isEmpty()) {
        return nullptr;
    }
 
    QMessageBox messageBox;
    messageBox.setText(i18n("Do you want to store this palette in your current image?"));
    messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    QString storageLocation = "";
    if (messageBox.exec() == QMessageBox::Yes) {
        storageLocation = m_d->view->document()->linkedResourcesStorageId();
    }
    KoResourceSP resource = KisResourceUserOperations::importResourceFileWithUserInput(m_d->view->mainWindowAsQWidget(), storageLocation, ResourceType::Palettes, filename);
 
    KoColorSetSP palette;
    if (resource) {
        palette = resource.dynamicCast<KoColorSet>();
    }
 
    return palette;
}

References KisResourceUserOperations::importResourceFileWithUserInput(), m_d, KoFileDialog::OpenFile, palette, and ResourceType::Palettes.

isModified()

bool KisPaletteEditor::isModified

(

)

const

Definition at line 485 of file KisPaletteEditor.cpp.

{
    if (m_d->model->colorSet()) {
        return m_d->model->colorSet()->isDirty();
    } else {
        return false;
    }
}

References m_d.

modifyEntry()

void KisPaletteEditor::modifyEntry

(

const QModelIndex &

index

)

Definition at line 385 of file KisPaletteEditor.cpp.

{
    if (!m_d->view) { return; }
    if (!m_d->view->document()) { return; }
 
    KoDialog dialog;
    dialog.setCaption(i18nc("@title:dialog", "Add a new Color Swatch"));
    QFormLayout *editableItems = new QFormLayout(dialog.mainWidget());
 
    QString groupName = qvariant_cast<QString>(index.data(Qt::DisplayRole));
    if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
        startEditing();
        renameGroup(groupName);
        endEditing();
    }
    else {
 
        QLineEdit *lnIDName = new QLineEdit();
        QLineEdit *lnGroupName = new QLineEdit();
        KisColorButton *bnColor = new KisColorButton();
        QCheckBox *chkSpot = new QCheckBox();
        chkSpot->setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
 
        KisSwatch entry = m_d->model->getSwatch(index);
 
        editableItems->addRow(i18n("Swatch ID:"), lnIDName);
        editableItems->addRow(i18n("Color swatch name:"), lnGroupName);
        editableItems->addRow(i18nc("Color as the Color of a Swatch in a Palette", "Color:"), bnColor);
        editableItems->addRow(i18n("Spot color:"), chkSpot);
 
        lnGroupName->setText(entry.name());
        lnIDName->setText(entry.id());
        bnColor->setColor(entry.color());
        chkSpot->setChecked(entry.spotColor());
 
        if (dialog.exec() == KoDialog::Accepted) {
            entry.setName(lnGroupName->text());
            entry.setId(lnIDName->text());
            entry.setColor(bnColor->color());
            entry.setSpotColor(chkSpot->isChecked());
            m_d->model->setSwatch(entry, index);
        }
    }
}

References KisSwatch::color(), KisColorButton::color, endEditing(), KisSwatch::id(), KisPaletteModel::IsGroupNameRole, m_d, KisSwatch::name(), renameGroup(), KisColorButton::setColor(), KisSwatch::setColor(), KisSwatch::setId(), KisSwatch::setName(), KisSwatch::setSpotColor(), KisSwatch::spotColor(), and startEditing().

newGroupName()

QString KisPaletteEditor::newGroupName ( ) const

private

Definition at line 614 of file KisPaletteEditor.cpp.

{
    int i = 1;
    QString groupname = i18nc("Default new group name", "New Group %1", QString::number(i));
    while (m_d->modifiedPaletteInfo.groups.contains(groupname)) {
        i++;
        groupname = i18nc("Default new group name", "New Group %1", QString::number(i));
    }
    return groupname;
}

References m_d.

oldNameFromNewName()

QString KisPaletteEditor::oldNameFromNewName

(

const QString &

newName

)

const

oldNameFromNewName

Parameters

newName

the current name of a group

Returns

the name of the group at the creation of the instance

Definition at line 208 of file KisPaletteEditor.cpp.

{
    Q_FOREACH (const QString &oldGroupName, m_d->modifiedPaletteInfo.groups.keys()) {
        if (m_d->modifiedPaletteInfo.groups[oldGroupName]->name() == newName) {
            return oldGroupName;
        }
    }
    return QString();
}

References m_d.

removeEntry()

void KisPaletteEditor::removeEntry

(

const QModelIndex &

index

)

Definition at line 371 of file KisPaletteEditor.cpp.

{
    Q_ASSERT(m_d->model);
    if (!m_d->view) { return; }
    if (!m_d->view->document()) { return; }
    if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
        startEditing();
        removeGroup(qvariant_cast<QString>(index.data(KisPaletteModel::GroupNameRole)));
        endEditing();
    } else {
        m_d->model->removeSwatch(index, false);
    }
}

References endEditing(), KisPaletteModel::GroupNameRole, KisPaletteModel::IsGroupNameRole, m_d, removeGroup(), and startEditing().

removeGroup()

bool KisPaletteEditor::removeGroup

(

const QString &

name

)

Stage the removal of a group.

Parameters

name	original group name

Returns

true if change accepted, false if cancelled

Definition at line 270 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return false;
    }
    KoDialog dialog;
    dialog.setWindowTitle(i18nc("@title:dialog", "Removing Swatch Group"));
    QFormLayout *editableItems = new QFormLayout(dialog.mainWidget());
    QCheckBox *chkKeep = new QCheckBox();
 
    editableItems->addRow(i18nc("Shows up when deleting a swatch group", "Keep the Colors"), chkKeep);
    if (dialog.exec() != KoDialog::Accepted) { return false; }
 
    m_d->modifiedPaletteInfo.groups.remove(name);
    m_d->newGroupNames.remove(name);
    if (chkKeep->isChecked()) {
        m_d->keepColorGroups.insert(name);
    }
    return true;
}

References m_d.

removePalette()

void KisPaletteEditor::removePalette

(

KoColorSetSP

cs

)

Definition at line 168 of file KisPaletteEditor.cpp.

{
    if (!m_d->view) { return; }
    if (!m_d->view->document()) { return; }
    if (!cs) { return; }
    m_d->rServer->removeResourceFromServer(cs);
}

References m_d.

rename()

void KisPaletteEditor::rename

(

const QString &

newName

)

Stage a palette rename.

Parameters

newName

Definition at line 218 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return;
    }
    if (newName.isEmpty()) { return; }
    m_d->modifiedPaletteInfo.name = newName;
}

References m_d.

renameGroup()

QString KisPaletteEditor::renameGroup

(

const QString &

oldName

)

Stage a rename of a group.

Parameters

oldName

Returns

new name if change accepted, empty string if cancelled

Definition at line 291 of file KisPaletteEditor.cpp.

{
    if (!m_d->isEditing) {
        return QString();
    }
    if (oldName.isEmpty() || oldName == KoColorSet::GLOBAL_GROUP_NAME) { return QString(); }
 
    KoDialog dialog;
    m_d->query = &dialog;
    m_d->groupBeingRenamed = m_d->modifiedPaletteInfo.groups[oldName]->name();
 
    QFormLayout *form = new QFormLayout(dialog.mainWidget());
 
    QLineEdit *leNewName = new QLineEdit();
    connect(leNewName, SIGNAL(textChanged(QString)), SLOT(slotGroupNameChanged(QString)));
    leNewName->setText(m_d->modifiedPaletteInfo.groups[oldName]->name());
 
    form->addRow(i18n("New swatch group name:"), leNewName);
 
    if (dialog.exec() != KoDialog::Accepted) { return QString(); }
    if (leNewName->text().isEmpty()) { return QString(); }
    if (duplicateExistsGroupName(leNewName->text())) { return QString(); }
 
    m_d->modifiedPaletteInfo.groups[oldName]->setName(leNewName->text());
    m_d->modifiedGroupNames.insert(oldName);
 
    return leNewName->text();
}

References connect(), duplicateExistsGroupName(), KoColorSet::GLOBAL_GROUP_NAME, m_d, and slotGroupNameChanged().

rowCountOfGroup()

int KisPaletteEditor::rowCountOfGroup

(

const QString &

originalName

)

const

rowCountOfGroup

Parameters

originalName

the original name of a group at the creation of the instance

Returns

newest row number of the group

Definition at line 176 of file KisPaletteEditor.cpp.

{
    if (!m_d->modifiedPaletteInfo.groups.contains(originalName)) {
        KoColorSetSP colorSet = m_d->model->colorSet();
        if (originalName.isEmpty()) {
            return colorSet->getGlobalGroup()->rowCount();
        }
        else {
            KisSwatchGroupSP group = colorSet->getGroup(originalName);
            if (group ){
                return group->rowCount();
            }
        }
        return 0;
    }
    return m_d->modifiedPaletteInfo.groups[originalName]->rowCount();
}

References m_d.

saveNewPaletteVersion()

void KisPaletteEditor::saveNewPaletteVersion

(

)

saveNewPaletteVersion

Definition at line 581 of file KisPaletteEditor.cpp.

{
    if (!m_d->model || !m_d->model->colorSet()) { return; }
 
    QModelIndex index = m_d->rServer->resourceModel()->indexForResource(m_d->model->colorSet());
    bool isGlobal = false;
    if (index.isValid()) {
        bool ok = false;
        int storageId = m_d->rServer->resourceModel()->data(index, Qt::UserRole + KisAllResourcesModel::StorageId).toInt(&ok);
        if (ok) {
            KisStorageModel storageModel;
            KisResourceStorageSP storage = storageModel.storageForId(storageId);
            isGlobal = storage->type() != KisResourceStorage::StorageType::Memory;
        }
    }
    bool res = false;
    if (isGlobal) {
        if (m_d->view) {
            res = KisResourceUserOperations::updateResourceWithUserInput(m_d->view->mainWindowAsQWidget(), m_d->model->colorSet());
        } else if (m_d->model->colorSet()->version() >= 0) {
            //if the version is -1, then the resource should not be updated, because it was never saved to begin with...
            res = m_d->rServer->resourceModel()->updateResource(m_d->model->colorSet());
            dbgResources << Q_FUNC_INFO << "-- Updating resource without user input: " << m_d->model->colorSet()->name() << "Result:" << res;
        }
    }
}

References dbgResources, m_d, KisResourceStorage::Memory, KisStorageModel::storageForId(), KisAbstractResourceModel::StorageId, and KisResourceUserOperations::updateResourceWithUserInput().

setEntry()

void KisPaletteEditor::setEntry	(	const KoColor &	color,
		const QModelIndex &	index )

Definition at line 351 of file KisPaletteEditor.cpp.

{
    Q_ASSERT(m_d->model);
    if (!m_d->view) { return; }
    if (!m_d->view->document()) { return; }
    KisSwatch c = KisSwatch(color);
    c.setId(QString::number(m_d->model->colorSet()->colorCount() + 1));
    c.setName(i18nc("Default name for a color swatch","Color %1", QString::number(m_d->model->colorSet()->colorCount()+1)));
    m_d->model->setSwatch(c, index);
}

References m_d, KisSwatch::setId(), and KisSwatch::setName().

setPaletteModel()

void KisPaletteEditor::setPaletteModel

(

KisPaletteModel *

model

)

Definition at line 73 of file KisPaletteEditor.cpp.

{
    if (!model) { return; }
    if (m_d->model) {
        m_d->model->disconnect(this);
    }
    m_d->model = model;
    slotPaletteChanged();
    connect(model, SIGNAL(sigPaletteChanged()), SLOT(slotPaletteChanged()));
    connect(model, SIGNAL(sigPaletteModified()), SLOT(slotSetDocumentModified()));
}

References connect(), m_d, slotPaletteChanged(), and slotSetDocumentModified().

setStorageLocation()

void KisPaletteEditor::setStorageLocation

(

QString

location

)

Definition at line 346 of file KisPaletteEditor.cpp.

{
   m_d->modifiedPaletteInfo.storageLocation = location;
}

References m_d.

setView()

void KisPaletteEditor::setView

(

KisViewManager *

view

)

Definition at line 85 of file KisPaletteEditor.cpp.

{
    m_d->view = view;
}

References m_d.

slotGroupNameChanged

void KisPaletteEditor::slotGroupNameChanged ( const QString & newName )

privateslot

Definition at line 320 of file KisPaletteEditor.cpp.

{
    QLineEdit *leGroupName = qobject_cast<QLineEdit*>(sender());
    if (duplicateExistsGroupName(newName) || newName == QString()) {
        leGroupName->setPalette(m_d->warnPalette);
        if (m_d->query->button(KoDialog::Ok)) {
            m_d->query->button(KoDialog::Ok)->setEnabled(false);
        }
        return;
    }
    leGroupName->setPalette(m_d->normalPalette);
    if (m_d->query->button(KoDialog::Ok)) {
        m_d->query->button(KoDialog::Ok)->setEnabled(true);
    }
}

References duplicateExistsGroupName(), m_d, and KoDialog::Ok.

slotPaletteChanged

void KisPaletteEditor::slotPaletteChanged ( )

privateslot

Definition at line 608 of file KisPaletteEditor.cpp.

{
    Q_ASSERT(m_d->model);
    clearStagedChanges();
}

References clearStagedChanges(), and m_d.

slotSetDocumentModified

void KisPaletteEditor::slotSetDocumentModified ( )

privateslot

Definition at line 362 of file KisPaletteEditor.cpp.

{
    if (m_d->modifiedPaletteInfo.storageLocation == m_d->view->document()->linkedResourcesStorageId()) {
        KisResourceUserOperations::updateResourceWithUserInput(m_d->view->mainWindowAsQWidget(), m_d->model->colorSet());
        m_d->view->document()->setModified(true);
    }
    m_d->model->colorSet()->setDirty(true);
}

References m_d, and KisResourceUserOperations::updateResourceWithUserInput().

startEditing()

void KisPaletteEditor::startEditing

(

)

Start editing the current palette.

This must be called before any calls that stage changes, otherwise those calls have no effect. All staged changes get applied when calling endEditing().

Adding, removing and updating swatches happens immediately

Definition at line 494 of file KisPaletteEditor.cpp.

{
    if (m_d->isEditing) {
        qWarning() << "KisPaletteEditor::startEditing(): restarting palette editing.";
        clearStagedChanges();
    }
 
    if (!m_d->model || !m_d->model->colorSet()) {
        return;
    }
    KoColorSetSP palette = m_d->model->colorSet();
 
    m_d->modifiedPaletteInfo.name = palette->name();
    m_d->modifiedPaletteInfo.storageLocation = palette->storageLocation();
    m_d->modifiedPaletteInfo.columnCount = palette->columnCount();
    m_d->modifiedPaletteInfo.groups.clear();
 
    Q_FOREACH (const QString &groupName, palette->swatchGroupNames()) {
        KisSwatchGroupSP cs(new KisSwatchGroup(*palette->getGroup(groupName).data()));
        m_d->modifiedPaletteInfo.groups.insert(groupName, cs);
    }
 
    m_d->isEditing = true;
}

References clearStagedChanges(), m_d, and palette.

Member Data Documentation

m_d

QScopedPointer<Private> KisPaletteEditor::m_d

private

Definition at line 147 of file KisPaletteEditor.h.

---

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

• libs/ui/KisPaletteEditor.h
• libs/ui/KisPaletteEditor.cpp