KisAbrBrushCollection Class Reference

#include <kis_abr_brush_collection.h>

Public Member Functions
KisAbrBrushSP	brushByName (QString name) const
QList< KisAbrBrushSP >	brushes () const
QSharedPointer< QMap< QString, KisAbrBrushSP > >	brushesMap () const
QString	defaultFileExtension () const
QString	filename () const
QImage	image () const
bool	isLoaded () const
	KisAbrBrushCollection (const QString &filename)
	Construct brush to load filename later as brush.
QDateTime	lastModified () const
bool	load ()
bool	loadFromDevice (QIODevice *dev)
bool	save ()
bool	saveToDevice (QIODevice *dev) const
	~KisAbrBrushCollection ()

Protected Member Functions
	KisAbrBrushCollection (const KisAbrBrushCollection &rhs)
void	toXML (QDomDocument &d, QDomElement &e) const

Private Member Functions
qint32	abr_brush_load (QDataStream &abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)
qint32	abr_brush_load_v12 (QDataStream &abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)
quint32	abr_brush_load_v6 (QDataStream &abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)

Private Attributes
QSharedPointer< QMap< QString, KisAbrBrushSP > >	m_abrBrushes
QString	m_filename
bool	m_isLoaded
QDateTime	m_lastModified

Detailed Description

load a collection of brushes from an abr file

Definition at line 32 of file kis_abr_brush_collection.h.

Constructor & Destructor Documentation

KisAbrBrushCollection() [1/2]

KisAbrBrushCollection::KisAbrBrushCollection

(

const QString &

filename

)

Construct brush to load filename later as brush.

Definition at line 522 of file kis_abr_brush_collection.cpp.

    : m_isLoaded(false)
    , m_lastModified()
    , m_filename(filename)
    , m_abrBrushes(new QMap<QString, KisAbrBrushSP>())
{
}

~KisAbrBrushCollection()

KisAbrBrushCollection::~KisAbrBrushCollection ( )

inline

Definition at line 42 of file kis_abr_brush_collection.h.

{}

KisAbrBrushCollection() [2/2]

KisAbrBrushCollection::KisAbrBrushCollection ( const KisAbrBrushCollection & rhs )

protected

Definition at line 530 of file kis_abr_brush_collection.cpp.

    : m_isLoaded(rhs.m_isLoaded)
    , m_lastModified(rhs.m_lastModified)
{
    m_abrBrushes.reset(new QMap<QString, KisAbrBrushSP>());
    for (auto it = rhs.m_abrBrushes->begin();
         it != rhs.m_abrBrushes->end();
         ++it) {
 
        m_abrBrushes->insert(it.key(), KisAbrBrushSP(new KisAbrBrush(*it.value(), this)));
    }
}

References m_abrBrushes.

Member Function Documentation

abr_brush_load()

qint32 KisAbrBrushCollection::abr_brush_load ( QDataStream & abr, AbrInfo * abr_hdr, const QString filename, qint32 image_ID, qint32 id )

private

Definition at line 503 of file kis_abr_brush_collection.cpp.

{
    qint32 layer_ID = -1;
    switch (abr_hdr->version) {
    case 1:
        Q_FALLTHROUGH();
        // fall through, version 1 and 2 are compatible
    case 2:
        layer_ID = abr_brush_load_v12(abr, abr_hdr, filename, image_ID, id);
        break;
    case 6:
        layer_ID = abr_brush_load_v6(abr, abr_hdr, filename, image_ID, id);
        break;
    }
 
    return layer_ID;
}

References abr_brush_load_v12(), abr_brush_load_v6(), filename(), and AbrInfo::version.

abr_brush_load_v12()

qint32 KisAbrBrushCollection::abr_brush_load_v12 ( QDataStream & abr, AbrInfo * abr_hdr, const QString filename, qint32 image_ID, qint32 id )

private

Definition at line 399 of file kis_abr_brush_collection.cpp.

{
    Q_UNUSED(image_ID);
    short brush_type;
    qint32 brush_size;
    qint32 next_brush;
 
    qint32 top, left, bottom, right;
    qint16 depth;
    char compression;
    QString name;
 
    qint32 width, height;
    qint32 size;
 
    qint32 layer_ID = -1;
    char   *buffer;
 
    // short
    abr >> brush_type;
    // long
    abr >> brush_size;
    next_brush = abr.device()->pos() + brush_size;
 
    if (brush_type == 1) {
        // computed brush
        // FIXME: support it!
        warnKrita  << "WARNING: computed brush unsupported, skipping.";
        abr.device()->seek(abr.device()->pos() + next_brush);
        // TODO: test also this one abr.skipRawData(next_brush);
    }
    else if (brush_type == 2) {
        // sampled brush
        // discard 4 misc bytes and 2 spacing bytes
        abr.device()->seek(abr.device()->pos() + 6);
 
        if (abr_hdr->version == 2)
            name = abr_read_ucs2_text(abr);
        if (name.isNull()) {
            name = abr_v1_brush_name(filename, id);
        }
 
        // discard 1 byte for antialiasing and 4 x short for short bounds
        abr.device()->seek(abr.device()->pos() + 9);
 
        // long
        abr >> top;
        abr >> left;
        abr >> bottom;
        abr >> right;
        // short
        abr >> depth;
        // char
        abr.device()->getChar(&compression);
 
        width = right - left;
        height = bottom - top;
        size = width * (depth >> 3) * height;
 
        /* FIXME: support wide brushes */
        if (height > 16384) {
            warnKrita << "WARNING: wide brushes not supported";
            abr.device()->seek(next_brush);
        }
        else {
            buffer = (char*)malloc(size);
 
            if (!compression) {
                // not compressed - read raw bytes as brush data
                abr.readRawData(buffer, size);
            } else {
                rle_decode(abr, buffer, height);
            }
 
            KisAbrBrushSP abrBrush;
            QImage brushTipImage = convertToQImage(buffer, width, height);
            if (m_abrBrushes->contains(name)) {
                abrBrush = m_abrBrushes.data()->operator[](name);
            }
            else {
                abrBrush = KisAbrBrushSP(new KisAbrBrush(name, this));
                QBuffer buf;
                buf.open(QFile::ReadWrite);
                brushTipImage.save(&buf, "PNG");
                abrBrush->setMD5Sum(KoMD5Generator::generateHash(buf.data()));
            }
 
            abrBrush->setBrushTipImage(brushTipImage);
            // XXX: call extra setters on abrBrush for other options of ABR brushes   free (buffer);
            abrBrush->setValid(true);
            abrBrush->setName(name);
            m_abrBrushes.data()->operator[](name) = abrBrush;
            layer_ID = 1;
        }
    }
    else {
        warnKrita << "Unknown ABR brush type, skipping.";
        abr.device()->seek(next_brush);
    }
 
    return layer_ID;
}

References abr_read_ucs2_text(), abr_v1_brush_name(), convertToQImage(), filename(), KoMD5Generator::generateHash(), m_abrBrushes, rle_decode(), AbrInfo::version, and warnKrita.

abr_brush_load_v6()

quint32 KisAbrBrushCollection::abr_brush_load_v6 ( QDataStream & abr, AbrInfo * abr_hdr, const QString filename, qint32 image_ID, qint32 id )

private

Definition at line 301 of file kis_abr_brush_collection.cpp.

{
    Q_UNUSED(image_ID);
    qint32 brush_size = 0;
    qint32 brush_end = 0;
    qint32 next_brush = 0;
 
    qint32 top, left, bottom, right;
    top = left = bottom = right = 0;
    short depth;
    char compression;
 
    qint32 width = 0;
    qint32 height = 0;
    qint32 size = 0;
 
    qint32 layer_ID = -1;
 
    char *buffer;
 
    abr >> brush_size;
    brush_end = brush_size;
    // complement to 4
    while (brush_end % 4 != 0) {
        brush_end++;
    }
 
    next_brush = abr.device()->pos() + brush_end;
 
    // discard key
    abr.device()->seek(abr.device()->pos() + 37);
    if (abr_hdr->subversion == 1)
        // discard short coordinates and unknown short
        abr.device()->seek(abr.device()->pos() + 10);
    else
        // discard unknown bytes
        abr.device()->seek(abr.device()->pos() + 264);
 
    // long
    abr >> top;
    abr >> left;
    abr >> bottom;
    abr >> right;
    // short
    abr >> depth;
    // char
    abr.device()->getChar(&compression);
 
    width = right - left;
    height = bottom - top;
    size = width * (depth >> 3) * height;
 
    // remove .abr and add some id, so something like test.abr -> test_12345
    QString name = abr_v1_brush_name(filename, id);
 
    buffer = (char*)malloc(size);
 
    // data decoding
    if (!compression) {
        // not compressed - read raw bytes as brush data
        //fread (buffer, size, 1, abr);
        abr.readRawData(buffer, size);
    } else {
        rle_decode(abr, buffer, height);
    }
 
    if (width < quint16_MAX && height < quint16_MAX) {
        // filename - filename of the file , e.g. test.abr
        // name - test_number_of_the_brush, e.g test_1, test_2
        KisAbrBrushSP abrBrush;
        QImage brushTipImage = convertToQImage(buffer, width, height);
        if (m_abrBrushes->contains(name)) {
            abrBrush = m_abrBrushes.data()->operator[](name);
        }
        else {
            abrBrush = KisAbrBrushSP(new KisAbrBrush(name, this));
            QBuffer buf;
            buf.open(QFile::ReadWrite);
            brushTipImage.save(&buf, "PNG");
            abrBrush->setMD5Sum(KoMD5Generator::generateHash(buf.data()));
        }
 
        abrBrush->setBrushTipImage(brushTipImage);
        // XXX: call extra setters on abrBrush for other options of ABR brushes
        abrBrush->setValid(true);
        abrBrush->setName(name);
        m_abrBrushes.data()->operator[](name) = abrBrush;
 
    }
 
    free(buffer);
    abr.device()->seek(next_brush);
 
    layer_ID = id;
    return layer_ID;
}

References abr_v1_brush_name(), convertToQImage(), filename(), KoMD5Generator::generateHash(), m_abrBrushes, quint16_MAX, rle_decode(), and AbrInfo::subversion.

brushByName()

KisAbrBrushSP KisAbrBrushCollection::brushByName ( QString name ) const

inline

Definition at line 72 of file kis_abr_brush_collection.h.

                                                  {
        if (m_abrBrushes->contains(name)) {
            return m_abrBrushes.data()->operator[](name);
        }
        return KisAbrBrushSP();
    }

brushes()

QList< KisAbrBrushSP > KisAbrBrushCollection::brushes ( ) const

inline

Definition at line 64 of file kis_abr_brush_collection.h.

                                         {
        return m_abrBrushes->values();
    }

brushesMap()

QSharedPointer< QMap< QString, KisAbrBrushSP > > KisAbrBrushCollection::brushesMap ( ) const

inline

Definition at line 68 of file kis_abr_brush_collection.h.

                                                                    {
        return m_abrBrushes;
    }

defaultFileExtension()

QString KisAbrBrushCollection::defaultFileExtension

(

)

const

Returns

default file extension for saving the brush

Definition at line 633 of file kis_abr_brush_collection.cpp.

{
    return QString(".abr");
}

filename()

QString KisAbrBrushCollection::filename ( ) const

inline

Definition at line 83 of file kis_abr_brush_collection.h.

                             {
        return m_filename;
    }

image()

QImage KisAbrBrushCollection::image

(

)

const

Returns

a preview of the brush

Definition at line 618 of file kis_abr_brush_collection.cpp.

{
    if (m_abrBrushes->size() > 0) {
        return m_abrBrushes->values().first()->image();
    }
    return QImage();
}

References m_abrBrushes.

isLoaded()

bool KisAbrBrushCollection::isLoaded

(

)

const

Definition at line 613 of file kis_abr_brush_collection.cpp.

{
    return m_isLoaded;
}

References m_isLoaded.

lastModified()

QDateTime KisAbrBrushCollection::lastModified ( ) const

inline

Definition at line 79 of file kis_abr_brush_collection.h.

                                   {
        return m_lastModified;
    }

load()

bool KisAbrBrushCollection::load

(

)

Definition at line 543 of file kis_abr_brush_collection.cpp.

{
    m_isLoaded = true;
    QFile file(filename());
    QFileInfo info(file);
    m_lastModified = info.lastModified();
    // check if the file is open correctly
    if (!file.open(QIODevice::ReadOnly)) {
        warnKrita << "Can't open file " << filename();
        return false;
    }
 
    bool res = loadFromDevice(&file);
    file.close();
 
    return res;
 
}

References filename(), loadFromDevice(), m_isLoaded, m_lastModified, and warnKrita.

loadFromDevice()

bool KisAbrBrushCollection::loadFromDevice

(

QIODevice *

dev

)

Definition at line 562 of file kis_abr_brush_collection.cpp.

{
    AbrInfo abr_hdr;
    qint32 image_ID;
    int i;
    qint32 layer_ID;
 
    QByteArray ba = dev->readAll();
    QBuffer buf(&ba);
    buf.open(QIODevice::ReadOnly);
    QDataStream abr(&buf);
 
 
    if (!abr_read_content(abr, &abr_hdr)) {
        warnKrita << "Error: cannot parse ABR file: " << filename();
        return false;
    }
 
    if (!abr_supported_content(&abr_hdr)) {
        warnKrita << "ERROR: unable to decode abr format version " << abr_hdr.version << "(subver " << abr_hdr.subversion << ")";
        return false;
    }
 
    if (abr_hdr.count == 0) {
        errKrita << "ERROR: no sample brush found in " << filename();
        return false;
    }
 
    image_ID = 123456;
 
    for (i = 0; i < abr_hdr.count; i++) {
        layer_ID = abr_brush_load(abr, &abr_hdr, QFileInfo(filename()).fileName(), image_ID, i + 1);
        if (layer_ID == -1) {
            warnKrita << "Warning: problem loading brush #" << i << " in " << filename();
        }
    }
 
    return true;
 
}

References abr_brush_load(), abr_read_content(), abr_supported_content(), AbrInfo::count, errKrita, filename(), AbrInfo::subversion, AbrInfo::version, and warnKrita.

save()

bool KisAbrBrushCollection::save

(

)

Definition at line 603 of file kis_abr_brush_collection.cpp.

{
    return false;
}

saveToDevice()

bool KisAbrBrushCollection::saveToDevice

(

QIODevice *

dev

)

const

Definition at line 608 of file kis_abr_brush_collection.cpp.

{
    return false;
}

toXML()

void KisAbrBrushCollection::toXML ( QDomDocument & d, QDomElement & e ) const

protected

Definition at line 626 of file kis_abr_brush_collection.cpp.

{
    Q_UNUSED(d);
    Q_UNUSED(e);
    // Do nothing...
}

Member Data Documentation

m_abrBrushes

QSharedPointer<QMap<QString, KisAbrBrushSP> > KisAbrBrushCollection::m_abrBrushes

private

Definition at line 101 of file kis_abr_brush_collection.h.

m_filename

QString KisAbrBrushCollection::m_filename

private

Definition at line 100 of file kis_abr_brush_collection.h.

m_isLoaded

bool KisAbrBrushCollection::m_isLoaded

private

Definition at line 98 of file kis_abr_brush_collection.h.

m_lastModified

QDateTime KisAbrBrushCollection::m_lastModified

private

Definition at line 99 of file kis_abr_brush_collection.h.

---

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

• libs/brush/kis_abr_brush_collection.h
• libs/brush/kis_abr_brush_collection.cpp