KisPresetLivePreviewView Class Reference

#include <kis_preset_live_preview_view.h>

Inheritance diagram for KisPresetLivePreviewView:

Public Member Functions
	KisPresetLivePreviewView (QWidget *parent)
void	requestUpdateStroke ()
void	setCurrentPreset (KisPaintOpPresetSP preset)
	set the current preset from resource manager for the live preview to use. Good to call this every stroke update in case the preset has changed
void	setup (KoCanvasResourceProvider *resourceManager)
	one time setup for initialization of many variables. This live preview might be in a UI file, so make sure to call this before starting to use it
	~KisPresetLivePreviewView ()

Private Slots
void	slotPreviewGenerationCompleted ()
void	updateStroke ()

Private Member Functions
void	changeEvent (QEvent *) override
void	paintBackground ()
	works as both clearing the previous stroke, providing striped backgrounds for smudging brushes, and text if there is no preview
void	setupAndPaintStroke ()
	creates and performs the actual stroke that goes on top of the background this is internally and should always be called after the paintBackground()

Private Attributes
QGraphicsScene *	m_brushPreviewScene {nullptr}
	the scene that can add items like text and the brush stroke image
QPointF	m_canvasCenterPoint
QRect	m_canvasSize
const KoColorSpace *	m_colorSpace {nullptr}
	internally sets the color space for brush preview
float	m_currentBrushSize {1.0}
KisDistanceInformation	m_currentDistance
KisPaintOpPresetSP	m_currentPreset
QPainterPath	m_curvedLine
KisPaintInformation	m_curvePointPI1
KisPaintInformation	m_curvePointPI2
KisImageSP	m_image
	internally sets the image area for brush preview
KisLayerSP	m_layer
	internally sets the layer area for brush preview
const float	m_maxBrushVal {100.0}
const qreal	m_maxScale {0.3}
const float	m_maxStrokeScale {1.0}
const float	m_minBrushVal {10.0}
	the range of brush sizes that will control zooming in/out
const qreal	m_minScale {1.0}
	range of scale values. 1.0 == 100%
const float	m_minStrokeScale {0.4}
	multiplier that is used for lengthening the brush stroke points
QGraphicsTextItem *	m_noPreviewText {nullptr}
	holds the 'no preview available' text object
KoColor	m_paintColor
	the color which is used for rendering the stroke
bool	m_previewGenerationInProgress {false}
KoCanvasResourceProvider *	m_resourceManager {nullptr}
	internally sets the Resource Provider for brush preview (allowing gradients in preview)
QGraphicsPixmapItem *	m_sceneImageItem {nullptr}
	holds the preview brush stroke data
KisSignalCompressor	m_updateCompressor

Detailed Description

Widget for displaying a live brush preview of your selected brush. It listens for signalsetting changes that the brush preset outputs and updates the preview accordingly. This class can be added to a UI file similar to how a QGraphicsView is added

Definition at line 35 of file kis_preset_live_preview_view.h.

Constructor & Destructor Documentation

KisPresetLivePreviewView()

KisPresetLivePreviewView::KisPresetLivePreviewView

(

QWidget *

parent

)

Definition at line 22 of file kis_preset_live_preview_view.cpp.

    : QGraphicsView(parent),
      m_updateCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
{
    connect(&m_updateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
}

References connect(), m_updateCompressor, and updateStroke().

~KisPresetLivePreviewView()

KisPresetLivePreviewView::~KisPresetLivePreviewView

(

)

Definition at line 29 of file kis_preset_live_preview_view.cpp.

{
    delete m_noPreviewText;
    delete m_brushPreviewScene;
}

References m_brushPreviewScene, and m_noPreviewText.

Member Function Documentation

changeEvent()

void KisPresetLivePreviewView::changeEvent ( QEvent * event )

overrideprivate

Definition at line 389 of file kis_preset_live_preview_view.cpp.

{
    QWidget::changeEvent(event);
    if (event->type() == QEvent::PaletteChange) {
        if (m_currentPreset) {
            requestUpdateStroke();
        }
    }
}

References m_currentPreset, and requestUpdateStroke().

paintBackground()

void KisPresetLivePreviewView::paintBackground ( )

private

works as both clearing the previous stroke, providing striped backgrounds for smudging brushes, and text if there is no preview

Definition at line 111 of file kis_preset_live_preview_view.cpp.

{
    // clean up "no preview" text object if it exists. we will add it later if we need it
    if (m_noPreviewText) {
        this->scene()->removeItem(m_noPreviewText);
        m_noPreviewText = 0;
    }
 
 
    if (m_currentPreset->paintOp().id() == "colorsmudge" ||
            m_currentPreset->paintOp().id() == "deformbrush" ||
            m_currentPreset->paintOp().id() == "filter") {
 
        // easier to see deformations and smudging with alternating stripes in the background
        // paint the whole background with alternating stripes
        // filter engine may or may not show things depending on the filter...but it is better than nothing
 
        int grayStrips = 20;
        for (int i=0; i < grayStrips; i++ ) {
 
            float sectionPercent = 1.0 / (float)grayStrips;
            bool isAlternating = i % 2;
            KoColor fillColor(m_layer->paintDevice()->colorSpace());
 
            if (isAlternating) {
                fillColor.fromQColor(QColor(80,80,80));
            } else {
                fillColor.fromQColor(QColor(140,140,140));
            }
 
 
            const QRect fillRect(m_layer->image()->width()*sectionPercent*i,
                                 0,
                                 m_layer->image()->width()*(sectionPercent*i +sectionPercent),
                                 m_layer->image()->height());
 
            KisTransaction t(m_layer->paintDevice());
            m_layer->paintDevice()->fill(fillRect, fillColor);
            t.end();
        }
 
        m_paintColor = KoColor(Qt::white, m_colorSpace);
 
    }
    else if (m_currentPreset->paintOp().id() == "roundmarker" ||
             m_currentPreset->paintOp().id() == "experimentbrush" ||
             m_currentPreset->paintOp().id() == "duplicate" ) {
 
        // cases where we will not show a preview for now
        // roundbrush (quick) -- this isn't showing anything, disable showing preview
        // experimentbrush -- this creates artifacts that carry over to other previews and messes up their display
        // duplicate (clone) brush doesn't have a preview as it doesn't show anything)
 
        // fill with gray first to clear out what existed from previous preview        
        KisTransaction t(m_layer->paintDevice());
        m_layer->paintDevice()->fill(m_image->bounds(), KoColor(palette().color(QPalette::Window) , m_colorSpace));
        t.end();
 
        m_paintColor = KoColor(palette().color(QPalette::Text), m_colorSpace);
 
        QFont font;
        font.setPixelSize(14);
        font.setBold(false);
 
        m_noPreviewText = this->scene()->addText(i18n("No Preview for this engine"),font);
        m_noPreviewText->setPos(50, this->height()/4);
 
        return;
 
    }
    else {
 
        // fill with gray first to clear out what existed from previous preview
        KisTransaction t(m_layer->paintDevice());
        m_layer->paintDevice()->fill(m_image->bounds(), KoColor(palette().color(QPalette::Window) , m_colorSpace));
        t.end();
 
        m_paintColor = KoColor(palette().color(QPalette::Text), m_colorSpace);
    }
}

References KisImage::bounds(), KisPaintDevice::colorSpace(), KisTransaction::end(), KisPaintDevice::fill(), KoColor::fromQColor(), KisImage::height(), KisBaseNode::image, m_colorSpace, m_currentPreset, m_image, m_layer, m_noPreviewText, m_paintColor, KisBaseNode::paintDevice(), palette, and KisImage::width().

requestUpdateStroke()

void KisPresetLivePreviewView::requestUpdateStroke

(

)

Definition at line 71 of file kis_preset_live_preview_view.cpp.

{
    m_updateCompressor.start();
}

References m_updateCompressor, and KisSignalCompressor::start().

setCurrentPreset()

void KisPresetLivePreviewView::setCurrentPreset

(

KisPaintOpPresetSP

preset

)

set the current preset from resource manager for the live preview to use. Good to call this every stroke update in case the preset has changed

Parameters

preset

the current preset from the resource manager

Definition at line 66 of file kis_preset_live_preview_view.cpp.

{
    m_currentPreset = preset;
}

References m_currentPreset.

setup()

void KisPresetLivePreviewView::setup

(

KoCanvasResourceProvider *

resourceManager

)

one time setup for initialization of many variables. This live preview might be in a UI file, so make sure to call this before starting to use it

Definition at line 35 of file kis_preset_live_preview_view.cpp.

{
    m_resourceManager = resourceManager;
 
    // initializing to 0 helps check later if they actually have something in them
    m_noPreviewText = 0;
    m_sceneImageItem = 0;
 
    setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
    setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
 
 
    // layer image needs to be big enough to get an entire stroke of data
    m_canvasSize.setWidth(this->width());
    m_canvasSize.setHeight(this->height());
 
    m_canvasCenterPoint.setX(m_canvasSize.width()*0.5);
    m_canvasCenterPoint.setY(m_canvasSize.height()*0.5);
 
    m_colorSpace = KoColorSpaceRegistry::instance()->rgb8();
    m_image = new KisImage(0, m_canvasSize.width(), m_canvasSize.height(), m_colorSpace, "stroke sample image");
 
 
    m_layer = new KisPaintLayer(m_image, "livePreviewStrokeSample", OPACITY_OPAQUE_U8, m_colorSpace);
 
    // set scene for the view
    m_brushPreviewScene = new QGraphicsScene();
    setScene(m_brushPreviewScene);
 
}

References KoColorSpaceRegistry::instance(), m_brushPreviewScene, m_canvasCenterPoint, m_canvasSize, m_colorSpace, m_image, m_layer, m_noPreviewText, m_resourceManager, m_sceneImageItem, OPACITY_OPAQUE_U8, and KoColorSpaceRegistry::rgb8().

setupAndPaintStroke()

void KisPresetLivePreviewView::setupAndPaintStroke ( )

private

creates and performs the actual stroke that goes on top of the background this is internally and should always be called after the paintBackground()

Definition at line 217 of file kis_preset_live_preview_view.cpp.

{
    // limit the brush stroke size. larger brush strokes just don't look good and are CPU intensive
    // we are making a proxy preset and setting it to the painter...otherwise setting the brush size of the original preset
    // will fire off signals that make this run in an infinite loop
    qreal previewSize = qBound(3.0, m_currentPreset->settings()->paintOpSize(), 25.0 ); // constrain live preview brush size
    //Except for the sketchbrush where it determines the history.
    if (m_currentPreset->paintOp().id() == "sketchbrush" ||
            m_currentPreset->paintOp().id() == "spraybrush") {
        previewSize = qMax(3.0, m_currentPreset->settings()->paintOpSize());
    }
 
 
    KisPaintOpPresetSP proxy_preset = m_currentPreset->clone().dynamicCast<KisPaintOpPreset>();
    KisPaintOpSettingsSP settings = proxy_preset->settings();
    settings->setPaintOpSize(previewSize);
 
    int maxTextureSize = 200;
    int textureOffsetX = settings->getInt("Texture/Pattern/MaximumOffsetX")*2;
    int textureOffsetY = settings->getInt("Texture/Pattern/MaximumOffsetY")*2;
    double textureScale = settings->getDouble("Texture/Pattern/Scale");
    if ( textureOffsetX*textureScale> maxTextureSize || textureOffsetY*textureScale > maxTextureSize) {
        int maxSize = qMax(textureOffsetX, textureOffsetY);
        double result = qreal(maxTextureSize) / maxSize;
        settings->setProperty("Texture/Pattern/Scale", result);
    }
    if (proxy_preset->paintOp().id() == "spraybrush") {
 
        QDomElement element;
        QDomDocument d;
        QString brushDefinition = settings->getString("brush_definition");
        if (!brushDefinition.isEmpty()) {
            d.setContent(brushDefinition, false);
            element = d.firstChildElement("Brush");
 
            KisBrushSP brush = KisBrush::fromXML(element, KisGlobalResourcesInterface::instance());
 
            qreal width = brush->image().width();
            qreal scale = brush->scale();
            qreal diameterToBrushRatio = 1.0;
            qreal diameter = settings->getInt("Spray/diameter");
            //hack, 1000 being the maximum possible brushsize.
            if (brush->filename().endsWith(".svg", Qt::CaseInsensitive)) {
                diameterToBrushRatio = diameter/(1000.0*scale);
                scale = 25.0 / 1000.0;
            } else {
                if (width * scale > 25.0) {
                    diameterToBrushRatio = diameter / (width * scale);
                    scale = 25.0 / width;
 
                    if (!settings->getBool("SprayShape/proportional")) {
                        settings->setProperty("SprayShape/width", qRound(scale * settings->getInt("SprayShape/width")));
                        settings->setProperty("SprayShape/height", qRound(scale * settings->getInt("SprayShape/height")));
                    }
                }
            }
            settings->setProperty("Spray/diameter", int(25.0 * diameterToBrushRatio));
 
            brush->setScale(scale);
            d.clear();
            element = d.createElement("Brush");
            brush->toXML(d, element);
            d.appendChild(element);
            settings->setProperty("brush_definition", d.toString());
        }
    }
 
    proxy_preset->setSettings(settings);
 
    KisResourcesSnapshotSP resources =
            new KisResourcesSnapshot(m_image,
                                     m_layer, m_resourceManager,
                                     0, {},
                                     proxy_preset);
    resources->setOpacity(settings->paintOpOpacity());
    resources->setMirroring(false, false); // ignore mirroring in toolbar
 
    resources->setFGColorOverride(m_paintColor);
    KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
    KisStrokeStrategy *stroke =
            new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("temp_stroke"));
 
    KisStrokeId strokeId = m_image->startStroke(stroke);
 
    if (proxy_preset->paintOp().id() == "mypaintbrush") {
 
        m_curvePointPI1.setCurrentTime(123);
        m_curvePointPI2.setCurrentTime(1230);
    }
 
    // paint the stroke. The sketchbrush gets a different shape than the others to show how it works
    if (proxy_preset->paintOp().id() == "sketchbrush"
            || proxy_preset->paintOp().id() == "curvebrush"
            || proxy_preset->paintOp().id() == "particlebrush") {
        qreal startX = m_canvasCenterPoint.x() - (this->width()*0.4);
        qreal endX   = m_canvasCenterPoint.x() + (this->width()*0.4);
        qreal middle = m_canvasCenterPoint.y();
        KisPaintInformation pointOne;
        pointOne.setPressure(0.0);
        pointOne.setPos(QPointF(startX, middle));
        KisPaintInformation pointTwo;
        pointTwo.setPressure(0.0);
        pointTwo.setPos(QPointF(startX, middle));
        int repeats = 8;
 
        for (int i = 0; i < repeats; i++) {
            pointOne.setPos(pointTwo.pos());
            pointOne.setPressure(pointTwo.pressure());
 
            pointTwo.setPressure((1.0/repeats)*(i+1));
            qreal xPos = ((1.0/repeats) * (i+1) * (endX-startX) )+startX;
            pointTwo.setPos(QPointF(xPos, middle));
 
            qreal offset = (this->height()/(repeats*1.5))*(i+1);
            qreal handleY = middle + offset;
            if (i%2 == 0) {
                handleY = middle - offset;
            }
 
            m_image->addJob(strokeId,
                            new FreehandStrokeStrategy::Data(0,
                                                             pointOne,
                                                             QPointF(pointOne.pos().x(),
                                                                     handleY),
                                                             QPointF(pointTwo.pos().x(),
                                                                     handleY),
                                                             pointTwo));
            m_image->addJob(strokeId, new KisAsynchronousStrokeUpdateHelper::UpdateData(true));
        }
 
    } else {
 
        // paint an S curve
        m_curvePointPI1.setPos(QPointF(m_canvasCenterPoint.x() - (this->width()*0.45),
                                       m_canvasCenterPoint.y() + (this->height()*0.2)));
        m_curvePointPI1.setPressure(0.0);
 
 
        m_curvePointPI2.setPos(QPointF(m_canvasCenterPoint.x() + (this->width()*0.4),
                                       m_canvasCenterPoint.y() - (this->height()*0.2)   ));
 
        m_curvePointPI2.setPressure(1.0);
 
        m_image->addJob(strokeId,
                        new FreehandStrokeStrategy::Data(0,
                                                         m_curvePointPI1,
                                                         QPointF(m_canvasCenterPoint.x(),
                                                                 m_canvasCenterPoint.y()-this->height()),
                                                         QPointF(m_canvasCenterPoint.x(),
                                                                 m_canvasCenterPoint.y()+this->height()),
                                                         m_curvePointPI2));
        m_image->addJob(strokeId, new KisAsynchronousStrokeUpdateHelper::UpdateData(true));
    }
    m_image->endStroke(strokeId);
 
    m_previewGenerationInProgress = true;
 
    NotificationStroke *notificationStroke = new NotificationStroke();
    connect(notificationStroke, SIGNAL(timeout()), SLOT(slotPreviewGenerationCompleted()));
    KisStrokeId notificationId = m_image->startStroke(notificationStroke);
    m_image->endStroke(notificationId);
 
 
    // TODO: if we don't have any regressions because of it until 4.2.8, then
    //       just remove this code.
    // even though the brush is cloned, the proxy_preset still has some connection to the original preset which will mess brush sizing
    // we need to return brush size to normal.The normal brush sends out a lot of extra signals, so keeping the proxy for now
    //proxy_preset->settings()->setPaintOpSize(originalPresetSize);
 
}

References KisImage::addJob(), connect(), KisImage::endStroke(), KisBrush::fromXML(), KisGlobalResourcesInterface::instance(), kundo2_noi18n(), m_canvasCenterPoint, m_currentPreset, m_curvePointPI1, m_curvePointPI2, m_image, m_layer, m_paintColor, m_previewGenerationInProgress, m_resourceManager, KisPaintInformation::pos(), KisPaintInformation::pressure(), KisPaintInformation::setCurrentTime(), KisResourcesSnapshot::setFGColorOverride(), KisResourcesSnapshot::setMirroring(), KisResourcesSnapshot::setOpacity(), KisPaintInformation::setPos(), KisPaintInformation::setPressure(), slotPreviewGenerationCompleted(), and KisImage::startStroke().

slotPreviewGenerationCompleted

void KisPresetLivePreviewView::slotPreviewGenerationCompleted ( )

privateslot

Definition at line 96 of file kis_preset_live_preview_view.cpp.

{
    m_previewGenerationInProgress = false;
 
    QImage m_temp_image;
    m_temp_image = m_layer->paintDevice()->convertToQImage(0, m_image->bounds());
 
    // only add the object once...then just update the pixmap so we can move the preview around
    if (!m_sceneImageItem) {
        m_sceneImageItem = m_brushPreviewScene->addPixmap(QPixmap::fromImage(m_temp_image));
    } else {
        m_sceneImageItem->setPixmap(QPixmap::fromImage(m_temp_image));
    }
}

References KisImage::bounds(), KisPaintDevice::convertToQImage(), m_brushPreviewScene, m_image, m_layer, m_previewGenerationInProgress, m_sceneImageItem, and KisBaseNode::paintDevice().

updateStroke

void KisPresetLivePreviewView::updateStroke ( )

privateslot

Definition at line 76 of file kis_preset_live_preview_view.cpp.

{
    // do not paint a stroke if we are any of these engines (they have some issue currently)
    if (m_currentPreset->paintOp().id() == "roundmarker" ||
            m_currentPreset->paintOp().id() == "experimentbrush" ||
            m_currentPreset->paintOp().id() == "duplicate") {
 
        paintBackground();
        slotPreviewGenerationCompleted();
        return;
    }
 
    if (!m_previewGenerationInProgress) {
        paintBackground();
        setupAndPaintStroke();
    } else {
        m_updateCompressor.start();
    }
}

References m_currentPreset, m_previewGenerationInProgress, m_updateCompressor, paintBackground(), setupAndPaintStroke(), slotPreviewGenerationCompleted(), and KisSignalCompressor::start().

Member Data Documentation

m_brushPreviewScene

QGraphicsScene* KisPresetLivePreviewView::m_brushPreviewScene {nullptr}

private

the scene that can add items like text and the brush stroke image

Definition at line 82 of file kis_preset_live_preview_view.h.

{nullptr};

m_canvasCenterPoint

QPointF KisPresetLivePreviewView::m_canvasCenterPoint

private

convenience variable used internally when positioning the objects and points in the scene

Definition at line 97 of file kis_preset_live_preview_view.h.

m_canvasSize

QRect KisPresetLivePreviewView::m_canvasSize

private

holds the width and height of the image of the brush preview Probably can later add set functions to make this customizable It is hard-coded to 1200 x 400 for right now for image size

Definition at line 93 of file kis_preset_live_preview_view.h.

m_colorSpace

const KoColorSpace* KisPresetLivePreviewView::m_colorSpace {nullptr}

private

internally sets the color space for brush preview

Definition at line 76 of file kis_preset_live_preview_view.h.

{nullptr};

m_currentBrushSize

float KisPresetLivePreviewView::m_currentBrushSize {1.0}

private

internal reference for internal brush size used to check if our brush size has changed do zooming and other things internally if it has changed

Definition at line 114 of file kis_preset_live_preview_view.h.

{1.0};

m_currentDistance

KisDistanceInformation KisPresetLivePreviewView::m_currentDistance

private

internal variables for constructing the stroke start and end shape there are two points that construct the "S" curve with this

Definition at line 101 of file kis_preset_live_preview_view.h.

m_currentPreset

KisPaintOpPresetSP KisPresetLivePreviewView::m_currentPreset

private

internally stores the current preset. See setCurrentPreset(KisPaintOpPresetSP preset) for setting this externally

Definition at line 109 of file kis_preset_live_preview_view.h.

m_curvedLine

QPainterPath KisPresetLivePreviewView::m_curvedLine

private

Definition at line 102 of file kis_preset_live_preview_view.h.

m_curvePointPI1

KisPaintInformation KisPresetLivePreviewView::m_curvePointPI1

private

Definition at line 103 of file kis_preset_live_preview_view.h.

m_curvePointPI2

KisPaintInformation KisPresetLivePreviewView::m_curvePointPI2

private

Definition at line 104 of file kis_preset_live_preview_view.h.

m_image

KisImageSP KisPresetLivePreviewView::m_image

private

internally sets the image area for brush preview

Definition at line 70 of file kis_preset_live_preview_view.h.

m_layer

KisLayerSP KisPresetLivePreviewView::m_layer

private

internally sets the layer area for brush preview

Definition at line 73 of file kis_preset_live_preview_view.h.

m_maxBrushVal

const float KisPresetLivePreviewView::m_maxBrushVal {100.0}

private

Definition at line 121 of file kis_preset_live_preview_view.h.

{100.0};

m_maxScale

const qreal KisPresetLivePreviewView::m_maxScale {0.3}

private

Definition at line 125 of file kis_preset_live_preview_view.h.

{0.3};

m_maxStrokeScale

const float KisPresetLivePreviewView::m_maxStrokeScale {1.0}

private

Definition at line 129 of file kis_preset_live_preview_view.h.

{1.0}; // for larger brush stroke

m_minBrushVal

const float KisPresetLivePreviewView::m_minBrushVal {10.0}

private

the range of brush sizes that will control zooming in/out

Definition at line 120 of file kis_preset_live_preview_view.h.

{10.0};

m_minScale

const qreal KisPresetLivePreviewView::m_minScale {1.0}

private

range of scale values. 1.0 == 100%

Definition at line 124 of file kis_preset_live_preview_view.h.

{1.0};

m_minStrokeScale

const float KisPresetLivePreviewView::m_minStrokeScale {0.4}

private

multiplier that is used for lengthening the brush stroke points

Definition at line 128 of file kis_preset_live_preview_view.h.

{0.4}; // for smaller brush stroke

m_noPreviewText

QGraphicsTextItem* KisPresetLivePreviewView::m_noPreviewText {nullptr}

private

holds the 'no preview available' text object

Definition at line 88 of file kis_preset_live_preview_view.h.

{nullptr};

m_paintColor

KoColor KisPresetLivePreviewView::m_paintColor

private

the color which is used for rendering the stroke

Definition at line 79 of file kis_preset_live_preview_view.h.

m_previewGenerationInProgress

bool KisPresetLivePreviewView::m_previewGenerationInProgress {false}

private

Definition at line 116 of file kis_preset_live_preview_view.h.

{false};

m_resourceManager

KoCanvasResourceProvider* KisPresetLivePreviewView::m_resourceManager {nullptr}

private

internally sets the Resource Provider for brush preview (allowing gradients in preview)

Definition at line 67 of file kis_preset_live_preview_view.h.

{nullptr};

m_sceneImageItem

QGraphicsPixmapItem* KisPresetLivePreviewView::m_sceneImageItem {nullptr}

private

holds the preview brush stroke data

Definition at line 85 of file kis_preset_live_preview_view.h.

{nullptr};

m_updateCompressor

KisSignalCompressor KisPresetLivePreviewView::m_updateCompressor

private

Definition at line 117 of file kis_preset_live_preview_view.h.

---

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

• libs/ui/widgets/kis_preset_live_preview_view.h
• libs/ui/widgets/kis_preset_live_preview_view.cpp