KisPipeBrushParasite Class Reference

#include <kis_pipebrush_parasite.h>

Public Types
enum	Placement { DefaultPlacement , ConstantPlacement , RandomPlacement }

Public Member Functions
void	init ()
	KisPipeBrushParasite ()
	Set some default values.
	KisPipeBrushParasite (QStringView source)
	Load the parasite from the source string.
bool	loadFromDevice (QIODevice *dev)
void	sanitize ()
bool	saveToDevice (QIODevice *dev) const
void	setBrushesCount ()
	Initializes the brushesCount helper.

Public Attributes
qint32	brushesCount [MaxDim]
	The total count of brushes in each dimension (helper)
qint32	dim {0}
qint32	index [MaxDim]
	The current index in each dimension, so that the selection modes know where to start.
qint32	ncells {0}
bool	needsMovement {false}
	If true, the brush won't be painted when there is no motion.
qint32	rank [MaxDim] {}
KisParasite::SelectionMode	selection [MaxDim]
QString	selectionMode

Static Public Attributes
static int const	MaxDim = 4

Detailed Description

The parasite info that gets loaded from the terribly documented gimp pipe brush parasite.

We only store data we actually use.

BC: How it seems the dimension stuff interacts with rank, selectionMode and the actual selection of a brush to be drawn. So apparently you can have at most 4 'dimensions'. Each dimension has a number of brushes, the rank. Each dimension has an associated selection mode and placement mode (which we don't use). The selection mode says us in which way which of the brushes or brush sets will be selected. In the case of a 1-dimensional pipe brush it is easy.

However, when there are more dimensions it is a bit harder. You can according to the gimp source maximally use 4 dimensions. When you want to select a brush, you first go to the first dimension. Say it has a rank of 2. The code chooses one of the 2 according to the selection mode. Say we choose 2. Then the currentBrush will skip over all the brushes from the first element in dimension 1. Then in dimension we pick again from the choices we have in dimension 2. We again add the appropriate amount to currentBrush. And so on, until we have reached dimension dim. Or at least, that is how it looks like, we'll know for sure when we can test it better with >1 dim brushes and Angular selectionMode.

Definition at line 48 of file kis_pipebrush_parasite.h.

Member Enumeration Documentation

Placement

enum KisPipeBrushParasite::Placement

Enumerator
DefaultPlacement
ConstantPlacement
RandomPlacement

Definition at line 74 of file kis_pipebrush_parasite.h.

{ DefaultPlacement, ConstantPlacement, RandomPlacement };

Constructor & Destructor Documentation

KisPipeBrushParasite() [1/2]

KisPipeBrushParasite::KisPipeBrushParasite ( )

inline

Set some default values.

Definition at line 52 of file kis_pipebrush_parasite.h.

        : ncells(0)
        , dim(0)
        , needsMovement(false) {
        init();
    }

KisPipeBrushParasite() [2/2]

KisPipeBrushParasite::KisPipeBrushParasite

(

QStringView

source

)

Load the parasite from the source string.

Definition at line 11 of file kis_pipebrush_parasite.cpp.

{
    init();
    needsMovement = false;
 
    const QList<QStringView> parasites = source.split(QLatin1Char(' '), Qt::SkipEmptyParts);
 
    for (int i = 0; i < parasites.count(); i++) {
        const QList<QStringView> split = parasites.at(i).split(QLatin1Char(':'), Qt::SkipEmptyParts);
 
        if (split.count() != 2) {
            warnImage << "Wrong count for this parasite key/value:" << parasites.at(i);
            continue;
        }
        const QStringView &index = split.at(0);
        if (index == QLatin1String("dim")) {
            dim = (split.at(1)).toInt();
            if (dim < 1 || dim > MaxDim) {
                dim = 1;
            }
        } else if (index.startsWith(QLatin1String("sel"))) {
            int selIndex = index.mid(strlen("sel")).toInt();
 
            if (selIndex >= 0 && selIndex < dim) {
                selectionMode = split.at(1).toString();
 
                if (selectionMode == QLatin1String("incremental")) {
                    selection[selIndex] = KisParasite::Incremental;
                } else if (selectionMode == QLatin1String("angular")) {
                    selection[selIndex] = KisParasite::Angular;
                    needsMovement = true;
                } else if (selectionMode == QLatin1String("random")) {
                    selection[selIndex] = KisParasite::Random;
                } else if (selectionMode == QLatin1String("pressure")) {
                    selection[selIndex] = KisParasite::Pressure;
                } else if (selectionMode == QLatin1String("xtilt")) {
                    selection[selIndex] = KisParasite::TiltX;
                } else if (selectionMode == QLatin1String("ytilt")) {
                    selection[selIndex] = KisParasite::TiltY;
                } else if (selectionMode == QLatin1String("velocity")) {
                    selection[selIndex] = KisParasite::Velocity;
                } else {
                    selection[selIndex] = KisParasite::Constant;
                }
            }
            else {
                warnImage << "Sel: wrong index: " << selIndex << "(dim = " << dim << ")";
            }
        } else if (index.startsWith(QLatin1String("rank"))) {
            int rankIndex = index.mid(strlen("rank")).toInt();
            if (rankIndex < 0 || rankIndex > dim) {
                warnImage << "Rankindex out of range: " << rankIndex;
                continue;
            }
            rank[rankIndex] = (split.at(1)).toInt();
        } else if (index == QLatin1String("ncells")) {
            ncells = (split.at(1)).toInt();
            if (ncells < 1) {
                warnImage << "ncells out of range: " << ncells;
                ncells = 1;
            }
        }
    }
 
    for (int i = 0; i < dim; i++) {
        index[i] = 0;
    }
 
    setBrushesCount();
}

References KisParasite::Angular, KisParasite::Constant, dim, KisParasite::Incremental, index, init(), MaxDim, ncells, needsMovement, KisParasite::Pressure, KisParasite::Random, rank, selection, selectionMode, setBrushesCount(), source(), KisParasite::TiltX, KisParasite::TiltY, KisParasite::Velocity, and warnImage.

Member Function Documentation

init()

void KisPipeBrushParasite::init

(

)

Definition at line 82 of file kis_pipebrush_parasite.cpp.

{
    for (int i = 0; i < MaxDim; i++) {
        rank[i] = index[i] = brushesCount[i] = 0;
        selection[i] = KisParasite::Constant;
    }
}

References brushesCount, KisParasite::Constant, index, MaxDim, rank, and selection.

loadFromDevice()

bool KisPipeBrushParasite::loadFromDevice

(

QIODevice *

dev

)

sanitize()

void KisPipeBrushParasite::sanitize

(

)

Definition at line 90 of file kis_pipebrush_parasite.cpp.

{
    for (int i = 0; i < dim; i++) {
        // In the 2 listed cases, we'd divide by 0!
        if (rank[i] == 0 &&
                (selection[i] == KisParasite::Incremental
                 || selection[i] == KisParasite::Angular)) {
 
            warnImage << "PIPE brush has a wrong rank for its selection mode!";
            selection[i] = KisParasite::Constant;
        }
    }
}

References KisParasite::Angular, KisParasite::Constant, dim, KisParasite::Incremental, rank, selection, and warnImage.

saveToDevice()

bool KisPipeBrushParasite::saveToDevice

(

QIODevice *

dev

)

const

Saves a GIMP-compatible representation of this parasite to the device. Also writes the number of brushes (== ncells) (no trailing '
')

Definition at line 124 of file kis_pipebrush_parasite.cpp.

{
    // write out something like
    // <count> ncells:<count> dim:<dim> rank0:<rank0> sel0:<sel0> <...>
 
    QTextStream stream(dev);
    KisPortingUtils::setUtf8OnStream(stream);
 
    // XXX: FIXME things like step, placement and so are not added (nor loaded, as a matter of fact)"
    stream << ncells << " ncells:" << ncells << " dim:" << dim;
 
    for (int i = 0; i < dim; i++) {
        stream << " rank" << i << ":" << rank[i] << " sel" << i << ":";
        switch (selection[i]) {
        case KisParasite::Constant:
            stream << "constant"; break;
        case KisParasite::Incremental:
            stream << "incremental"; break;
        case KisParasite::Angular:
            stream << "angular"; break;
        case KisParasite::Velocity:
            stream << "velocity"; break;
        case KisParasite::Random:
            stream << "random"; break;
        case KisParasite::Pressure:
            stream << "pressure"; break;
        case KisParasite::TiltX:
            stream << "xtilt"; break;
        case KisParasite::TiltY:
            stream << "ytilt"; break;
        }
    }
 
    return true;
}

References KisParasite::Angular, KisParasite::Constant, dim, KisParasite::Incremental, ncells, KisParasite::Pressure, KisParasite::Random, rank, selection, KisPortingUtils::setUtf8OnStream(), KisParasite::TiltX, KisParasite::TiltY, and KisParasite::Velocity.

setBrushesCount()

void KisPipeBrushParasite::setBrushesCount

(

)

Initializes the brushesCount helper.

Definition at line 104 of file kis_pipebrush_parasite.cpp.

{
    // I assume ncells is correct. If it isn't, complain to the parasite header.
    if (rank[0] != 0) {
        brushesCount[0] = ncells / rank[0];
    }
    else {
        brushesCount[0] = ncells;
    }
 
    for (int i = 1; i < dim; i++) {
        if (rank[i] == 0) {
            brushesCount[i] = brushesCount[i - 1];
        }
        else {
            brushesCount[i] = brushesCount[i - 1] / rank[i];
        }
    }
}

References brushesCount, dim, ncells, and rank.

Member Data Documentation

brushesCount

qint32 KisPipeBrushParasite::brushesCount[MaxDim]

The total count of brushes in each dimension (helper)

Definition at line 94 of file kis_pipebrush_parasite.h.

dim

qint32 KisPipeBrushParasite::dim {0}

Definition at line 80 of file kis_pipebrush_parasite.h.

{0};

index

qint32 KisPipeBrushParasite::index[MaxDim]

The current index in each dimension, so that the selection modes know where to start.

Definition at line 97 of file kis_pipebrush_parasite.h.

MaxDim

int const KisPipeBrushParasite::MaxDim = 4

static

Definition at line 76 of file kis_pipebrush_parasite.h.

ncells

qint32 KisPipeBrushParasite::ncells {0}

Definition at line 79 of file kis_pipebrush_parasite.h.

{0};

needsMovement

bool KisPipeBrushParasite::needsMovement {false}

If true, the brush won't be painted when there is no motion.

Definition at line 100 of file kis_pipebrush_parasite.h.

{false};

rank

qint32 KisPipeBrushParasite::rank[MaxDim] {}

Definition at line 88 of file kis_pipebrush_parasite.h.

{};

selection

KisParasite::SelectionMode KisPipeBrushParasite::selection[MaxDim]

Definition at line 90 of file kis_pipebrush_parasite.h.

selectionMode

QString KisPipeBrushParasite::selectionMode

Definition at line 91 of file kis_pipebrush_parasite.h.

---

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

• libs/brush/kis_pipebrush_parasite.h
• libs/brush/kis_pipebrush_parasite.cpp