#include <kis_specific_color_selector_widget.h>

Inheritance diagram for KisSpecificColorSelectorWidget:

Public Slots
void	setColor (const KoColor &)

void	setColorSpace (const KoColorSpace *cs, bool force=false)

void	setDisplayConverter (KisDisplayColorConverter *colorConverter)

void	setFGColor (const KoColor &c)

Signals
void	colorChanged (const KoColor &)

void	updated ()

Public Member Functions
	KisSpecificColorSelectorWidget (QWidget *parent)

	~KisSpecificColorSelectorWidget () override

Protected Member Functions
void	resizeEvent (QResizeEvent *event) override

Private Slots
void	changeHsxMode (int index)

void	hsvSelectorClicked (QAbstractButton *)

void	onChkUsePercentageChanged (bool)

void	rereadCurrentColorSpace (bool force=false)

void	setCustomColorSpace (const KoColorSpace *)

void	setUseSameColorSpace (bool locked, bool reloadColorSpace=true)

void	update ()

void	updateTimeout ()

Private Member Functions
void	updateHsvSelector (bool isRgbColorSpace)

Private Attributes
KoColor	m_color

const KoColorSpace *	m_colorSpace

KisColorSpaceSelector *	m_colorspaceSelector

KisSignalAutoConnectionsStore	m_converterConnection

KisDisplayColorConverter *	m_displayConverter

KoColor	m_FGColor

KisHexColorInput *	m_hexInput

QButtonGroup *	m_hsvSelector

KisHsvColorInput *	m_hsvSlider

QRadioButton *	m_hsxButton

QComboBox *	m_hsxModeComboBox

QList< KisColorInput * >	m_inputs

QRadioButton *	m_rgbButton

QScopedPointer< Ui_wdgSpecificColorSelectorWidget >	m_ui

bool	m_updateAllowed

KisSignalCompressor *	m_updateCompressor

Detailed Description

Definition at line 33 of file kis_specific_color_selector_widget.h.

Constructor & Destructor Documentation

◆ KisSpecificColorSelectorWidget()

KisSpecificColorSelectorWidget::KisSpecificColorSelectorWidget ( QWidget * parent )

Definition at line 37 of file kis_specific_color_selector_widget.cc.

    : QWidget(parent)
    , m_inputs()
    , m_hexInput(nullptr)
    , m_hsvSlider(nullptr)
    , m_rgbButton(nullptr)
    , m_hsxButton(nullptr)
    , m_hsvSelector(nullptr)
    , m_colorSpace(nullptr)
    , m_color()
    , m_FGColor()
    , m_updateAllowed(true)
    , m_updateCompressor(new KisSignalCompressor(10, KisSignalCompressor::POSTPONE, this))
    , m_colorspaceSelector(nullptr)
    , m_ui(nullptr)
    , m_displayConverter(nullptr)
    , m_converterConnection()
{
 
    m_ui.reset(new Ui_wdgSpecificColorSelectorWidget());
    m_ui->setupUi(this);
 
    // Set up "RGB/HSV" button group
    m_hsvSelector = new QButtonGroup(this);
    m_rgbButton = new QRadioButton("RGB", this);
    m_hsxButton = new QRadioButton("HSV", this);
    m_hsxModeComboBox = new QComboBox(this);
 
    m_hsxButton->setText("");
    m_rgbButton->setChecked(true);
    m_hsxModeComboBox->addItem(i18n("HSV"));
    m_hsxModeComboBox->addItem(i18n("HSL"));
    m_hsxModeComboBox->addItem(i18n("HSI"));
    m_hsxModeComboBox->addItem(i18n("HSY"));
 
    connect(m_hsvSelector, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(hsvSelectorClicked(QAbstractButton*)));
    connect(m_hsxModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeHsxMode(int)));
 
    m_hsvSelector->addButton(m_rgbButton);
    m_hsvSelector->addButton(m_hsxButton);
    m_hsvSelector->setExclusive(true);
    m_rgbButton->setVisible(false);
    m_hsxButton->setVisible(false);
    m_hsxModeComboBox->setVisible(false);
 
    QSpacerItem *hsvButtonSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_ui->hsvButtonsLayout->addWidget(m_rgbButton);
    m_ui->hsvButtonsLayout->addWidget(m_hsxButton);
    m_ui->hsvButtonsLayout->addWidget(m_hsxModeComboBox);
    m_ui->hsvButtonsLayout->addItem(hsvButtonSpacer);
 
    // Set up HSV sliders
    m_hsvSlider = new KisHsvColorInput(this, &m_color);
    m_hsvSlider->setVisible(false);
 
    connect(m_hsvSlider, SIGNAL(updated()), this,  SLOT(update()));
    connect(this,  SIGNAL(updated()), m_hsvSlider, SLOT(update()));
 
    m_ui->hsvSlidersLayout->addWidget(m_hsvSlider);
 
    connect(m_updateCompressor, SIGNAL(timeout()), SLOT(updateTimeout()));
 
    m_colorspaceSelector = new KisColorSpaceSelector(this);
    connect(m_colorspaceSelector, SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(setCustomColorSpace(const KoColorSpace*)));
 
    m_ui->colorspacePopupButton->setPopupWidget(m_colorspaceSelector);
 
    m_ui->useSameColorSpace->setChecked(true);
    setUseSameColorSpace(m_ui->useSameColorSpace->isChecked(), false);
    connect(m_ui->useSameColorSpace, SIGNAL(toggled(bool)), this, SLOT(setUseSameColorSpace(bool)));
 
    connect(m_ui->chkUsePercentage, SIGNAL(toggled(bool)), this, SLOT(onChkUsePercentageChanged(bool)));
 
    KConfigGroup cfg =  KSharedConfig::openConfig()->group(QString());
    m_ui->chkUsePercentage->setChecked(cfg.readEntry("SpecificColorSelector/UsePercentage", false));
    m_ui->chkUsePercentage->setIcon(KisIconUtils::loadIcon("ratio"));
    m_hsxModeComboBox->setCurrentIndex(cfg.readEntry("SpecificColorSelector/HsxMode", 0));
    m_hsxButton->setChecked(cfg.readEntry("SpecificColorSelector/UseHsx", false));
 
    m_colorspaceSelector->showColorBrowserButton(false);
 
    QSpacerItem *bottomSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_ui->spacerLayout->addItem(bottomSpacer);
}

References changeHsxMode(), connect(), hsvSelectorClicked(), KisIconUtils::loadIcon(), m_color, m_colorspaceSelector, m_hsvSelector, m_hsvSlider, m_hsxButton, m_hsxModeComboBox, m_rgbButton, m_ui, m_updateCompressor, onChkUsePercentageChanged(), setCustomColorSpace(), setUseSameColorSpace(), KisColorSpaceSelector::showColorBrowserButton(), update(), updated(), and updateTimeout().

◆ ~KisSpecificColorSelectorWidget()

KisSpecificColorSelectorWidget::~KisSpecificColorSelectorWidget ( )

override

Definition at line 122 of file kis_specific_color_selector_widget.cc.

{
    KConfigGroup cfg =  KSharedConfig::openConfig()->group(QString());
    cfg.writeEntry("SpecificColorSelector/UsePercentage", m_ui->chkUsePercentage->isChecked());
    cfg.writeEntry("SpecificColorSelector/HsxMode", m_hsxModeComboBox->currentIndex());
    cfg.writeEntry("SpecificColorSelector/UseHsx", m_hsxButton->isChecked());
}

References m_hsxButton, m_hsxModeComboBox, and m_ui.

Member Function Documentation

◆ changeHsxMode

void KisSpecificColorSelectorWidget::changeHsxMode ( int index )

privateslot

Definition at line 335 of file kis_specific_color_selector_widget.cc.

                                                            {
    m_hsvSlider->setMixMode((KisHsvColorSlider::MIX_MODE)(index + 1));
}

References m_hsvSlider, and KisHsvColorInput::setMixMode().

◆ colorChanged

void KisSpecificColorSelectorWidget::colorChanged ( const KoColor & )

signal

◆ hsvSelectorClicked

void KisSpecificColorSelectorWidget::hsvSelectorClicked ( QAbstractButton * )

privateslot

Definition at line 330 of file kis_specific_color_selector_widget.cc.

{
    updateHsvSelector(m_colorSpace ? m_colorSpace->colorModelId() == RGBAColorModelID : false);
}

References KoColorSpace::colorModelId(), m_colorSpace, RGBAColorModelID, and updateHsvSelector().

◆ onChkUsePercentageChanged

void KisSpecificColorSelectorWidget::onChkUsePercentageChanged ( bool isChecked )

privateslot

Definition at line 322 of file kis_specific_color_selector_widget.cc.

{
    for (auto input: m_inputs) {
        input->setPercentageWise(isChecked);
    }
    emit(updated());
}

References m_inputs, and updated().

◆ rereadCurrentColorSpace

void KisSpecificColorSelectorWidget::rereadCurrentColorSpace ( bool force = false )

privateslot

Definition at line 165 of file kis_specific_color_selector_widget.cc.

{
    if (m_displayConverter && m_ui->useSameColorSpace->isChecked()) {
        setColorSpace(m_displayConverter->paintingColorSpace(), force);
    } else {
        setColorSpace(m_colorSpace, force);
    }
 
    setColor(m_color);
}

References m_color, m_colorSpace, m_displayConverter, m_ui, KisDisplayColorConverter::paintingColorSpace(), setColor(), and setColorSpace().

◆ resizeEvent()

void KisSpecificColorSelectorWidget::resizeEvent ( QResizeEvent * event )

overrideprotected

Definition at line 138 of file kis_specific_color_selector_widget.cc.

{
    QWidget::resizeEvent(event);
 
    if (m_colorSpace) {
        QString elidedColorspaceName = m_ui->colorspacePopupButton->fontMetrics().elidedText(
                    m_colorSpace->name(), Qt::ElideRight,
                    m_ui->colorspacePopupButton->width()
                    );
        m_ui->colorspacePopupButton->setText(elidedColorspaceName);
    }
}

References m_colorSpace, m_ui, and KoColorSpace::name.

◆ setColor

void KisSpecificColorSelectorWidget::setColor ( const KoColor & c )

slot

Definition at line 296 of file kis_specific_color_selector_widget.cc.

{
    m_updateAllowed = false;
    m_color.fromKoColor(c);
    emit(updated());
    m_updateAllowed = true;
}

References KoColor::fromKoColor(), m_color, m_updateAllowed, and updated().

◆ setColorSpace

void KisSpecificColorSelectorWidget::setColorSpace	(	const KoColorSpace *	cs,
		bool	force = false )

slot

Definition at line 176 of file kis_specific_color_selector_widget.cc.

{
    Q_ASSERT(cs);
    dbgPlugins << cs->id() << " " << cs->profile()->name();
 
    if (m_colorSpace && *m_colorSpace == *cs && !force) {
        Q_FOREACH (KisColorInput* input, m_inputs) {
            input->update();
        }
 
        return;
    }
 
    if (cs->colorDepthId() == Integer8BitsColorDepthID || cs->colorDepthId() == Integer16BitsColorDepthID) {
        m_ui->chkUsePercentage->setVisible(true);
    } else {
        m_ui->chkUsePercentage->setVisible(false);
    }
 
    m_colorSpace = KoColorSpaceRegistry::instance()->colorSpace(cs->colorModelId().id(), cs->colorDepthId().id(), cs->profile());
    Q_ASSERT(m_colorSpace);
    Q_ASSERT(*m_colorSpace == *cs);
 
    QString elidedColorspaceName = m_ui->colorspacePopupButton->fontMetrics().elidedText(
                m_colorSpace->name(), Qt::ElideRight,
                m_ui->colorspacePopupButton->width()
                );
    m_ui->colorspacePopupButton->setText(elidedColorspaceName);
 
    m_color = KoColor(m_FGColor, m_colorSpace);
    Q_FOREACH (KisColorInput* input, m_inputs) {
        delete input;
    }
    if (m_hexInput) {
        delete m_hexInput;
        m_hexInput = nullptr;
    }
    m_inputs.clear();
 
    QList<KoChannelInfo *> channels = KoChannelInfo::displayOrderSorted(m_colorSpace->channels());
 
    KoColorDisplayRendererInterface *displayRenderer =
        m_displayConverter ?
        m_displayConverter->displayRendererInterface() :
        KisDisplayColorConverter::dumbConverterInstance()->displayRendererInterface();
 
    Q_FOREACH (KoChannelInfo* channel, channels) {
        if (channel->channelType() == KoChannelInfo::COLOR) {
            KisColorInput* input = 0;
            switch (channel->channelValueType()) {
            case KoChannelInfo::UINT8:
            case KoChannelInfo::UINT16:
            case KoChannelInfo::UINT32: {
                input = new KisIntegerColorInput(this, channel, &m_color, displayRenderer, m_ui->chkUsePercentage->isChecked());
            }
            break;
            case KoChannelInfo::FLOAT16:
            case KoChannelInfo::FLOAT32: {
                input = new KisFloatColorInput(this, channel, &m_color, displayRenderer);
            }
            break;
            default:
                Q_ASSERT(false);
                input = 0;
            }
            if (input) {
                connect(input, SIGNAL(updated()), this,  SLOT(update()));
                connect(this,  SIGNAL(updated()), input, SLOT(update()));
 
                m_inputs.append(input);
                m_ui->slidersLayout->addWidget(input);
            }
        }
    }
 
    QList<QLabel*> labels;
    int labelWidth = 0;
 
    Q_FOREACH (KisColorInput* input, m_inputs) {
        Q_FOREACH (QLabel* label, input->findChildren<QLabel*>()) {
            labels.append(label);
            labelWidth = qMax(labelWidth, label->sizeHint().width());
        }
    }
 
    Q_FOREACH (QLabel *label, labels) {
        label->setMinimumWidth(labelWidth);
    }
 
    bool allChannels8Bit = true;
    Q_FOREACH (KoChannelInfo* channel, channels) {
        if (channel->channelType() == KoChannelInfo::COLOR && channel->channelValueType() != KoChannelInfo::UINT8) {
            allChannels8Bit = false;
        }
    }
    if (allChannels8Bit) {
        // Set up the Hex input
        m_hexInput = new KisHexColorInput(this, &m_color, displayRenderer, false, true);
        m_ui->hexSelectorLayout->addWidget(m_hexInput);
        connect(m_hexInput, SIGNAL(updated()), this,  SLOT(update()));
        connect(this,  SIGNAL(updated()), m_hexInput, SLOT(update()));
    }
 
    updateHsvSelector(m_colorSpace->colorModelId() == RGBAColorModelID);
 
    m_colorspaceSelector->blockSignals(true);
    m_colorspaceSelector->setCurrentColorSpace(cs);
    m_colorspaceSelector->blockSignals(false);
 
    m_updateAllowed = false;
    emit(updated());
    m_updateAllowed = true;
}

References KoColorSpace::channels, KoChannelInfo::channelType(), KoChannelInfo::channelValueType(), KoChannelInfo::COLOR, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoColorSpaceRegistry::colorSpace(), connect(), dbgPlugins, KoChannelInfo::displayOrderSorted(), KisDisplayColorConverter::displayRendererInterface(), KisDisplayColorConverter::dumbConverterInstance(), KoChannelInfo::FLOAT16, KoChannelInfo::FLOAT32, KoID::id(), KoColorSpace::id, KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, m_color, m_colorSpace, m_colorspaceSelector, m_displayConverter, m_FGColor, m_hexInput, m_inputs, m_ui, m_updateAllowed, KoColorProfile::name, KoColorSpace::name, KoColorSpace::profile(), RGBAColorModelID, KisColorSpaceSelector::setCurrentColorSpace(), KoChannelInfo::UINT16, KoChannelInfo::UINT32, KoChannelInfo::UINT8, update(), updated(), and updateHsvSelector().

◆ setCustomColorSpace

void KisSpecificColorSelectorWidget::setCustomColorSpace ( const KoColorSpace * colorSpace )

privateslot

Definition at line 315 of file kis_specific_color_selector_widget.cc.

{
    m_ui->useSameColorSpace->setChecked(false);
    setColorSpace(colorSpace);
    setColor(m_color);
}

References m_color, m_ui, setColor(), and setColorSpace().

◆ setDisplayConverter

void KisSpecificColorSelectorWidget::setDisplayConverter ( KisDisplayColorConverter * colorConverter )

slot

Definition at line 151 of file kis_specific_color_selector_widget.cc.

{
    const bool needsForceUpdate = m_displayConverter != displayConverter;
 
    m_displayConverter = displayConverter;
 
    if (m_displayConverter) {
        m_converterConnection.clear();
        m_converterConnection.addConnection(m_displayConverter, SIGNAL(displayConfigurationChanged()), this, SLOT(rereadCurrentColorSpace()), Qt::UniqueConnection);
    }
 
    rereadCurrentColorSpace(needsForceUpdate);
}

References KisSignalAutoConnectionsStore::addConnection(), KisSignalAutoConnectionsStore::clear(), m_converterConnection, m_displayConverter, and rereadCurrentColorSpace().

◆ setFGColor

void KisSpecificColorSelectorWidget::setFGColor ( const KoColor & c )

slot

Definition at line 304 of file kis_specific_color_selector_widget.cc.

{
    m_FGColor = c;
}

References m_FGColor.

◆ setUseSameColorSpace

void KisSpecificColorSelectorWidget::setUseSameColorSpace	(	bool	locked,
		bool	reloadColorSpace = true )

privateslot

Definition at line 130 of file kis_specific_color_selector_widget.cc.

{
    m_ui->useSameColorSpace->setIcon(locked ? KisIconUtils::loadIcon("chain-icon") : KisIconUtils::loadIcon("chain-broken-icon"));
    if (locked && reloadColorSpace) {
        rereadCurrentColorSpace();
    }
}

References KisIconUtils::loadIcon(), m_ui, and rereadCurrentColorSpace().

◆ update

void KisSpecificColorSelectorWidget::update ( )

privateslot

Definition at line 290 of file kis_specific_color_selector_widget.cc.

{
    if (m_updateAllowed) {
        m_updateCompressor->start();
    }
}

References m_updateAllowed, m_updateCompressor, and KisSignalCompressor::start().

◆ updated

void KisSpecificColorSelectorWidget::updated ( )

signal

◆ updateHsvSelector()

void KisSpecificColorSelectorWidget::updateHsvSelector ( bool isRgbColorSpace )

private

Definition at line 339 of file kis_specific_color_selector_widget.cc.

{
    m_rgbButton->setVisible(isRgbColorSpace);
    m_hsxButton->setVisible(isRgbColorSpace);
    m_hsxModeComboBox->setVisible(isRgbColorSpace);
 
    if (!isRgbColorSpace) {
        // Force to be RGB only
        m_hsvSlider->setVisible(false);
        Q_FOREACH (KisColorInput* input, m_inputs) {
            input->setVisible(true);
        }
        m_ui->chkUsePercentage->setEnabled(true);
 
        return;
    }
 
    Q_FOREACH (KisColorInput* input, m_inputs) {
        input->setVisible(m_rgbButton->isChecked());
    }
    m_ui->chkUsePercentage->setEnabled(m_rgbButton->isChecked());
 
    m_hsvSlider->setVisible(m_hsxButton->isChecked());
}