Krita Source Code Documentation
Loading...
Searching...
No Matches
Namespaces | Functions
kis_asl_reader.cpp File Reference
#include "kis_asl_reader.h"
#include "kis_dom_utils.h"
#include <stdexcept>
#include <string>
#include <QBuffer>
#include <QDomDocument>
#include <QIODevice>
#include "compression.h"
#include "kis_offset_on_exit_verifier.h"
#include "psd.h"
#include "psd_utils.h"
#include "kis_asl_reader_utils.h"
#include "kis_asl_writer_utils.h"

Go to the source code of this file.

Namespaces

namespace  Private
 

Functions

void Private::appendDoubleXMLNode (const QString &key, const QString &value, QDomElement *parent, QDomDocument *doc)
 
void Private::appendIntegerXMLNode (const QString &key, const QString &value, QDomElement *parent, QDomDocument *doc)
 
void Private::appendPointXMLNode (const QString &key, const QPointF &pt, QDomElement *parent, QDomDocument *doc)
 
void Private::appendTextXMLNode (const QString &key, const QString &value, QDomElement *parent, QDomDocument *doc)
 
QDomElement Private::appendXMLNodeCommon (const QString &key, const QString &value, const QString &type, QDomElement *parent, QDomDocument *doc)
 
QDomElement Private::appendXMLNodeCommonNoValue (const QString &key, const QString &type, QDomElement *parent, QDomDocument *doc)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString Private::readBoolAsString (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void Private::readChildObject (QIODevice &device, QDomElement *parent, QDomDocument *doc, bool skipKey=false)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
void Private::readDescriptor (QIODevice &device, const QString &key, QDomElement *parent, QDomDocument *doc)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString Private::readDoubleAsString (QIODevice &device)
 
QDomDocument Private::readFileImpl (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readFillLayerImpl (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString Private::readIntAsString (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readLfx2PsdSectionImpl (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
qint64 Private::readPattern (QIODevice &device, QDomElement *parent, QDomDocument *doc)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readPsdSectionPatternImpl (QIODevice &device, qint64 bytesLeft)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readTypeToolObjectSettingsImpl (QIODevice &device, QTransform &transform)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readVectorOriginationDataImpl (QIODevice &device)
 
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readVectorStrokeImpl (QIODevice &device)
 
template<psd_byte_order byteOrder>
QImage Private::readVirtualArrayList (QIODevice &device, int numPlanes, const QVector< QRgb > &palette)
 

Function Documentation

◆ readFillLayerImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readFillLayerImpl ( QIODevice & device)

Definition at line 771 of file kis_asl_reader.cpp.

772{
773 QDomDocument doc;
774
775 if (device.isSequential()) {
776 warnKrita << "WARNING: *** KisAslReader::readFillLayerPsdSection: the supplied"
777 << "IO device is sequential. Chances are that"
778 << "the fill config will *not* be loaded correctly!";
779 }
780 try {
781
782 {
783 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
784 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 16);
785 }
786
787 QDomElement root = doc.createElement("asl");
788 doc.appendChild(root);
789
790 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
791
792 } catch (KisAslReaderUtils::ASLParseException &e) {
793 warnKrita << "WARNING: PSD: SoCo section:" << e.what();
794 }
795
796 return doc;
797}
GARBAGE_VALUE_MARK
#define GARBAGE_VALUE_MARK
Definition kis_asl_reader_utils.h:26
SAFE_READ_SIGNATURE_EX
#define SAFE_READ_SIGNATURE_EX(byteOrder, device, varname, expected)
Definition kis_asl_reader_utils.h:51
warnKrita
#define warnKrita
Definition kis_debug.h:87

References GARBAGE_VALUE_MARK, SAFE_READ_SIGNATURE_EX, and warnKrita.

◆ readLfx2PsdSectionImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readLfx2PsdSectionImpl ( QIODevice & device)

Definition at line 722 of file kis_asl_reader.cpp.

723{
724 QDomDocument doc;
725
726 if (device.isSequential()) {
727 warnKrita << "WARNING: *** KisAslReader::readLfx2PsdSection: the supplied"
728 << "IO device is sequential. Chances are that"
729 << "the layer style will *not* be loaded correctly!";
730 }
731
732 try {
733 {
734 quint32 objectEffectsVersion = GARBAGE_VALUE_MARK;
735 const quint32 ref = 0x00;
736 SAFE_READ_SIGNATURE_EX(byteOrder, device, objectEffectsVersion, ref);
737 }
738
739 {
740 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
741 const quint32 ref = 0x10;
742 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, ref);
743 }
744
745 QDomElement root = doc.createElement("asl");
746 doc.appendChild(root);
747
748 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
749
750 } catch (KisAslReaderUtils::ASLParseException &e) {
751 warnKrita << "WARNING: PSD: lfx2 section:" << e.what();
752 }
753
754 return doc;
755}

References GARBAGE_VALUE_MARK, SAFE_READ_SIGNATURE_EX, and warnKrita.

◆ readPsdSectionPatternImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readPsdSectionPatternImpl ( QIODevice & device,
qint64 bytesLeft )

Definition at line 988 of file kis_asl_reader.cpp.

989{
990 QDomDocument doc;
991
992 QDomElement root = doc.createElement("asl");
993 doc.appendChild(root);
994
995 QDomElement pat = doc.createElement("node");
996 root.appendChild(pat);
997
998 pat.setAttribute("classId", ResourceType::Patterns);
999 pat.setAttribute("type", "Descriptor");
1000 pat.setAttribute("name", "");
1001
1002 try {
1003 qint64 bytesRead = 0;
1004 while (bytesRead < bytesLeft) {
1005 qint64 chunk = Private::readPattern<byteOrder>(device, &pat, &doc);
1006 bytesRead += chunk;
1007 }
1008 } catch (KisAslReaderUtils::ASLParseException &e) {
1009 warnKrita << "WARNING: PSD (emb. pattern):" << e.what();
1010 }
1011
1012 return doc;
1013}
ResourceType::Patterns
const QString Patterns
Definition KisResourceTypes.cpp:18

References ResourceType::Patterns, and warnKrita.

◆ readTypeToolObjectSettingsImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readTypeToolObjectSettingsImpl ( QIODevice & device,
QTransform & transform )

Definition at line 813 of file kis_asl_reader.cpp.

814{
815 QDomDocument doc;
816
817 if (device.isSequential()) {
818 warnKrita << "WARNING: *** KisAslReader::readTypeToolObjectSettings: the supplied"
819 << "IO device is sequential. Chances are that"
820 << "the fill config will *not* be loaded correctly!";
821 }
822 try {
823
824 {
825 quint16 descriptorVersion = GARBAGE_VALUE_MARK;
826 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 1);
827
828 }
829
830 // transform matrix.
831 double xx = GARBAGE_VALUE_MARK;
832 SAFE_READ_EX(byteOrder, device, xx);
833 double xy = GARBAGE_VALUE_MARK;
834 SAFE_READ_EX(byteOrder, device, xy);
835 double yx = GARBAGE_VALUE_MARK;
836 SAFE_READ_EX(byteOrder, device, yx);
837 double yy = GARBAGE_VALUE_MARK;
838 SAFE_READ_EX(byteOrder, device, yy);
839 double tx = GARBAGE_VALUE_MARK;
840 SAFE_READ_EX(byteOrder, device, tx);
841 double ty = GARBAGE_VALUE_MARK;
842 SAFE_READ_EX(byteOrder, device, ty);
843
844 {
845 quint16 textVersion = GARBAGE_VALUE_MARK;
846 SAFE_READ_SIGNATURE_EX(byteOrder, device, textVersion, 50);
847 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
848 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 16);
849 }
850
851 transform = QTransform(xx, xy, yx, yy, tx, ty);
852
853 QDomElement root = doc.createElement("asl");
854 doc.appendChild(root);
855 // text layer data
856 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
857
858 // warp data
859 {
860 quint16 textVersion = GARBAGE_VALUE_MARK;
861 SAFE_READ_SIGNATURE_EX(byteOrder, device, textVersion, 1);
862 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
863 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 16);
864 }
865
866 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
867
868 /*// bounding box
869 quint64 left = GARBAGE_VALUE_MARK;
870 SAFE_READ_EX(byteOrder, device, left);
871 quint64 top = GARBAGE_VALUE_MARK;
872 SAFE_READ_EX(byteOrder, device, top);
873 quint64 right = GARBAGE_VALUE_MARK;
874 SAFE_READ_EX(byteOrder, device, right);
875 quint64 bottom = GARBAGE_VALUE_MARK;
876 SAFE_READ_EX(byteOrder, device, bottom);
877 */
878
879
880 } catch (KisAslReaderUtils::ASLParseException &e) {
881 warnKrita << "WARNING: PSD: TySh section:" << e.what();
882 }
883
884 return doc;
885}
SAFE_READ_EX
#define SAFE_READ_EX(byteOrder, device, varname)
Definition kis_asl_reader_utils.h:45

References GARBAGE_VALUE_MARK, SAFE_READ_EX, SAFE_READ_SIGNATURE_EX, and warnKrita.

◆ readVectorOriginationDataImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readVectorOriginationDataImpl ( QIODevice & device)

Definition at line 942 of file kis_asl_reader.cpp.

943{
944 QDomDocument doc;
945
946 if (device.isSequential()) {
947 warnKrita << "WARNING: *** KisAslReader::readVectorStroke: the supplied"
948 << "IO device is sequential. Chances are that"
949 << "the fill config will *not* be loaded correctly!";
950 }
951 try {
952
953 {
954 quint32 version = GARBAGE_VALUE_MARK;
955 SAFE_READ_SIGNATURE_EX(byteOrder, device, version, 1);
956 }
957 {
958 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
959 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 16);
960 }
961
962 QDomElement root = doc.createElement("asl");
963 doc.appendChild(root);
964
965 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
966
967 } catch (KisAslReaderUtils::ASLParseException &e) {
968 warnKrita << "WARNING: PSD: vogk section:" << e.what();
969 }
970
971 return doc;
972}

References GARBAGE_VALUE_MARK, SAFE_READ_SIGNATURE_EX, and warnKrita.

◆ readVectorStrokeImpl()

template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QDomDocument readVectorStrokeImpl ( QIODevice & device)

Definition at line 901 of file kis_asl_reader.cpp.

902{
903 QDomDocument doc;
904
905 if (device.isSequential()) {
906 warnKrita << "WARNING: *** KisAslReader::readVectorStroke: the supplied"
907 << "IO device is sequential. Chances are that"
908 << "the fill config will *not* be loaded correctly!";
909 }
910 try {
911
912 {
913 quint32 descriptorVersion = GARBAGE_VALUE_MARK;
914 SAFE_READ_SIGNATURE_EX(byteOrder, device, descriptorVersion, 16);
915 }
916
917 QDomElement root = doc.createElement("asl");
918 doc.appendChild(root);
919
920 Private::readDescriptor<byteOrder>(device, "", &root, &doc);
921
922 } catch (KisAslReaderUtils::ASLParseException &e) {
923 warnKrita << "WARNING: PSD: vmsk section:" << e.what();
924 }
925
926 return doc;
927}

References GARBAGE_VALUE_MARK, SAFE_READ_SIGNATURE_EX, and warnKrita.