KisDlgInternalColorSelector Class Reference

The KisInternalColorSelector class. More...

#include <KisDlgInternalColorSelector.h>

Inheritance diagram for KisDlgInternalColorSelector:

Classes
struct	Config
struct	Private

Public Slots
void	reject () override
void	setPreviousColor (KoColor c)
	setPreviousColor set the previous color.
void	slotColorUpdated (KoColor newColor)
	slotColorUpdated Very important slot. Is connected to krita's resources to make sure it has the currently active color. It's very important that this function is able to understand when the signal came from itself.
void	slotSetColorFromPatch (KoColorPatch *patch)
	slotSetColorFromPatch update current color from kocolorpatch.

Signals
void	signalForegroundColorChosen (KoColor color)
	signalForegroundColorChosen The most important signal. This will sent out when a color has been chosen from the selector. There will be a small delay to make sure that the selector causes too many updates.

Public Member Functions
void	chooseAlpha (bool chooseAlpha)
void	colorSpaceChanged (const KoColorSpace *cs)
	slotColorSpaceChanged Color space has changed, use this dialog to change the colorspace.
KoColor	getCurrentColor ()
	getCurrentColor
	KisDlgInternalColorSelector (QWidget *parent, KoColor color, Config config, const QString &caption, const KoColorDisplayRendererInterface *displayRenderer=KoDumbColorDisplayRenderer::instance())
void	lockUsedColorSpace (const KoColorSpace *cs)
	lockUsedColorSpace Lock the used colorspace of this selector.
void	setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer)
	setDisplayRenderer Set the display renderer. This is necessary for HDR color manage support.
	~KisDlgInternalColorSelector () override

Static Public Member Functions
static KoColor	getModalColorDialog (const KoColor color, QWidget *parent=0, QString caption=QString())
	getModalColorDialog Execute this dialog modally. The function returns the KoColor you want.
static void	setScreenColorSamplerFactory (std::function< KisScreenColorSamplerBase *(QWidget *)> f)

Protected Member Functions
void	showEvent (QShowEvent *event) override

Private Slots
void	endUpdateWithNewColor ()
void	slotChangePalette (KoColorSetSP set)
void	slotFinishUp ()
	slotFinishUp This is called when the selector is closed, for saving the current palette.
void	slotSelectorModelChanged ()
void	slotSetColorFromHex ()
	slotSetColorFromHex Update from the hex color input.

Private Member Functions
void	focusInEvent (QFocusEvent *) override
void	updateAllElements (QObject *source)
	updateAllElements Updates each widget with the new element, and if it's responsible for the update sents a signal out that there's a new color.

Private Attributes
const QScopedPointer< Private >	m_d
Ui_WdgDlgInternalColorSelector *	m_ui

Static Private Attributes
static std::function< KisScreenColorSamplerBase *(QWidget *)	s_screenColorSamplerFactory )

Detailed Description

The KisInternalColorSelector class.

A non-modal color selector dialog that is not a plugin and can thus be used for filters.

Definition at line 29 of file KisDlgInternalColorSelector.h.

Constructor & Destructor Documentation

KisDlgInternalColorSelector()

KisDlgInternalColorSelector::KisDlgInternalColorSelector	(	QWidget *	parent,
		KoColor	color,
		Config	config,
		const QString &	caption,
		const KoColorDisplayRendererInterface *	displayRenderer = KoDumbColorDisplayRenderer::instance() )

Definition at line 57 of file KisDlgInternalColorSelector.cpp.

    : QDialog(parent)
    , m_d(new Private)
{
    setModal(config.modal);
    setFocusPolicy(Qt::ClickFocus);
    m_ui = new Ui_WdgDlgInternalColorSelector();
    m_ui->setupUi(this);
 
    setWindowTitle(caption);
 
    m_d->selectorModel = m_ui->visualSelector->selectorModel();
 
    m_d->currentColor = color;
    m_d->currentColorSpace = m_d->currentColor.colorSpace();
    m_d->displayRenderer = displayRenderer;
 
    m_ui->spinboxselector->slotSetColor(color);
    connect(m_ui->spinboxselector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
 
    m_ui->spinboxHSXSelector->setModel(m_d->selectorModel);
 
    m_ui->visualSelector->setDisplayRenderer(displayRenderer);
    m_ui->visualSelector->setConfig(false, config.modal);
    if (config.visualColorSelector) {
        connect(m_d->selectorModel.data(), SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
        connect(m_d->selectorModel.data(), SIGNAL(sigColorModelChanged()), this, SLOT(slotSelectorModelChanged()));
        connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_ui->visualSelector, SLOT(slotConfigurationChanged()));
    } else {
        m_ui->visualSelector->hide();
    }
    m_ui->visualSelector->slotSetColor(color);
 
    m_d->paletteChooser = new KisPaletteChooser(this);
    m_d->paletteModel = new KisPaletteModel(this);
    m_ui->bnPaletteChooser->setIcon(KisIconUtils::loadIcon("palette-library"));
    m_ui->bnPaletteChooser->setToolTip(i18n("Load a palette"));
    m_ui->paletteBox->setPaletteModel(m_d->paletteModel);
    m_ui->paletteBox->setDisplayRenderer(displayRenderer);
    m_ui->cmbNameList->setCompanionView(m_ui->paletteBox);
    connect(m_d->paletteChooser, SIGNAL(sigPaletteSelected(KoColorSetSP)), this, SLOT(slotChangePalette(KoColorSetSP)));
    connect(m_ui->cmbNameList, SIGNAL(sigColorSelected(KoColor)), SLOT(slotColorUpdated(KoColor)));
 
    // For some bizarre reason, the modal dialog doesn't like having the colorset set, so let's not.
    if (config.paletteBox) {
        //TODO: Add disable signal as well. Might be not necessary...?
        KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
        QString paletteMd5 = cfg.readEntry("internal_selector_active_color_set_md5", QString());
        QString paletteName = cfg.readEntry("internal_selector_active_color_set", QString());
        KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
        KoColorSetSP savedPal = rServer->resource(paletteMd5, "", paletteName);
        if (savedPal) {
            this->slotChangePalette(savedPal);
        } else {
            if (rServer->resourceCount()) {
                savedPal = rServer->firstResource();
                if (savedPal) {
                    this->slotChangePalette(savedPal);
                }
            }
        }
 
        connect(m_ui->paletteBox, SIGNAL(sigColorSelected(KoColor)), this,
                SLOT(slotColorUpdated(KoColor)));
        m_ui->bnPaletteChooser->setPopupWidget(m_d->paletteChooser);
    } else {
        m_ui->paletteBox->setEnabled(false);
        m_ui->cmbNameList->setEnabled(false);
        m_ui->bnPaletteChooser->setEnabled(false);
    }
 
    if (config.prevNextButtons) {
        m_ui->currentColor->setColor(m_d->currentColor);
        m_ui->currentColor->setDisplayRenderer(displayRenderer);
        m_ui->previousColor->setColor(m_d->previousColor);
        m_ui->previousColor->setDisplayRenderer(displayRenderer);
        connect(m_ui->previousColor, SIGNAL(triggered(KoColorPatch*)), SLOT(slotSetColorFromPatch(KoColorPatch*)));
    } else {
        m_ui->currentColor->hide();
        m_ui->previousColor->hide();
    }
 
    if (config.hexInput) {
        m_d->sRGB.fromKoColor(m_d->currentColor);
        m_d->hexColorInput = new KisHexColorInput(this, &m_d->sRGB);
        m_d->hexColorInput->update();
        connect(m_d->hexColorInput, SIGNAL(updated()), SLOT(slotSetColorFromHex()));
        m_ui->rightPane->addWidget(m_d->hexColorInput);
        m_d->hexColorInput->setToolTip(i18n("This is a hexcode input, for webcolors. It can only get colors in the sRGB space."));
    }
 
    // KisScreenColorSampler is in the kritaui module, so dependency inversion is used to access it.
    m_ui->screenColorSamplerWidget->setLayout(new QHBoxLayout());
    if (s_screenColorSamplerFactory) {
        m_d->screenColorSampler = s_screenColorSamplerFactory(m_ui->screenColorSamplerWidget);
        m_ui->screenColorSamplerWidget->layout()->addWidget(m_d->screenColorSampler);
        if (config.screenColorSampler) {
            connect(m_d->screenColorSampler, SIGNAL(sigNewColorSampled(KoColor)),this, SLOT(slotColorUpdated(KoColor)));
        } else {
            m_d->screenColorSampler->hide();
        }
    }
 
    m_d->compressColorChanges = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
    connect(m_d->compressColorChanges, SIGNAL(timeout()), this, SLOT(endUpdateWithNewColor()));
 
    KGuiItem::assign(m_ui->buttonBox->button(QDialogButtonBox::Ok), KStandardGuiItem::ok());
    KGuiItem::assign(m_ui->buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
    connect(m_ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept()), Qt::UniqueConnection);
    connect(m_ui->buttonBox, SIGNAL(rejected()), this, SLOT(reject()), Qt::UniqueConnection);
 
    connect(this, SIGNAL(finished(int)), SLOT(slotFinishUp()));
}

References KoColor::colorSpace(), connect(), endUpdateWithNewColor(), KoResourceServer< T >::firstResource(), KisDlgInternalColorSelector::Config::hexInput, KisConfigNotifier::instance(), KoResourceServerProvider::instance(), KisIconUtils::loadIcon(), m_d, m_ui, KisDlgInternalColorSelector::Config::modal, KisDlgInternalColorSelector::Config::paletteBox, KoResourceServerProvider::paletteServer, KisSignalCompressor::POSTPONE, KisDlgInternalColorSelector::Config::prevNextButtons, reject(), KoResourceServer< T >::resource(), KoResourceServer< T >::resourceCount(), s_screenColorSamplerFactory, KisDlgInternalColorSelector::Config::screenColorSampler, slotChangePalette(), slotColorUpdated(), slotFinishUp(), slotSelectorModelChanged(), slotSetColorFromHex(), slotSetColorFromPatch(), and KisDlgInternalColorSelector::Config::visualColorSelector.

~KisDlgInternalColorSelector()

KisDlgInternalColorSelector::~KisDlgInternalColorSelector ( )

override

Definition at line 171 of file KisDlgInternalColorSelector.cpp.

{
    delete m_ui;
}

References m_ui.

Member Function Documentation

chooseAlpha()

void KisDlgInternalColorSelector::chooseAlpha

(

bool

chooseAlpha

)

Definition at line 257 of file KisDlgInternalColorSelector.cpp.

{
    m_d->chooseAlpha = chooseAlpha;
}

References chooseAlpha(), and m_d.

colorSpaceChanged()

void KisDlgInternalColorSelector::colorSpaceChanged

(

const KoColorSpace *

cs

)

slotColorSpaceChanged Color space has changed, use this dialog to change the colorspace.

Definition at line 207 of file KisDlgInternalColorSelector.cpp.

{
    if (cs == m_d->currentColorSpace) {
        return;
    }
 
    m_d->currentColorSpace = KoColorSpaceRegistry::instance()->colorSpace(cs->colorModelId().id(), cs->colorDepthId().id(), cs->profile());
    m_ui->spinboxselector->slotSetColorSpace(m_d->currentColorSpace);
    m_ui->visualSelector->slotSetColorSpace(m_d->currentColorSpace);
 
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoColorSpaceRegistry::colorSpace(), KoID::id(), KoColorSpaceRegistry::instance(), m_d, m_ui, and KoColorSpace::profile().

endUpdateWithNewColor

void KisDlgInternalColorSelector::endUpdateWithNewColor ( )

privateslot

Definition at line 341 of file KisDlgInternalColorSelector.cpp.

{
    Q_EMIT signalForegroundColorChosen(m_d->currentColor);
    m_d->allowUpdates = true;
}

References m_d, and signalForegroundColorChosen().

focusInEvent()

void KisDlgInternalColorSelector::focusInEvent ( QFocusEvent * )

overrideprivate

Definition at line 347 of file KisDlgInternalColorSelector.cpp.

{
    //setPreviousColor();
}

getCurrentColor()

KoColor KisDlgInternalColorSelector::getCurrentColor

(

)

getCurrentColor

Returns

gives currently active color;

Definition at line 252 of file KisDlgInternalColorSelector.cpp.

{
    return m_d->currentColor;
}

References m_d.

getModalColorDialog()

KoColor KisDlgInternalColorSelector::getModalColorDialog ( const KoColor color, QWidget * parent = 0, QString caption = QString() )

static

getModalColorDialog Execute this dialog modally. The function returns the KoColor you want.

Parameters

color	- The current color. Make sure this is in the color space you want your end color to be in.
parent	parent widget.
caption	the dialog caption.

Definition at line 243 of file KisDlgInternalColorSelector.cpp.

{
    Config config = Config();
    KisDlgInternalColorSelector dialog(parent, color, config, caption);
    dialog.setPreviousColor(color);
    dialog.exec();
    return dialog.getCurrentColor();
}

lockUsedColorSpace()

void KisDlgInternalColorSelector::lockUsedColorSpace

(

const KoColorSpace *

cs

)

lockUsedColorSpace Lock the used colorspace of this selector.

Parameters

cs

Definition at line 219 of file KisDlgInternalColorSelector.cpp.

{
    colorSpaceChanged(cs);
    if (m_d->currentColor.colorSpace() != m_d->currentColorSpace) {
        m_d->currentColor.convertTo(m_d->currentColorSpace);
        m_ui->spinboxselector->slotSetColor(m_d->currentColor);
        m_ui->visualSelector->slotSetColor(m_d->currentColor);
    }
    m_d->lockUsedCS = true;
}

References colorSpaceChanged(), m_d, and m_ui.

reject

void KisDlgInternalColorSelector::reject ( )

overrideslot

Definition at line 267 of file KisDlgInternalColorSelector.cpp.

{
    slotColorUpdated(m_d->previousColor);
    QDialog::reject();
}

References m_d, and slotColorUpdated().

setDisplayRenderer()

void KisDlgInternalColorSelector::setDisplayRenderer

(

const KoColorDisplayRendererInterface *

displayRenderer

)

setDisplayRenderer Set the display renderer. This is necessary for HDR color manage support.

Parameters

displayRenderer

Definition at line 230 of file KisDlgInternalColorSelector.cpp.

{
    if (displayRenderer) {
        m_d->displayRenderer = displayRenderer;
        m_ui->visualSelector->setDisplayRenderer(displayRenderer);
        m_ui->currentColor->setDisplayRenderer(displayRenderer);
        m_ui->previousColor->setDisplayRenderer(displayRenderer);
        m_ui->paletteBox->setDisplayRenderer(displayRenderer);
    } else {
        m_d->displayRenderer = KoDumbColorDisplayRenderer::instance();
    }
}

References KoDumbColorDisplayRenderer::instance(), m_d, and m_ui.

setPreviousColor

void KisDlgInternalColorSelector::setPreviousColor ( KoColor c )

slot

setPreviousColor set the previous color.

Definition at line 262 of file KisDlgInternalColorSelector.cpp.

{
    m_d->previousColor = c;
}

References m_d.

setScreenColorSamplerFactory()

static void KisDlgInternalColorSelector::setScreenColorSamplerFactory ( std::function< KisScreenColorSamplerBase *(QWidget *)> f )

inlinestatic

Definition at line 37 of file KisDlgInternalColorSelector.h.

                                                                                                    {
        s_screenColorSamplerFactory = f;
    }

showEvent()

void KisDlgInternalColorSelector::showEvent ( QShowEvent * event )

overrideprotected

Definition at line 377 of file KisDlgInternalColorSelector.cpp.

{
    updateAllElements(0);
    QDialog::showEvent(event);
}

References updateAllElements().

signalForegroundColorChosen

void KisDlgInternalColorSelector::signalForegroundColorChosen ( KoColor color )

signal

signalForegroundColorChosen The most important signal. This will sent out when a color has been chosen from the selector. There will be a small delay to make sure that the selector causes too many updates.

Do not connect this to slotColorUpdated.

Parameters

color

The new color chosen

slotChangePalette

void KisDlgInternalColorSelector::slotChangePalette ( KoColorSetSP set )

privateslot

Definition at line 369 of file KisDlgInternalColorSelector.cpp.

{
    if (!set) {
        return;
    }
    m_d->paletteModel->setColorSet(set);
}

References m_d.

slotColorUpdated

void KisDlgInternalColorSelector::slotColorUpdated ( KoColor newColor )

slot

slotColorUpdated Very important slot. Is connected to krita's resources to make sure it has the currently active color. It's very important that this function is able to understand when the signal came from itself.

Parameters

newColor

This is the new color.

Definition at line 176 of file KisDlgInternalColorSelector.cpp.

{
    // not-so-nice solution: if someone calls this slot directly and that code was
    // triggered by our compressor signal, our compressor is technically the sender()!
    if (sender() == m_d->compressColorChanges) {
        return;
    }
    // Do not accept external updates while a color update Q_EMIT is pending;
    // Note: Assumes external updates only come from parent(), a separate slot might be better
    if (m_d->allowUpdates || (QObject::sender() && QObject::sender() != this->parent())) {
        // Enforce palette colors
        KConfigGroup group(KSharedConfig::openConfig(), "");
        if (group.readEntry("colorsettings/forcepalettecolors", false)) {
            newColor = m_ui->paletteBox->closestColor(newColor);
        }
 
        if (m_d->lockUsedCS){
            newColor.convertTo(m_d->currentColorSpace);
        } else {
            colorSpaceChanged(newColor.colorSpace());
        }
        m_d->currentColor = newColor;
        updateAllElements(QObject::sender());
    }
}

References KoColor::colorSpace(), colorSpaceChanged(), KoColor::convertTo(), m_d, m_ui, and updateAllElements().

slotFinishUp

void KisDlgInternalColorSelector::slotFinishUp ( )

privateslot

slotFinishUp This is called when the selector is closed, for saving the current palette.

Definition at line 352 of file KisDlgInternalColorSelector.cpp.

{
    setPreviousColor(m_d->currentColor);
    KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
    if (m_d->paletteModel) {
        if (m_d->paletteModel->colorSet()) {
            cfg.writeEntry("internal_selector_active_color_set_md5", m_d->paletteModel->colorSet()->md5Sum());
            cfg.writeEntry("internal_selector_active_color_set", m_d->paletteModel->colorSet()->name());
        }
    }
}

References m_d, and setPreviousColor().

slotSelectorModelChanged

void KisDlgInternalColorSelector::slotSelectorModelChanged ( )

privateslot

Definition at line 307 of file KisDlgInternalColorSelector.cpp.

{
    if (m_d->selectorModel->isHSXModel()) {
        QString label;
        switch (m_d->selectorModel->colorModel()) {
        case KisVisualColorModel::HSV:
            label = i18n("HSV");
            break;
        case KisVisualColorModel::HSL:
            label = i18n("HSL");
            break;
        case KisVisualColorModel::HSI:
            label = i18n("HSI");
            break;
        case KisVisualColorModel::HSY:
            label = i18n("HSY'");
            break;
        default:
            label =  i18n("Unknown");
        }
        if (m_ui->tabWidget->count() == 1) {
            m_ui->tabWidget->addTab(m_ui->tab_hsx, label);
        }
        else {
            m_ui->tabWidget->setTabText(1, label);
        }
    }
    else {
        if (m_ui->tabWidget->count() == 2) {
            m_ui->tabWidget->removeTab(1);
        }
    }
}

References KisVisualColorModel::HSI, KisVisualColorModel::HSL, KisVisualColorModel::HSV, KisVisualColorModel::HSY, m_d, and m_ui.

slotSetColorFromHex

void KisDlgInternalColorSelector::slotSetColorFromHex ( )

privateslot

slotSetColorFromHex Update from the hex color input.

Definition at line 364 of file KisDlgInternalColorSelector.cpp.

{
    slotColorUpdated(m_d->sRGB);
}

References m_d, and slotColorUpdated().

slotSetColorFromPatch

void KisDlgInternalColorSelector::slotSetColorFromPatch ( KoColorPatch * patch )

slot

slotSetColorFromPatch update current color from kocolorpatch.

Parameters

patch

Definition at line 202 of file KisDlgInternalColorSelector.cpp.

{
    slotColorUpdated(patch->color());
}

References KoColorPatch::color(), and slotColorUpdated().

updateAllElements()

void KisDlgInternalColorSelector::updateAllElements ( QObject * source )

private

updateAllElements Updates each widget with the new element, and if it's responsible for the update sents a signal out that there's a new color.

Definition at line 273 of file KisDlgInternalColorSelector.cpp.

{
    //update everything!!!
    if (source != m_ui->spinboxselector) {
        m_ui->spinboxselector->slotSetColor(m_d->currentColor);
    }
 
    if (source != m_ui->visualSelector) {
        m_ui->visualSelector->slotSetColor(m_d->currentColor);
    }
 
    if (source != m_d->hexColorInput) {
        m_d->sRGB.fromKoColor(m_d->currentColor);
        m_d->hexColorInput->update();
    }
 
    if (source != m_ui->paletteBox) {
        m_ui->paletteBox->selectClosestColor(m_d->currentColor);
    }
 
    m_ui->previousColor->setColor(m_d->previousColor);
 
    m_ui->currentColor->setColor(m_d->currentColor);
 
    if (source && source != this->parent()) {
        m_d->allowUpdates = false;
        m_d->compressColorChanges->start();
    }
 
    if (m_d->screenColorSampler) {
        m_d->screenColorSampler->updateIcons();
    }
}

References m_d, m_ui, and source().

Member Data Documentation

m_d

const QScopedPointer<Private> KisDlgInternalColorSelector::m_d

private

Definition at line 173 of file KisDlgInternalColorSelector.h.

m_ui

Ui_WdgDlgInternalColorSelector* KisDlgInternalColorSelector::m_ui

private

Definition at line 171 of file KisDlgInternalColorSelector.h.

s_screenColorSamplerFactory

std::function<KisScreenColorSamplerBase *(QWidget *) KisDlgInternalColorSelector::s_screenColorSamplerFactory)

staticprivate

Definition at line 33 of file KisDlgInternalColorSelector.h.

---

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

• libs/widgets/KisDlgInternalColorSelector.h
• libs/widgets/KisDlgInternalColorSelector.cpp