KisCurveWidget Class Reference

#include <kis_curve_widget.h>

Inheritance diagram for KisCurveWidget:

Public Types
enum	PointConstrain { PointConstrain_None , PointConstrain_AlwaysCorner , PointConstrain_AlwaysSmooth }

Public Slots
void	setCurve (KisCubicCurve inlist)

Signals
void	compressorShouldEmitModified ()
void	curveChanged (const KisCubicCurve &)
void	modified (void)
void	pointSelectedChanged ()
void	shouldFocusIOControls ()
void	shouldSyncIOControls ()

Public Member Functions
void	addPointInTheMiddle ()
void	applyGlobalPointConstrain ()
std::optional< KisCubicCurvePoint >	currentPoint () const
std::optional< QPointF >	currentPointPosition () const
KisCubicCurve	curve ()
void	drawGrid (QPainter &p, int wWidth, int wHeight)
void	dropInOutControls ()
QPixmap	getPixmap ()
PointConstrain	globalPointConstrain () const
std::optional< bool >	isCurrentPointSetAsCorner () const
bool	jumpOverExistingPoints (QPointF &pt, int skipIndex)
	KisCurveWidget (QWidget *parent=nullptr, Qt::WindowFlags f=Qt::WindowFlags())
int	nearestPointInRange (QPointF pt, int wWidth, int wHeight) const
bool	pointSelected () const
	Private (KisCurveWidget *parent)
void	reset (void)
bool	setCurrentPoint (const QPointF &position, bool setAsCorner)
bool	setCurrentPointAsCorner (bool setAsCorner)
bool	setCurrentPointPosition (const QPointF &position)
void	setCurveModified (bool rewriteSpinBoxesValues=true)
void	setCurveRepaint ()
void	setGlobalPointConstrain (PointConstrain constrain)
void	setPixmap (const QPixmap &pix)
void	setState (enumState st)
void	setupInOutControls (QSpinBox *in, QSpinBox *out, int inMin, int inMax, int outMin, int outMax)
enumState	state () const
void	syncIOControls ()
	~KisCurveWidget () override

Public Attributes
KisCubicCurve	m_curve
KisCubicCurvePoint	m_draggedAwayPoint
int	m_draggedAwayPointIndex {0}
KisCurveWidget::PointConstrain	m_globalPointConstrain {KisCurveWidget::PointConstrain_None}
int	m_grab_point_index {-1}
double	m_grabOffsetX {0.0}
double	m_grabOffsetY {0.0}
double	m_grabOriginalX {0.0}
double	m_grabOriginalY {0.0}
int	m_handleSize {12}
KisThreadSafeSignalCompressor	m_modifiedSignalsCompressor
QPixmap	m_pix
QPixmap *	m_pixmapCache {nullptr}
bool	m_pixmapDirty {true}
bool	m_readOnlyMode {false}
bool	m_splineDirty {false}
enumState	m_state {enumState::ST_NORMAL}

Protected Slots
void	notifyModified ()
void	slotCompressorShouldEmitModified ()

Protected Member Functions
void	keyPressEvent (QKeyEvent *) override
void	leaveEvent (QEvent *) override
void	mouseMoveEvent (QMouseEvent *e) override
void	mousePressEvent (QMouseEvent *e) override
void	mouseReleaseEvent (QMouseEvent *e) override
void	paintEvent (QPaintEvent *) override
void	resizeEvent (QResizeEvent *e) override

Properties
bool	pointSelected

Private Attributes
Private *const	d {nullptr}
KisCurveWidget *	m_curveWidget {nullptr}
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Friends
class	CurveEditorItem

Additional Inherited Members
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Detailed Description

KisCurveWidget is a widget that shows a single curve that can be edited by the user. The user can grab the curve and move it; this creates a new control point. Control points can be deleted by selecting a point and pressing the delete key.

(From: https://techbase.kde.org/Projects/Widgets_and_Classes#KisCurveWidget) KisCurveWidget allows editing of spline based y=f(x) curves. Handy for cases where you want the user to control such things as tablet pressure response, color transformations, acceleration by time, aeroplane lift by angle of attack.

Private members for KisCurveWidget class

Definition at line 40 of file kis_curve_widget.h.

Member Enumeration Documentation

PointConstrain

enum KisCurveWidget::PointConstrain

Enumerator
PointConstrain_None
PointConstrain_AlwaysCorner
PointConstrain_AlwaysSmooth

Definition at line 80 of file kis_curve_widget.h.

    {
        PointConstrain_None,
        PointConstrain_AlwaysCorner,
        PointConstrain_AlwaysSmooth,
    };

Constructor & Destructor Documentation

KisCurveWidget()

KisCurveWidget::KisCurveWidget	(	QWidget *	parent = nullptr,
		Qt::WindowFlags	f = Qt::WindowFlags() )

Create a new curve widget with a default curve, that is a straight line from bottom-left to top-right.

Definition at line 53 of file kis_curve_widget.cpp.

        : QWidget(parent, f), d(new KisCurveWidget::Private(this))
{
    setObjectName("KisCurveWidget");
 
    connect(&d->m_modifiedSignalsCompressor, SIGNAL(timeout()), SLOT(notifyModified()));
    connect(this, SIGNAL(compressorShouldEmitModified()), SLOT(slotCompressorShouldEmitModified()));
 
    setMouseTracking(true);
    setAutoFillBackground(false);
    setAttribute(Qt::WA_OpaquePaintEvent);
    setMinimumSize(150, 50);
    setMaximumSize(250, 250);
 
 
    setFocusPolicy(Qt::StrongFocus);
}

References compressorShouldEmitModified(), connect(), d, notifyModified(), and slotCompressorShouldEmitModified().

~KisCurveWidget()

KisCurveWidget::~KisCurveWidget ( )

override

Definition at line 71 of file kis_curve_widget.cpp.

{
    delete d->m_pixmapCache;
    delete d;
}

References d.

Member Function Documentation

addPointInTheMiddle()

void KisCurveWidget::addPointInTheMiddle

(

)

Handy function that creates new point in the middle of the curve and sets focus on the m_intIn field, so the user can move this point anywhere in a moment

Definition at line 245 of file kis_curve_widget.cpp.

{
    QPointF position(0.5, d->m_curve.value(0.5));
 
    if (!d->jumpOverExistingPoints(position, -1))
        return;
 
    const bool setAsCorner = d->m_globalPointConstrain == PointConstrain_AlwaysCorner;
 
    d->m_grab_point_index = d->m_curve.addPoint(position, setAsCorner);
    Q_EMIT pointSelectedChanged();
 
    Q_EMIT shouldFocusIOControls();
    d->setCurveModified();
}

References d, PointConstrain_AlwaysCorner, pointSelectedChanged(), and shouldFocusIOControls().

applyGlobalPointConstrain()

void KisCurveWidget::applyGlobalPointConstrain

(

)

Ensure that all points conform to the global constrain set

compressorShouldEmitModified

void KisCurveWidget::compressorShouldEmitModified ( )

signal

Emitted to notify that the start() function in compressor can be activated. Thanks to that, blocking signals in curve widget blocks "sending signals" (calling start() function) to the signal compressor. It effectively makes signals work nearly the same way they worked before adding the signal compressor in between.

currentPoint()

std::optional< KisCubicCurvePoint > KisCurveWidget::currentPoint

(

)

const

Definition at line 142 of file kis_curve_widget.cpp.

{
    return d->m_grab_point_index >= 0 && d->m_grab_point_index < d->m_curve.curvePoints().count()
            ? std::make_optional(d->m_curve.curvePoints()[d->m_grab_point_index])
            : std::nullopt;
}

References d.

currentPointPosition()

std::optional< QPointF > KisCurveWidget::currentPointPosition

(

)

const

Definition at line 149 of file kis_curve_widget.cpp.

{
    return d->m_grab_point_index >= 0 && d->m_grab_point_index < d->m_curve.curvePoints().count()
            ? std::make_optional(d->m_curve.curvePoints()[d->m_grab_point_index].position())
            : std::nullopt;
}

References d.

curve()

KisCubicCurve KisCurveWidget::curve

(

)

Returns

get a list with all defined points. If you want to know what the y value for a given x is on the curve defined by these points, use getCurveValue().

See also

getCurveValue

Definition at line 519 of file kis_curve_widget.cpp.

{
    return d->m_curve;
}

References d.

curveChanged

void KisCurveWidget::curveChanged ( const KisCubicCurve & )

signal

drawGrid()

void KisCurveWidget::drawGrid ( QPainter & p, int wWidth, int wHeight )

inline

Nothing to be said! =)

dropInOutControls()

void KisCurveWidget::dropInOutControls

(

)

getPixmap()

QPixmap KisCurveWidget::getPixmap

(

)

Definition at line 188 of file kis_curve_widget.cpp.

{
    return d->m_pix;
}

References d.

globalPointConstrain()

KisCurveWidget::PointConstrain KisCurveWidget::globalPointConstrain

(

)

const

Definition at line 163 of file kis_curve_widget.cpp.

{
    return d->m_globalPointConstrain;
}

References d.

isCurrentPointSetAsCorner()

std::optional< bool > KisCurveWidget::isCurrentPointSetAsCorner

(

)

const

Definition at line 156 of file kis_curve_widget.cpp.

{
    return d->m_grab_point_index >= 0 && d->m_grab_point_index < d->m_curve.curvePoints().count()
            ? std::make_optional(d->m_curve.curvePoints()[d->m_grab_point_index].isSetAsCorner())
            : std::nullopt;
}

References d.

jumpOverExistingPoints()

bool KisCurveWidget::jumpOverExistingPoints	(	QPointF &	pt,
		int	skipIndex )

Check whether newly created/moved point pt doesn't overlap with any of existing ones from m_points and adjusts its coordinates. skipIndex is the index of the point, that shouldn't be taken into account during the search (e.g. because it's pt itself)

Returns false in case the point can't be placed anywhere without overlapping

keyPressEvent()

void KisCurveWidget::keyPressEvent ( QKeyEvent * e )

overrideprotected

Definition at line 198 of file kis_curve_widget.cpp.

{
    if (e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace) {
        if (d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.curvePoints().count() - 1) {
            //x() find closest point to get focus afterwards
            double grab_point_x = d->m_curve.curvePoints()[d->m_grab_point_index].x();
 
            int left_of_grab_point_index = d->m_grab_point_index - 1;
            int right_of_grab_point_index = d->m_grab_point_index + 1;
            int new_grab_point_index;
 
            if (fabs(d->m_curve.curvePoints()[left_of_grab_point_index].x() - grab_point_x) <
                    fabs(d->m_curve.curvePoints()[right_of_grab_point_index].x() - grab_point_x)) {
                new_grab_point_index = left_of_grab_point_index;
            } else {
                new_grab_point_index = d->m_grab_point_index;
            }
            d->m_curve.removePoint(d->m_grab_point_index);
            d->m_grab_point_index = new_grab_point_index;
            Q_EMIT pointSelectedChanged();
            setCursor(Qt::ArrowCursor);
            d->setState(ST_NORMAL);
        }
        e->accept();
        d->setCurveModified();
    } else if (e->key() == Qt::Key_Escape && d->state() != ST_NORMAL) {
        d->m_curve.setPointPosition(d->m_grab_point_index, QPointF(d->m_grabOriginalX, d->m_grabOriginalY) );
        setCursor(Qt::ArrowCursor);
        d->setState(ST_NORMAL);
 
        e->accept();
        d->setCurveModified();
    } else if ((e->key() == Qt::Key_A || e->key() == Qt::Key_Insert) && d->state() == ST_NORMAL) {
        /* FIXME: Lets user choose the hotkeys */
        addPointInTheMiddle();
        e->accept();
    } else if (e->key() == Qt::Key_S &&
               d->m_globalPointConstrain == PointConstrain_None &&
               pointSelected() &&
               d->state() == ST_NORMAL) {
        /* FIXME: Lets user choose the hotkeys */
        setCurrentPointAsCorner(!*isCurrentPointSetAsCorner());
        e->accept();
    } else
        QWidget::keyPressEvent(e);
}

References addPointInTheMiddle(), d, isCurrentPointSetAsCorner(), PointConstrain_None, pointSelected, pointSelectedChanged(), setCurrentPointAsCorner(), and ST_NORMAL.

leaveEvent()

void KisCurveWidget::leaveEvent ( QEvent * )

overrideprotected

Definition at line 533 of file kis_curve_widget.cpp.

{
}

modified

void KisCurveWidget::modified ( void )

signal

Emitted whenever a control point has changed position.

mouseMoveEvent()

void KisCurveWidget::mouseMoveEvent ( QMouseEvent * e )

overrideprotected

Definition at line 444 of file kis_curve_widget.cpp.

{
    if (d->m_readOnlyMode) return;
 
    double x = e->pos().x() / (double)(width() - 1);
    double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
    if (d->state() == ST_NORMAL) { // If no point is selected set the cursor shape if on top
        int nearestPointIndex = d->nearestPointInRange(QPointF(x, y), width(), height());
 
        if (nearestPointIndex < 0)
            setCursor(Qt::ArrowCursor);
        else
            setCursor(Qt::CrossCursor);
    } else { // Else, drag the selected point
        bool crossedHoriz = e->pos().x() - width() > MOUSE_AWAY_THRES ||
                            e->pos().x() < -MOUSE_AWAY_THRES;
        bool crossedVert =  e->pos().y() - height() > MOUSE_AWAY_THRES ||
                            e->pos().y() < -MOUSE_AWAY_THRES;
 
        bool removePoint = (crossedHoriz || crossedVert);
 
        if (!removePoint && d->m_draggedAwayPointIndex >= 0) {
            // point is no longer dragged away so reinsert it
            KisCubicCurvePoint newPoint(d->m_draggedAwayPoint);
            d->m_grab_point_index = d->m_curve.addPoint(newPoint);
            d->m_draggedAwayPointIndex = -1;
        }
 
        if (removePoint &&
                (d->m_draggedAwayPointIndex >= 0))
            return;
 
 
        setCursor(Qt::CrossCursor);
 
        x += d->m_grabOffsetX;
        y += d->m_grabOffsetY;
 
        double leftX;
        double rightX;
        if (d->m_grab_point_index == 0) {
            leftX = 0.0;
            if (d->m_curve.curvePoints().count() > 1)
                rightX = d->m_curve.curvePoints()[d->m_grab_point_index + 1].x() - POINT_AREA;
            else
                rightX = 1.0;
        } else if (d->m_grab_point_index == d->m_curve.curvePoints().count() - 1) {
            leftX = d->m_curve.curvePoints()[d->m_grab_point_index - 1].x() + POINT_AREA;
            rightX = 1.0;
        } else {
            Q_ASSERT(d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.curvePoints().count() - 1);
 
            // the 1E-4 addition so we can grab the dot later.
            leftX = d->m_curve.curvePoints()[d->m_grab_point_index - 1].x() + POINT_AREA;
            rightX = d->m_curve.curvePoints()[d->m_grab_point_index + 1].x() - POINT_AREA;
        }
 
        x = bounds(x, leftX, rightX);
        y = bounds(y, 0., 1.);
 
        d->m_curve.setPointPosition(d->m_grab_point_index, QPointF(x, y));
 
        if (removePoint && d->m_curve.curvePoints().count() > 2) {
            d->m_draggedAwayPoint = d->m_curve.curvePoints()[d->m_grab_point_index];
            d->m_draggedAwayPointIndex = d->m_grab_point_index;
            d->m_curve.removePoint(d->m_grab_point_index);
            d->m_grab_point_index = bounds(d->m_grab_point_index, 0, d->m_curve.curvePoints().count() - 1);
            Q_EMIT pointSelectedChanged();
        }
 
        d->setCurveModified();
    }
}

References bounds, d, MOUSE_AWAY_THRES, POINT_AREA, pointSelectedChanged(), and ST_NORMAL.

mousePressEvent()

void KisCurveWidget::mousePressEvent ( QMouseEvent * e )

overrideprotected

Definition at line 385 of file kis_curve_widget.cpp.

{
    if (d->m_readOnlyMode) return;
 
    if (e->button() != Qt::LeftButton)
        return;
 
    double x = e->pos().x() / (double)(width() - 1);
    double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
 
 
    int closest_point_index = d->nearestPointInRange(QPointF(x, y), width(), height());
    if (closest_point_index < 0) {
        QPointF newPoint(x, y);
        if (!d->jumpOverExistingPoints(newPoint, -1))
            return;
 
        const bool setAsCorner = d->m_globalPointConstrain == PointConstrain_AlwaysCorner;
        d->m_grab_point_index = d->m_curve.addPoint(newPoint, setAsCorner);
        Q_EMIT pointSelectedChanged();
    } else {
        d->m_grab_point_index = closest_point_index;
        Q_EMIT pointSelectedChanged();
    }
 
    const KisCubicCurvePoint &currentPoint = d->m_curve.curvePoints()[d->m_grab_point_index];
    
    d->m_grabOriginalX = currentPoint.x();
    d->m_grabOriginalY = currentPoint.y();
    d->m_grabOffsetX = currentPoint.x() - x;
    d->m_grabOffsetY = currentPoint.y() - y;
    if (e->modifiers().testFlag(Qt::ControlModifier) && d->m_globalPointConstrain == PointConstrain_None) {
        d->m_curve.setPointAsCorner(d->m_grab_point_index, !currentPoint.isSetAsCorner());
    }
    d->m_curve.setPointPosition(d->m_grab_point_index, QPointF(x + d->m_grabOffsetX, y + d->m_grabOffsetY));
 
    d->m_draggedAwayPointIndex = -1;
    d->setState(ST_DRAG);
 
 
    d->setCurveModified();
}

References currentPoint(), d, PointConstrain_AlwaysCorner, PointConstrain_None, pointSelectedChanged(), and ST_DRAG.

mouseReleaseEvent()

void KisCurveWidget::mouseReleaseEvent ( QMouseEvent * e )

overrideprotected

Definition at line 430 of file kis_curve_widget.cpp.

{
    if (d->m_readOnlyMode) return;
 
    if (e->button() != Qt::LeftButton)
        return;
 
    setCursor(Qt::ArrowCursor);
    d->setState(ST_NORMAL);
 
    d->setCurveModified();
}

References d, and ST_NORMAL.

nearestPointInRange()

int KisCurveWidget::nearestPointInRange	(	QPointF	pt,
		int	wWidth,
		int	wHeight ) const

Find the nearest point to pt from m_points

notifyModified

void KisCurveWidget::notifyModified ( )

protectedslot

Definition at line 537 of file kis_curve_widget.cpp.

{
    Q_EMIT modified();
    Q_EMIT curveChanged(d->m_curve);
}

References curveChanged(), d, and modified().

paintEvent()

void KisCurveWidget::paintEvent ( QPaintEvent * )

overrideprotected

Keep in mind that QLineF rounds doubles to ints mathematically, not just rounds down like in C

Definition at line 267 of file kis_curve_widget.cpp.

{
    int    wWidth = width() - 1;
    int    wHeight = height() - 1;
 
 
    QPainter p(this);
 
    // Antialiasing is not a good idea here, because
    // the grid will drift one pixel to any side due to rounding of int
    // FIXME: let's user tell the last word (in config)
    //p.setRenderHint(QPainter::Antialiasing);
     QPalette appPalette = QApplication::palette();
     p.fillRect(rect(), appPalette.color(QPalette::Base)); // clear out previous paint call results
 
     // make the entire widget grayed out if it is disabled
     if (!this->isEnabled()) {
        p.setOpacity(0.2);
     }
 
 
 
    //  draw background
    if (!d->m_pix.isNull()) {
        if (d->m_pixmapDirty || !d->m_pixmapCache) {
            delete d->m_pixmapCache;
            d->m_pixmapCache = new QPixmap(width(), height());
            QPainter cachePainter(d->m_pixmapCache);
 
            cachePainter.scale(1.0*width() / d->m_pix.width(), 1.0*height() / d->m_pix.height());
            cachePainter.drawPixmap(0, 0, d->m_pix);
            d->m_pixmapDirty = false;
        }
        p.drawPixmap(0, 0, *d->m_pixmapCache);
    }
 
    d->drawGrid(p, wWidth, wHeight);
 
    KisConfig cfg(true);
    if (cfg.antialiasCurves()) {
        p.setRenderHint(QPainter::Antialiasing);
    }
 
    // Draw curve.
    double curY;
    double normalizedX;
    int x;
 
    QPolygonF poly;
 
    p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
    for (x = 0 ; x < wWidth ; x++) {
        normalizedX = double(x) / wWidth;
        curY = wHeight - d->m_curve.value(normalizedX) * wHeight;
 
        poly.append(QPointF(x, curY));
    }
    poly.append(QPointF(x, wHeight - d->m_curve.value(1.0) * wHeight));
    p.drawPolyline(poly);
 
    QPainterPath fillCurvePath;
    QPolygonF fillPoly = poly;
    fillPoly.append(QPoint(rect().width(), rect().height()));
    fillPoly.append(QPointF(0,rect().height()));
 
    // add a couple points to the edges so it fills in below always
 
    QColor fillColor = appPalette.color(QPalette::Text);
    fillColor.setAlphaF(0.2);
 
    fillCurvePath.addPolygon(fillPoly);
    p.fillPath(fillCurvePath, fillColor);
 
 
 
    // Drawing curve handles.
    if (!d->m_readOnlyMode) {
        const qreal halfHandleSize = d->m_handleSize * 0.5;
 
        for (int i = 0; i < d->m_curve.curvePoints().count(); ++i) {
            const KisCubicCurvePoint &point = d->m_curve.points().at(i);
 
            if (i == d->m_grab_point_index) {
                // active point is slightly more "bold"
                p.setPen(QPen(appPalette.color(QPalette::Text), 4, Qt::SolidLine));
            } else {
                p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
            }
 
            const QPointF handleCenter(point.x() * wWidth, wHeight - point.y() * wHeight);
 
            if (point.isSetAsCorner()) {
                QPolygonF rhombusHandle;
                rhombusHandle.append(QPointF(handleCenter.x() - halfHandleSize, handleCenter.y()));
                rhombusHandle.append(QPointF(handleCenter.x(), handleCenter.y() - halfHandleSize));
                rhombusHandle.append(QPointF(handleCenter.x() + halfHandleSize, handleCenter.y()));
                rhombusHandle.append(QPointF(handleCenter.x(), handleCenter.y() + halfHandleSize));
                p.drawPolygon(rhombusHandle);
            } else {
                p.drawEllipse(handleCenter, halfHandleSize, halfHandleSize);
            }
        }
    }
 
    // add border around widget to help contain everything
    QPainterPath widgetBoundsPath;
    widgetBoundsPath.addRect(rect());
    p.strokePath(widgetBoundsPath, appPalette.color(QPalette::Text));
 
 
    p.setOpacity(1.0); // reset to 1.0 in case we were drawing a disabled widget before
}

References KisConfig::antialiasCurves(), d, KisCubicCurvePoint::isSetAsCorner(), p, KisCubicCurvePoint::x(), and KisCubicCurvePoint::y().

pointSelected()

bool KisCurveWidget::pointSelected

(

)

const

Whether or not there is a point selected This does NOT include the first and last points

Definition at line 193 of file kis_curve_widget.cpp.

{
    return d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.curvePoints().count();
}

References d.

pointSelectedChanged

void KisCurveWidget::pointSelectedChanged ( )

signal

Emitted whenever the status of whether a control point is selected or not changes

Private()

KisCurveWidget::Private

(

KisCurveWidget *

parent

)

reset()

void KisCurveWidget::reset

(

void

)

Reset the curve to the default shape

Definition at line 168 of file kis_curve_widget.cpp.

{
    d->m_grab_point_index = -1;
    Q_EMIT pointSelectedChanged();
 
    //remove total - 2 points.
    while (d->m_curve.curvePoints().count() - 2 ) {
        d->m_curve.removePoint(d->m_curve.curvePoints().count() - 2);
    }
 
    d->setCurveModified();
}

References d, and pointSelectedChanged().

resizeEvent()

void KisCurveWidget::resizeEvent ( QResizeEvent * e )

overrideprotected

Definition at line 261 of file kis_curve_widget.cpp.

{
    d->m_pixmapDirty = true;
    QWidget::resizeEvent(e);
}

References d.

setCurrentPoint()

bool KisCurveWidget::setCurrentPoint	(	const QPointF &	position,
		bool	setAsCorner )

Definition at line 77 of file kis_curve_widget.cpp.

{
    Q_ASSERT(d->m_grab_point_index >= 0);
 
    bool needResyncControls = true;
    bool isCorner;
 
    if (d->m_globalPointConstrain == PointConstrain_None) {
        d->m_curve.setPointAsCorner(d->m_grab_point_index, setAsCorner);
        isCorner = setAsCorner;
    } else {
        isCorner = d->m_globalPointConstrain == PointConstrain_AlwaysCorner;
    }
 
    QPointF newPosition(position);
 
    if (d->jumpOverExistingPoints(newPosition, d->m_grab_point_index)) {
        needResyncControls = false;
        d->m_curve.setPointPosition(d->m_grab_point_index, newPosition);
        d->m_grab_point_index = d->m_curve.curvePoints().indexOf(
            KisCubicCurvePoint(newPosition, isCorner)
        );
        Q_EMIT pointSelectedChanged();
    }
 
    d->setCurveModified(false);
    return needResyncControls;
}

References d, PointConstrain_AlwaysCorner, PointConstrain_None, and pointSelectedChanged().

setCurrentPointAsCorner()

bool KisCurveWidget::setCurrentPointAsCorner

(

bool

setAsCorner

)

Definition at line 113 of file kis_curve_widget.cpp.

{
    Q_ASSERT(d->m_grab_point_index >= 0);
 
    // Setting the point corner flag is not allowed if there is some global constrain set
    if (d->m_globalPointConstrain != PointConstrain_None) {
        return false;
    }
 
    if (setAsCorner != d->m_curve.curvePoints()[d->m_grab_point_index].isSetAsCorner()) {
        d->m_curve.setPointAsCorner(d->m_grab_point_index, setAsCorner);
        d->setCurveModified(false);
    }
 
    return false;
}

References d, and PointConstrain_None.

setCurrentPointPosition()

bool KisCurveWidget::setCurrentPointPosition

(

const QPointF &

position

)

Definition at line 106 of file kis_curve_widget.cpp.

{
    Q_ASSERT(d->m_grab_point_index >= 0);
 
    return setCurrentPoint(position, d->m_curve.curvePoints()[d->m_grab_point_index].isSetAsCorner());
}

References d, and setCurrentPoint().

setCurve

void KisCurveWidget::setCurve ( KisCubicCurve inlist )

slot

Replace the current curve with a curve specified by the curve defined by the control points in inlist.

Definition at line 524 of file kis_curve_widget.cpp.

{
    d->m_curve = inlist;
    d->m_grab_point_index = qBound(0, d->m_grab_point_index, d->m_curve.curvePoints().count() - 1);
    d->applyGlobalPointConstrain();
    d->setCurveModified();
    Q_EMIT pointSelectedChanged();
}

References d, and pointSelectedChanged().

setCurveModified()

void KisCurveWidget::setCurveModified

(

bool

rewriteSpinBoxesValues = true

)

Common update routines

setCurveRepaint()

void KisCurveWidget::setCurveRepaint

(

)

setGlobalPointConstrain()

void KisCurveWidget::setGlobalPointConstrain

(

PointConstrain

constrain

)

Definition at line 130 of file kis_curve_widget.cpp.

{
    if (d->m_globalPointConstrain == constrain) {
        return;
    }
    
    d->m_globalPointConstrain = constrain;
    d->applyGlobalPointConstrain();
 
    d->setCurveModified(false);
}

References d.

setPixmap()

void KisCurveWidget::setPixmap

(

const QPixmap &

pix

)

Set a background pixmap. The background pixmap will be drawn under the grid and the curve.

XXX: or is the pixmap what is drawn to the left and bottom of the curve itself?

Definition at line 181 of file kis_curve_widget.cpp.

{
    d->m_pix = pix;
    d->m_pixmapDirty = true;
    d->setCurveRepaint();
}

References d.

setState()

void KisCurveWidget::setState ( enumState st )

inline

setupInOutControls()

void KisCurveWidget::setupInOutControls	(	QSpinBox *	in,
		QSpinBox *	out,
		int	inMin,
		int	inMax,
		int	outMin,
		int	outMax )

Connect/disconnect external spinboxes to the curve inMin / inMax - is the range for input values outMin / outMax - is the range for output values

shouldFocusIOControls

void KisCurveWidget::shouldFocusIOControls ( )

signal

shouldSyncIOControls

void KisCurveWidget::shouldSyncIOControls ( )

signal

slotCompressorShouldEmitModified

void KisCurveWidget::slotCompressorShouldEmitModified ( )

protectedslot

This function is called when compressorShouldEmitModified() is emitted. For why it's needed,

See also

compressorShouldEmitModified()

Definition at line 543 of file kis_curve_widget.cpp.

{
    d->m_modifiedSignalsCompressor.start();
}

References d.

state()

enumState KisCurveWidget::state ( ) const

inline

syncIOControls()

void KisCurveWidget::syncIOControls

(

)

Synchronize In/Out spinboxes with the curve

Friends And Related Symbol Documentation

CurveEditorItem

friend class CurveEditorItem

friend

Definition at line 46 of file kis_curve_widget.h.

Member Data Documentation

d

Private* const KisCurveWidget::d {nullptr}

private

Definition at line 175 of file kis_curve_widget.h.

{nullptr};

m_curve

KisCubicCurve KisCurveWidget::m_curve

Definition at line 42 of file kis_curve_widget_p.h.

m_curveWidget

KisCurveWidget* KisCurveWidget::m_curveWidget {nullptr}

private

Definition at line 24 of file kis_curve_widget_p.h.

{nullptr};

m_draggedAwayPoint

KisCubicCurvePoint KisCurveWidget::m_draggedAwayPoint

Definition at line 35 of file kis_curve_widget_p.h.

m_draggedAwayPointIndex

int KisCurveWidget::m_draggedAwayPointIndex {0}

Definition at line 36 of file kis_curve_widget_p.h.

{0};

m_globalPointConstrain

KisCurveWidget::PointConstrain KisCurveWidget::m_globalPointConstrain {KisCurveWidget::PointConstrain_None}

Definition at line 43 of file kis_curve_widget_p.h.

{KisCurveWidget::PointConstrain_None};

m_grab_point_index

int KisCurveWidget::m_grab_point_index {-1}

Definition at line 30 of file kis_curve_widget_p.h.

{-1};

m_grabOffsetX

double KisCurveWidget::m_grabOffsetX {0.0}

Definition at line 31 of file kis_curve_widget_p.h.

{0.0};

m_grabOffsetY

double KisCurveWidget::m_grabOffsetY {0.0}

Definition at line 32 of file kis_curve_widget_p.h.

{0.0};

m_grabOriginalX

double KisCurveWidget::m_grabOriginalX {0.0}

Definition at line 33 of file kis_curve_widget_p.h.

{0.0};

m_grabOriginalY

double KisCurveWidget::m_grabOriginalY {0.0}

Definition at line 34 of file kis_curve_widget_p.h.

{0.0};

m_handleSize

int KisCurveWidget::m_handleSize {12}

Definition at line 50 of file kis_curve_widget_p.h.

{12}; // size of the control points (diameter, in logical pixels) - both for painting and for detecting clicks

m_modifiedSignalsCompressor

KisThreadSafeSignalCompressor KisCurveWidget::m_modifiedSignalsCompressor

Compresses the modified() signals

Definition at line 64 of file kis_curve_widget_p.h.

m_pix

QPixmap KisCurveWidget::m_pix

Definition at line 45 of file kis_curve_widget_p.h.

m_pixmapCache

QPixmap* KisCurveWidget::m_pixmapCache {nullptr}

Definition at line 47 of file kis_curve_widget_p.h.

{nullptr};

m_pixmapDirty

bool KisCurveWidget::m_pixmapDirty {true}

Definition at line 46 of file kis_curve_widget_p.h.

{true};

m_readOnlyMode

bool KisCurveWidget::m_readOnlyMode {false}

Definition at line 38 of file kis_curve_widget_p.h.

{false};

m_splineDirty

bool KisCurveWidget::m_splineDirty {false}

Definition at line 41 of file kis_curve_widget_p.h.

{false};

m_state

enumState KisCurveWidget::m_state {enumState::ST_NORMAL}

State functions. At the moment used only for dragging.

Definition at line 56 of file kis_curve_widget_p.h.

{enumState::ST_NORMAL};

Property Documentation

pointSelected

bool KisCurveWidget::pointSelected

read

Definition at line 43 of file kis_curve_widget.h.

---

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

• libs/ui/widgets/kis_curve_widget.h
• libs/ui/widgets/kis_curve_widget_p.h
• libs/ui/widgets/kis_curve_widget.cpp