KisSmallColorWidget Class Reference

#include <kis_small_color_widget.h>

Inheritance diagram for KisSmallColorWidget:

Classes
struct	Private

Public Slots
void	setColor (const KoColor &color)
void	setHSV (qreal h, qreal s, qreal v, bool notifyChanged=true)
void	setHue (qreal h)
void	slotUpdatePalettes ()
void	updateSVPalette ()

Signals
void	colorChanged (const KoColor &)
void	sigTellColorChangedInternal ()

Public Member Functions
	KisSmallColorWidget (QWidget *parent)
void	resizeEvent (QResizeEvent *event) override
void	setDisplayColorConverter (KisDisplayColorConverter *converter)
	~KisSmallColorWidget () override

Private Slots
void	slotDisplayConfigurationChanged ()
void	slotHueSliderChanged (const QPointF &pos)
void	slotInitiateUpdateDynamicRange (int maxLuminance)
void	slotTellColorChanged ()
void	slotValueSliderChanged (const QPointF &pos)

Private Member Functions
void	updateDynamicRange (int maxLuminance)
void	updateHuePalette ()
template<class FillPolicy >
void	uploadPaletteData (KisGLImageWidget *widget, const QSize &size)

Private Attributes
Private *const	d

Detailed Description

Definition at line 16 of file kis_small_color_widget.h.

Constructor & Destructor Documentation

KisSmallColorWidget()

KisSmallColorWidget::KisSmallColorWidget

(

QWidget *

parent

)

Definition at line 122 of file kis_small_color_widget.cc.

    : QWidget(parent),
      d(new Private)
{
    d->hue = 0.0;
    d->value = 0;
    d->saturation = 0;
    d->updateAllowed = true;
 
    d->repaintCompressor = new KisSignalCompressor(25, KisSignalCompressor::FIRST_ACTIVE, this);
    connect(d->repaintCompressor, SIGNAL(timeout()), SLOT(update()));
 
    d->resizeUpdateCompressor = new KisSignalCompressor(200, KisSignalCompressor::FIRST_ACTIVE, this);
    connect(d->resizeUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdatePalettes()));
 
    d->valueSliderUpdateCompressor = new KisSignalCompressor(100, KisSignalCompressor::FIRST_ACTIVE, this);
    connect(d->valueSliderUpdateCompressor, SIGNAL(timeout()), SLOT(updateSVPalette()));
 
    d->colorChangedSignalCompressor = new KisSignalCompressor(25, KisSignalCompressor::FIRST_ACTIVE, this);
    connect(d->colorChangedSignalCompressor, SIGNAL(timeout()), SLOT(slotTellColorChanged()));
 
    {
        using namespace std::placeholders;
        std::function<void (qreal)> callback(
                    std::bind(&KisSmallColorWidget::updateDynamicRange, this, _1));
        d->dynamicRangeCompressor.reset(new KisSignalCompressorWithParam<int>(50, callback));
 
    }
 
    // default color space means that the colors will be passed through to the GPU directly
    // without any conversion
    const KisSurfaceColorSpaceWrapper colorSpace = KisSurfaceColorSpaceWrapper::DefaultColorSpace;
 
    d->hueWidget = new KisClickableGLImageWidget(colorSpace, this);
    d->hueWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
    d->hueWidget->setHandlePaintingStrategy(new KisClickableGLImageWidget::VerticalLineHandleStrategy);
    connect(d->hueWidget, SIGNAL(selected(const QPointF&)), SLOT(slotHueSliderChanged(const QPointF&)));
 
    d->valueWidget = new KisClickableGLImageWidget(colorSpace, this);
    d->valueWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
    d->valueWidget->setHandlePaintingStrategy(new KisClickableGLImageWidget::CircularHandleStrategy);
    connect(d->valueWidget, SIGNAL(selected(const QPointF&)), SLOT(slotValueSliderChanged(const QPointF&)));
 
    d->hasHardwareHDR = KisOpenGLModeProber::instance()->useHDRMode();
 
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
        d->hasHardwareHDR = true;
        d->rootSurfaceInfoProxy = new KisRootSurfaceInfoProxy(this, this);
        connect(d->rootSurfaceInfoProxy, &KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged,
                this, &KisSmallColorWidget::slotDisplayConfigurationChanged);
    }
#endif
 
    if (d->hasHardwareHDR) {
        d->dynamicRange = new KisSliderSpinBox(this);
        d->dynamicRange->setRange(80, 10000);
        d->dynamicRange->setExponentRatio(3.0);
        d->dynamicRange->setSingleStep(1);
        d->dynamicRange->setPageStep(100);
        d->dynamicRange->setSuffix("cd/m²");
        d->dynamicRange->setValue(d->currenOutputReferenceWhite * d->currentRelativeDynamicRange);
        connect(d->dynamicRange, SIGNAL(valueChanged(int)), SLOT(slotInitiateUpdateDynamicRange(int)));
    }
 
    QVBoxLayout *layout = new QVBoxLayout(this);
    layout->addWidget(d->hueWidget, 0);
    layout->addWidget(d->valueWidget, 1);
 
    if (d->dynamicRange) {
        layout->addSpacing(16);
        layout->addWidget(d->dynamicRange, 0);
    }
 
    slotUpdatePalettes();
}

References KisSmallColorWidget::Private::colorChangedSignalCompressor, KisSmallColorWidget::Private::currenOutputReferenceWhite, KisSmallColorWidget::Private::currentRelativeDynamicRange, d, KisSurfaceColorSpaceWrapper::DefaultColorSpace, KisSmallColorWidget::Private::dynamicRange, KisSmallColorWidget::Private::dynamicRangeCompressor, KisSignalCompressor::FIRST_ACTIVE, KisSmallColorWidget::Private::hasHardwareHDR, KisSmallColorWidget::Private::hue, KisSmallColorWidget::Private::hueWidget, KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KisSmallColorWidget::Private::repaintCompressor, KisSmallColorWidget::Private::resizeUpdateCompressor, KisSmallColorWidget::Private::saturation, KisSliderSpinBox::setExponentRatio(), KisClickableGLImageWidget::setHandlePaintingStrategy(), KisSliderSpinBox::setPageStep(), KisSliderSpinBox::setRange(), KisSliderSpinBox::setValue(), KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged(), slotDisplayConfigurationChanged(), slotHueSliderChanged(), slotInitiateUpdateDynamicRange(), slotTellColorChanged(), slotUpdatePalettes(), slotValueSliderChanged(), KisSmallColorWidget::Private::updateAllowed, updateDynamicRange(), updateSVPalette(), KisOpenGLModeProber::useHDRMode(), KisSmallColorWidget::Private::value, KisSmallColorWidget::Private::valueSliderUpdateCompressor, KisSmallColorWidget::Private::valueWidget, and void().

~KisSmallColorWidget()

KisSmallColorWidget::~KisSmallColorWidget ( )

override

Definition at line 202 of file kis_small_color_widget.cc.

{
    delete d;
}

References d.

Member Function Documentation

colorChanged

void KisSmallColorWidget::colorChanged ( const KoColor & )

signal

resizeEvent()

void KisSmallColorWidget::resizeEvent ( QResizeEvent * event )

override

Definition at line 555 of file kis_small_color_widget.cc.

{
    QWidget::resizeEvent(event);
    update();
    d->resizeUpdateCompressor->start();
}

References d, KisSmallColorWidget::Private::resizeUpdateCompressor, and KisSignalCompressor::start().

setColor

void KisSmallColorWidget::setColor ( const KoColor & color )

slot

Definition at line 235 of file kis_small_color_widget.cc.

{
    if (!d->updateAllowed) return;
 
    KIS_SAFE_ASSERT_RECOVER(!d->dynamicRange || d->hasHDR == d->dynamicRange->isEnabled()) {
        slotDisplayConfigurationChanged();
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(!d->hasHDR || d->hasHardwareHDR);
 
    const KoColorSpace *cs = d->generationColorSpace();
    KIS_SAFE_ASSERT_RECOVER_RETURN(cs);
 
    KoColor newColor(color);
    newColor.convertTo(cs);
 
    QVector<float> channels(4);
    cs->normalisedChannelsValue(newColor.data(), channels);
 
    float r, g, b;
 
    if (cs->colorDepthId() == Integer8BitsColorDepthID) {
        r = channels[2];
        g = channels[1];
        b = channels[0];
    } else {
        r = channels[0];
        g = channels[1];
        b = channels[2];
    }
 
    if (d->hasHDR) {
        qreal rangeCoeff = d->effectiveRelativeDynamicRange();
 
        if (rangeCoeff < r || rangeCoeff < g || rangeCoeff < b) {
            rangeCoeff = std::max({r, g, b}) * 1.10f;
 
            const int newMaxLuminance = qRound(d->currenOutputReferenceWhite * rangeCoeff);
            updateDynamicRange(newMaxLuminance);
            d->dynamicRange->setValue(newMaxLuminance);
        }
 
        r /= rangeCoeff;
        g /= rangeCoeff;
        b /= rangeCoeff;
    } else {
        r = qBound(0.0f, r, 1.0f);
        g = qBound(0.0f, g, 1.0f);
        b = qBound(0.0f, b, 1.0f);
    }
 
    float denormHue, saturation, value;
    RGBToHSV(r, g, b, &denormHue, &saturation, &value);
 
    d->hueWidget->setNormalizedPos(QPointF(denormHue / 360.0, 0.0));
    d->valueWidget->setNormalizedPos(QPointF(saturation, 1.0 - value));
 
    setHSV(denormHue / 360.0, saturation, value, false);
}

References KoColorSpace::colorDepthId(), KoColor::convertTo(), KisSmallColorWidget::Private::currenOutputReferenceWhite, d, KoColor::data(), KisSmallColorWidget::Private::dynamicRange, KisSmallColorWidget::Private::effectiveRelativeDynamicRange(), KisSmallColorWidget::Private::generationColorSpace(), KisSmallColorWidget::Private::hasHardwareHDR, KisSmallColorWidget::Private::hasHDR, KisSmallColorWidget::Private::hueWidget, Integer8BitsColorDepthID, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, KoColorSpace::normalisedChannelsValue(), RGBToHSV(), setHSV(), KisClickableGLImageWidget::setNormalizedPos(), KisSliderSpinBox::setValue(), slotDisplayConfigurationChanged(), KisSmallColorWidget::Private::updateAllowed, updateDynamicRange(), value(), and KisSmallColorWidget::Private::valueWidget.

setDisplayColorConverter()

void KisSmallColorWidget::setDisplayColorConverter

(

KisDisplayColorConverter *

converter

)

Definition at line 463 of file kis_small_color_widget.cc.

{
    d->colorConverterConnections.clear();
 
    if (!converter) {
        converter = KisDisplayColorConverter::dumbConverterInstance();
    }
 
    d->displayColorConverter = converter;
 
    if (d->displayColorConverter) {
        d->colorConverterConnections.addConnection(
            d->displayColorConverter, SIGNAL(displayConfigurationChanged()),
            this, SLOT(slotDisplayConfigurationChanged()));
    }
 
    slotDisplayConfigurationChanged();
}

References KisSignalAutoConnectionsStore::addConnection(), KisSignalAutoConnectionsStore::clear(), KisSmallColorWidget::Private::colorConverterConnections, d, KisSmallColorWidget::Private::displayColorConverter, KisDisplayColorConverter::dumbConverterInstance(), and slotDisplayConfigurationChanged().

setHSV

void KisSmallColorWidget::setHSV ( qreal h, qreal s, qreal v, bool notifyChanged = true )

slot

Definition at line 216 of file kis_small_color_widget.cc.

{
    h = qBound(0.0, h, 1.0);
    s = qBound(0.0, s, 1.0);
    v = qBound(0.0, v, 1.0);
    bool newH = !qFuzzyCompare(d->hue, h);
    d->hue = h;
    d->value = v;
    d->saturation = s;
    // TODO: remove and make acyclic!
    if (notifyChanged) {
        d->colorChangedSignalCompressor->start();
    }
    if(newH) {
        d->valueSliderUpdateCompressor->start();
    }
    d->repaintCompressor->start();
}

References KisSmallColorWidget::Private::colorChangedSignalCompressor, d, KisSmallColorWidget::Private::hue, qFuzzyCompare(), KisSmallColorWidget::Private::repaintCompressor, KisSmallColorWidget::Private::saturation, KisSignalCompressor::start(), v, KisSmallColorWidget::Private::value, and KisSmallColorWidget::Private::valueSliderUpdateCompressor.

setHue

void KisSmallColorWidget::setHue ( qreal h )

slot

Definition at line 207 of file kis_small_color_widget.cc.

{
    h = qBound(0.0, h, 1.0);
    d->hue = h;
    d->colorChangedSignalCompressor->start();
    d->valueSliderUpdateCompressor->start();
    d->repaintCompressor->start();
}

References KisSmallColorWidget::Private::colorChangedSignalCompressor, d, KisSmallColorWidget::Private::hue, KisSmallColorWidget::Private::repaintCompressor, KisSignalCompressor::start(), and KisSmallColorWidget::Private::valueSliderUpdateCompressor.

sigTellColorChangedInternal

void KisSmallColorWidget::sigTellColorChangedInternal ( )

signal

slotDisplayConfigurationChanged

void KisSmallColorWidget::slotDisplayConfigurationChanged ( )

privateslot

Definition at line 482 of file kis_small_color_widget.cc.

{
    d->hasHDR = false;
 
    if (d->hasHardwareHDR) {
        const KoColorSpace *cs = d->displayColorConverter->paintingColorSpace();
 
        d->hasHDR = cs->colorModelId() == RGBAColorModelID &&
                (cs->colorDepthId() == Float16BitsColorDepthID ||
                 cs->colorDepthId() == Float32BitsColorDepthID ||
                 cs->colorDepthId() == Float64BitsColorDepthID ||
                 cs->profile()->getTransferCharacteristics() == TRC_ITU_R_BT_2100_0_PQ);
 
        if (d->hasHDR) {
            const KoColorSpace *outputColorSpace = d->outputColorSpace();
            if (!outputColorSpace->profile()->hdrReferenceWhite()) {
                qWarning() << "WARNING: KisSmallColorWidget::slotDisplayConfigurationChanged(): output color space is "
                              "not a PQ space, the meaning of the range slider may be wrong!";
            }
 
            d->currenOutputReferenceWhite = outputColorSpace->profile()->hdrReferenceWhite().value_or(80.0);
        }
    }
 
    if (d->dynamicRange) {
        d->dynamicRange->setEnabled(d->hasHDR);
    }
    d->hueWidget->setUseHandleOpacity(!d->hasHDR);
    d->valueWidget->setUseHandleOpacity(!d->hasHDR);
 
    slotUpdatePalettes();
    // TODO: also set the currently selected color again
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisSmallColorWidget::Private::currenOutputReferenceWhite, d, KisSmallColorWidget::Private::displayColorConverter, KisSmallColorWidget::Private::dynamicRange, Float16BitsColorDepthID, Float32BitsColorDepthID, Float64BitsColorDepthID, KoColorProfile::getTransferCharacteristics(), KisSmallColorWidget::Private::hasHardwareHDR, KisSmallColorWidget::Private::hasHDR, KoColorProfile::hdrReferenceWhite(), KisSmallColorWidget::Private::hueWidget, KisSmallColorWidget::Private::outputColorSpace(), KisDisplayColorConverter::paintingColorSpace(), KoColorSpace::profile(), RGBAColorModelID, KisClickableGLImageWidget::setUseHandleOpacity(), slotUpdatePalettes(), TRC_ITU_R_BT_2100_0_PQ, and KisSmallColorWidget::Private::valueWidget.

slotHueSliderChanged

void KisSmallColorWidget::slotHueSliderChanged ( const QPointF & pos )

privateslot

Definition at line 408 of file kis_small_color_widget.cc.

{
    const qreal newHue = pos.x();
 
    if (!qFuzzyCompare(newHue, d->hue)) {
        setHue(newHue);
    }
}

References d, KisSmallColorWidget::Private::hue, qFuzzyCompare(), and setHue().

slotInitiateUpdateDynamicRange

void KisSmallColorWidget::slotInitiateUpdateDynamicRange ( int maxLuminance )

privateslot

Definition at line 429 of file kis_small_color_widget.cc.

{
    d->dynamicRangeCompressor->start(maxLuminance);
}

References d, and KisSmallColorWidget::Private::dynamicRangeCompressor.

slotTellColorChanged

void KisSmallColorWidget::slotTellColorChanged ( )

privateslot

Definition at line 516 of file kis_small_color_widget.cc.

{
    d->updateAllowed = false;
 
    float r, g, b;
    HSVToRGB(d->hue * 360.0, d->saturation, d->value, &r, &g, &b);
 
    if (d->hasHDR) {
        const float rangeCoeff = d->effectiveRelativeDynamicRange();
 
        r *= rangeCoeff;
        g *= rangeCoeff;
        b *= rangeCoeff;
    }
 
    const KoColorSpace *cs = d->generationColorSpace();
    KIS_SAFE_ASSERT_RECOVER_RETURN(cs);
 
    QVector<float> values(4);
 
    if (cs->colorDepthId() == Integer8BitsColorDepthID) {
        values[0] = b;
        values[1] = g;
        values[2] = r;
        values[3] = 1.0f;
    } else {
        values[0] = r;
        values[1] = g;
        values[2] = b;
        values[3] = 1.0f;
    }
 
    KoColor c(cs);
    cs->fromNormalisedChannelsValue(c.data(), values);
    Q_EMIT colorChanged(c);
 
    d->updateAllowed = true;
}

References colorChanged(), KoColorSpace::colorDepthId(), d, KoColor::data(), KisSmallColorWidget::Private::effectiveRelativeDynamicRange(), KoColorSpace::fromNormalisedChannelsValue(), KisSmallColorWidget::Private::generationColorSpace(), KisSmallColorWidget::Private::hasHDR, HSVToRGB(), KisSmallColorWidget::Private::hue, Integer8BitsColorDepthID, KIS_SAFE_ASSERT_RECOVER_RETURN, KisSmallColorWidget::Private::saturation, KisSmallColorWidget::Private::updateAllowed, and KisSmallColorWidget::Private::value.

slotUpdatePalettes

void KisSmallColorWidget::slotUpdatePalettes ( )

slot

Definition at line 295 of file kis_small_color_widget.cc.

{
    updateHuePalette();
    updateSVPalette();
}

References updateHuePalette(), and updateSVPalette().

slotValueSliderChanged

void KisSmallColorWidget::slotValueSliderChanged ( const QPointF & pos )

privateslot

Definition at line 417 of file kis_small_color_widget.cc.

{
    const qreal newSaturation = pos.x();
    const qreal newValue = 1.0 - pos.y();
 
    if (!qFuzzyCompare(newSaturation, d->saturation) ||
        !qFuzzyCompare(newValue, d->value)) {
 
        setHSV(d->hue, newSaturation, newValue);
    }
}

References d, KisSmallColorWidget::Private::hue, qFuzzyCompare(), KisSmallColorWidget::Private::saturation, setHSV(), and KisSmallColorWidget::Private::value.

updateDynamicRange()

void KisSmallColorWidget::updateDynamicRange ( int maxLuminance )

private

Definition at line 434 of file kis_small_color_widget.cc.

{
    const qreal oldRange = d->currentRelativeDynamicRange;
    const qreal newRange = qreal(maxLuminance) / d->currenOutputReferenceWhite;
 
    if (qFuzzyCompare(oldRange, newRange)) return;
 
    float r, g, b;
    float denormHue = d->hue * 360.0;
    float saturation = d->saturation;
    float value = d->value;
 
    HSVToRGB(denormHue, saturation, value, &r, &g, &b);
 
    const qreal transformCoeff = oldRange / newRange;
 
    r = qBound(0.0, r * transformCoeff, 1.0);
    g = qBound(0.0, g * transformCoeff, 1.0);
    b = qBound(0.0, b * transformCoeff, 1.0);
 
    RGBToHSV(r, g, b, &denormHue, &saturation, &value);
 
    d->currentRelativeDynamicRange = newRange;
    slotUpdatePalettes();
    setHSV(denormHue / 360.0, saturation, value, false);
    d->hueWidget->setNormalizedPos(QPointF(denormHue / 360.0, 0));
    d->valueWidget->setNormalizedPos(QPointF(saturation, 1.0 - value));
}

References KisSmallColorWidget::Private::currenOutputReferenceWhite, KisSmallColorWidget::Private::currentRelativeDynamicRange, d, HSVToRGB(), KisSmallColorWidget::Private::hue, KisSmallColorWidget::Private::hueWidget, qFuzzyCompare(), RGBToHSV(), KisSmallColorWidget::Private::saturation, setHSV(), KisClickableGLImageWidget::setNormalizedPos(), slotUpdatePalettes(), KisSmallColorWidget::Private::value, value(), and KisSmallColorWidget::Private::valueWidget.

updateHuePalette()

void KisSmallColorWidget::updateHuePalette ( )

private

Definition at line 393 of file kis_small_color_widget.cc.

{
    uploadPaletteData<FillHPolicy>(d->hueWidget, QSize(d->hueWidget->width(), d->huePreferredHeight));
}

References d, KisSmallColorWidget::Private::huePreferredHeight, and KisSmallColorWidget::Private::hueWidget.

updateSVPalette

void KisSmallColorWidget::updateSVPalette ( )

slot

Definition at line 398 of file kis_small_color_widget.cc.

{
    const int maxSize = 256;
    QSize newSize = d->valueWidget->size();
    newSize.rwidth() = qMin(maxSize, newSize.width());
    newSize.rheight() = qMin(maxSize, newSize.height());
 
    uploadPaletteData<FillSVPolicy>(d->valueWidget, newSize);
}

References d, and KisSmallColorWidget::Private::valueWidget.

uploadPaletteData()

template<class FillPolicy >

void KisSmallColorWidget::uploadPaletteData ( KisGLImageWidget * widget, const QSize & size )

private

Definition at line 320 of file kis_small_color_widget.cc.

{
    if (!isEnabled() || size.isEmpty()) return;
 
    KisGLImageF16 image(size);
    const float xPortionCoeff = 1.0 / image.width();
    const float yPortionCoeff = 1.0 / image.height();
    const float rangeCoeff = d->effectiveRelativeDynamicRange();
 
    const KoColorSpace *generationColorSpace = d->generationColorSpace();
 
    if (d->displayColorConverter->canSkipDisplayConversion(generationColorSpace)) {
        half *pixelPtr = image.data();
 
        for (int y = 0; y < image.height(); y++) {
            for (int x = 0; x < image.width(); x++) {
                Imf::Rgba &pxl = reinterpret_cast<Imf::Rgba &>(*pixelPtr);
 
                float r, g, b;
                FillPolicy::getRGB(d->hue, xPortionCoeff, yPortionCoeff, x, y,
                                   &r, &g, &b);
 
                pxl.r = r * rangeCoeff;
                pxl.g = g * rangeCoeff;
                pxl.b = b * rangeCoeff;
                pxl.a = 1.0;
 
                pixelPtr += 4;
            }
        }
 
    } else {
        KIS_SAFE_ASSERT_RECOVER_RETURN(d->displayColorConverter);
 
        KisFixedPaintDeviceSP device = new KisFixedPaintDevice(generationColorSpace);
        device->setRect(QRect(QPoint(), image.size()));
        device->reallocateBufferWithoutInitialization();
        float *devicePtr = reinterpret_cast<float*>(device->data());
 
        for (int y = 0; y < image.height(); y++) {
            for (int x = 0; x < image.width(); x++) {
                FillPolicy::getRGB(d->hue, xPortionCoeff, yPortionCoeff, x, y,
                                   devicePtr, devicePtr + 1, devicePtr + 2);
 
                devicePtr[0] *= rangeCoeff;
                devicePtr[1] *= rangeCoeff;
                devicePtr[2] *= rangeCoeff;
                devicePtr[3] = 1.0;
 
                devicePtr += 4;
            }
        }
 
        // TODO: should we add caching for this space fetching?
        const KoColorSpace *dstColorSpace =
            KoColorSpaceRegistry::instance()->colorSpace(
                RGBAColorModelID.id(),
                Float16BitsColorDepthID.id(),
                d->outputColorProfile());
 
        d->displayColorConverter->applyDisplayFilteringF32(device, dstColorSpace);
 
        // the output device must have float16/rgba space
        KIS_SAFE_ASSERT_RECOVER_RETURN(device->pixelSize() == 8);
 
        memcpy(image.data(),
               device->data(),
               device->pixelSize() * device->bounds().width() * device->bounds().height());
    }
 
    widget->loadImage(image);
}

References KisDisplayColorConverter::applyDisplayFilteringF32(), KisFixedPaintDevice::bounds(), KisDisplayColorConverter::canSkipDisplayConversion(), KoColorSpaceRegistry::colorSpace(), d, KisFixedPaintDevice::data(), KisGLImageF16::data(), KisSmallColorWidget::Private::displayColorConverter, KisSmallColorWidget::Private::effectiveRelativeDynamicRange(), Float16BitsColorDepthID, KisSmallColorWidget::Private::generationColorSpace(), KisGLImageF16::height(), KisSmallColorWidget::Private::hue, KoID::id(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisGLImageWidget::loadImage(), KisSmallColorWidget::Private::outputColorProfile(), KisFixedPaintDevice::pixelSize(), KisFixedPaintDevice::reallocateBufferWithoutInitialization(), RGBAColorModelID, KisFixedPaintDevice::setRect(), KisGLImageF16::size(), and KisGLImageF16::width().

Member Data Documentation

d

Private* const KisSmallColorWidget::d

private

Definition at line 62 of file kis_small_color_widget.h.

---

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

• plugins/dockers/smallcolorselector/kis_small_color_widget.h
• plugins/dockers/smallcolorselector/kis_small_color_widget.cc