KisAslPatternsWriter Class Reference

#include <kis_asl_patterns_writer.h>

Public Member Functions
	KisAslPatternsWriter (const QDomDocument &doc, QIODevice &device, psd_byte_order byteOrder)
void	writePatterns ()

Private Member Functions
void	addPattern (const KoPatternSP pattern)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void	addPatternImpl (const KoPatternSP pattern)

Private Attributes
psd_byte_order	m_byteOrder
QIODevice &	m_device
const QDomDocument &	m_doc
int	m_numPatternsWritten

Detailed Description

Definition at line 20 of file kis_asl_patterns_writer.h.

Constructor & Destructor Documentation

KisAslPatternsWriter()

KisAslPatternsWriter::KisAslPatternsWriter	(	const QDomDocument &	doc,
		QIODevice &	device,
		psd_byte_order	byteOrder )

Definition at line 20 of file kis_asl_patterns_writer.cpp.

    : m_doc(doc)
    , m_device(device)
    , m_numPatternsWritten(0)
    , m_byteOrder(byteOrder)
{
}

Member Function Documentation

addPattern()

void KisAslPatternsWriter::addPattern ( const KoPatternSP pattern )

private

Definition at line 86 of file kis_asl_patterns_writer.cpp.

{
    KoPatternSP effectivePattern = pattern;
 
    if (effectivePattern->hasAlpha()) {
        effectivePattern = pattern->cloneWithoutAlpha();
    }
 
    switch (m_byteOrder) {
    case psd_byte_order::psdLittleEndian:
        addPatternImpl<psd_byte_order::psdLittleEndian>(effectivePattern);
        break;
    default:
        addPatternImpl(effectivePattern);
        break;
    }
}

References addPatternImpl(), m_byteOrder, and psdLittleEndian.

addPatternImpl()

template<psd_byte_order byteOrder>

void KisAslPatternsWriter::addPatternImpl ( const KoPatternSP pattern )

private

Definition at line 105 of file kis_asl_patterns_writer.cpp.

{
    {
        KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder> patternSizeField(m_device);
 
        {
            const quint32 patternVersion = 1;
            SAFE_WRITE_EX(byteOrder, m_device, patternVersion);
        }
 
        {
            const quint32 patternImageMode = 3;
            SAFE_WRITE_EX(byteOrder, m_device, patternImageMode);
        }
 
        {
            const quint16 patternHeight = static_cast<quint16>(pattern->height());
            SAFE_WRITE_EX(byteOrder, m_device, patternHeight);
        }
 
        {
            const quint16 patternWidth = static_cast<quint16>(pattern->width());
            SAFE_WRITE_EX(byteOrder, m_device, patternWidth);
        }
 
        KisAslWriterUtils::writeUnicodeString<byteOrder>(pattern->name(), m_device);
        KisAslWriterUtils::writePascalString<byteOrder>(KisAslWriterUtils::getPatternUuidLazy(pattern), m_device);
 
        // Write "Virtual Memory Array List"
 
        const QRect patternRect(0, 0, pattern->width(), pattern->height());
 
        {
            {
                const quint32 arrayVersion = 3;
                SAFE_WRITE_EX(byteOrder, m_device, arrayVersion);
            }
 
            KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder> arraySizeField(m_device);
 
            KisAslWriterUtils::writeRect<byteOrder>(patternRect, m_device);
 
            {
                // don't ask me why it is called this way...
                const quint32 numberOfChannels = 24;
                SAFE_WRITE_EX(byteOrder, m_device, numberOfChannels);
            }
 
            KIS_ASSERT_RECOVER_RETURN(patternRect.size() == pattern->pattern().size());
 
            QVector<QVector<QByteArray>> imagePlanes;
            bool isCompressed;
            sliceQImage(pattern->pattern(), &imagePlanes, &isCompressed);
 
            for (int i = 0; i < 3; i++) {
                {
                    const quint32 planeIsWritten = 1;
                    SAFE_WRITE_EX(byteOrder, m_device, planeIsWritten);
                }
 
                KisAslWriterUtils::OffsetStreamPusher<quint32, byteOrder> planeSizeField(m_device);
 
                {
                    const quint32 pixelDepth1 = 8;
                    SAFE_WRITE_EX(byteOrder, m_device, pixelDepth1);
                }
 
                KisAslWriterUtils::writeRect<byteOrder>(patternRect, m_device);
 
                {
                    // why twice? who knows...
                    const quint16 pixelDepth2 = 8;
                    SAFE_WRITE_EX(byteOrder, m_device, pixelDepth2);
                }
 
                {
                    // compress with RLE
                    const quint8 compressionMethod = isCompressed;
                    SAFE_WRITE_EX(byteOrder, m_device, compressionMethod);
                }
 
                KIS_ASSERT_RECOVER_RETURN(imagePlanes[i].size() == pattern->pattern().height());
 
                if (isCompressed) {
                    Q_FOREACH (const QByteArray &compressedRow, imagePlanes[i]) {
                        const quint16 compressionRowSize = static_cast<quint16>(compressedRow.size());
                        SAFE_WRITE_EX(byteOrder, m_device, compressionRowSize);
                    }
                }
 
                Q_FOREACH (const QByteArray &rowData, imagePlanes[i]) {
                    const qint64 bytesWritten = m_device.write(rowData);
                    if (bytesWritten != rowData.size()) {
                        throw KisAslWriterUtils::ASLWriteException("Failed to write a compressed pattern plane");
                    }
                }
            }
        }
    }
 
    const qint64 currentPos = m_device.pos();
    const qint64 alignedPos = KisAslWriterUtils::alignOffsetCeil(currentPos, 4);
 
    if (currentPos != alignedPos) {
        m_device.seek(alignedPos);
    }
 
    m_numPatternsWritten++;
}

References KisAslWriterUtils::alignOffsetCeil(), KisAslWriterUtils::getPatternUuidLazy(), KIS_ASSERT_RECOVER_RETURN, m_device, m_numPatternsWritten, SAFE_WRITE_EX, and sliceQImage().

writePatterns()

void KisAslPatternsWriter::writePatterns

(

)

Definition at line 28 of file kis_asl_patterns_writer.cpp.

{
    KisAslCallbackObjectCatcher c;
    c.subscribePattern("/Patterns/KisPattern", std::bind(&KisAslPatternsWriter::addPattern, this, std::placeholders::_1));
    c.subscribePattern("/patterns/KisPattern", std::bind(&KisAslPatternsWriter::addPattern, this, std::placeholders::_1));
 
    KisAslXmlParser parser;
    parser.parseXML(m_doc, c);
}

References addPattern(), m_doc, KisAslXmlParser::parseXML(), and KisAslCallbackObjectCatcher::subscribePattern().

Member Data Documentation

m_byteOrder

psd_byte_order KisAslPatternsWriter::m_byteOrder

private

Definition at line 38 of file kis_asl_patterns_writer.h.

m_device

QIODevice& KisAslPatternsWriter::m_device

private

Definition at line 35 of file kis_asl_patterns_writer.h.

m_doc

const QDomDocument& KisAslPatternsWriter::m_doc

private

Definition at line 34 of file kis_asl_patterns_writer.h.

m_numPatternsWritten

int KisAslPatternsWriter::m_numPatternsWritten

private

Definition at line 37 of file kis_asl_patterns_writer.h.

---

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

• libs/psdutils/asl/kis_asl_patterns_writer.h
• libs/psdutils/asl/kis_asl_patterns_writer.cpp