KisTxt2Utils Class Reference

The KisTxt2Utils class. More...

#include <kis_txt2_utls.h>

Static Public Member Functions
static QVariantHash	defaultTxt2 ()
	defaultTxt2 Generate a default txt2 varianthash. This includes stuff like Kinsoku sets default fonts and other things that might be expected but Krita doesn't write itself.
static QVariantHash	tyShFromTxt2 (const QVariantHash Txt2, const QRectF boundsInPx, int textIndex)
	tyShFromTxt2 Txt2 is more or less a superset of tySh, so this function allows generating the tySh data from a Txt2 hash.
static QVariantHash	uncompressKeys (QVariantHash doc)
	uncompressKeys One of the problems with the Txt2 block is that older versions of photoshop (cs2-cs3 era) stored the dictionary keys as names, while new versions stores it as numbers. This function translates the numbers to the names.

Detailed Description

The KisTxt2Utils class.

Utils for handling text engine data inside the Txt2 additional info block. This is a global section info block, which contains more extensive data to the TySh additional info block.

Definition at line 20 of file kis_txt2_utls.h.

Member Function Documentation

defaultTxt2()

QVariantHash KisTxt2Utils::defaultTxt2 ( )

static

defaultTxt2 Generate a default txt2 varianthash. This includes stuff like Kinsoku sets default fonts and other things that might be expected but Krita doesn't write itself.

Returns

a default txt2 hash.

Definition at line 1103 of file kis_txt2_utls.cpp.

{
    QVariantHash doc;
 
    QVariantHash documentResources;
    QVariantHash documentObjects;
 
    QVariantHash fontSet;
    QVariantList fontResources;
 
    QVariantHash fontInvis {
        {"/Name", "AdobeInvisFont"},
        {"/Type", 0}
    };
 
    QVariantHash fontMyriad {
        {"/Name", "MyriadPro-Regular"},
        {"/Type", 0},
        {"/Version", "Version 2.115;PS 2.000;hotconv 1.0.81;makeotf.lib2.5.63406"}
    };
    QVariantHash fR = {
        {"/Resource", QVariantHash({{"/Identifier", fontMyriad}, {"/StreamTag", "/CoolTypeFont"}})}
    };
    fontResources.append(fR);
    fR = {
        {"/Resource", QVariantHash({{"/Identifier", fontInvis}, {"/StreamTag", "/CoolTypeFont"}})}
    };
    fontResources.append(fR);
 
    fontSet.insert("/Resources", fontResources);
    documentResources.insert("/FontSet", fontSet);
    QVariantHash kinsokuSet;
    QVariantList kinsokuResources;
    QVariantList kinsokuDisplay;
    QVariantHash kin =  QVariantHash ({{"/Resource", QVariantHash({ {"/Name", "None"}, {"/Data", kinsokuNone}})}});
    kinsokuResources.append(kin);
    kinsokuDisplay.append(QVariantHash({{"/Resource", 0}}));
    kin =  QVariantHash ({{"/Resource", QVariantHash({ {"/Name", "PhotoshopKinsokuHard"}, {"/Data", kinsokuHard}})}});
    kinsokuResources.append(kin);
    kinsokuDisplay.append(QVariantHash({{"/Resource", 1}}));
    kin =  QVariantHash ({{"/Resource", QVariantHash({ {"/Name", "PhotoshopKinsokuSoft"}, {"/Data", kinsokuSoft}})}});
    kinsokuResources.append(kin);
    kinsokuDisplay.append(QVariantHash({{"/Resource", 2}}));
    kin =  QVariantHash ({{"/Resource", QVariantHash({ {"/Name", "Hard"}, {"/Data", kinsokuHard}})}});
    kinsokuResources.append(kin);
    kinsokuDisplay.append(QVariantHash({{"/Resource", 3}}));
    kin =  QVariantHash ({{"/Resource", QVariantHash({ {"/Name", "Soft"}, {"/Data", kinsokuSoft}})}});
    kinsokuResources.append(kin);
    kinsokuDisplay.append(QVariantHash({{"/Resource", 4}}));
    kinsokuSet.insert("/Resources", kinsokuResources);
    kinsokuSet.insert("/DisplayList", kinsokuDisplay);
    documentResources.insert("/KinsokuSet", kinsokuSet);
 
    //QVariantHash listStyleSet;
    //documentResources.insert("/ListStyleSet", listStyleSet);
    QVariantHash mojiKumiCodeToClassSet = {
        {"/Resources", QVariantList({
             QVariantHash({
                 {"/Resource", QVariantHash({
                      {"/Name", ""}
                  })
                 }
             })
         })},
        {"/DisplayList", QVariantList({QVariantHash({{"/Resource", 0}})})}
    };
    documentResources.insert("/MojiKumiCodeToClassSet", mojiKumiCodeToClassSet);
 
    QHash<QString, int> mojilist {
        {"Photoshop6MojiKumiSet4", 2},
        {"Photoshop6MojiKumiSet3", 4},
        {"Photoshop6MojiKumiSet2", 3},
        {"Photoshop6MojiKumiSet1", 1},
        {"YakumonoHankaku", 1},
        {"GyomatsuYakumonoHankaku", 3},
        {"GyomatsuYakumonoZenkaku", 4},
        {"YakumonoZenkaku", 2},
    };
 
    QVariantHash mojiKumiTableSet;
 
    QVariantList mojiResources;
    QVariantList mojiDisplay;
 
    Q_FOREACH(const QString key, mojilist.keys()) {
        mojiDisplay.append(QVariantHash({{"/Resource", mojiDisplay.size()}}));
        QVariantHash mojikumiTable = {
            {"/Name", key},
            {"/Members", QVariantHash({
                 {"/CodeToClass", 0},
                 {"/PredefinedTag", mojilist.value(key)}
 
             })
            },
        };
 
        mojiResources.append(mojikumiTable);
    }
 
    mojiKumiTableSet.insert("/Resources", mojiResources);
    mojiKumiTableSet.insert("/DisplayList", mojiDisplay);
    documentResources.insert("/MojiKumiTableSet", mojiKumiTableSet);
 
    QVariantHash paragraphSheetSet = {
        {"/Resources", QVariantList({
             QVariantHash({
                 {"/Resource", QVariantHash({
                      {"/Name", "Normal RGB"},
                      {"/Features", defaultParagraph}
                  })
                 }
             })
         })},
        {"/DisplayList", QVariantList({QVariantHash({{"/Resource", 0}})})}
    };
    documentResources.insert("/ParagraphSheetSet", paragraphSheetSet);
    QVariantHash styleSheetSet = {
        {"/Resources", QVariantList({
             QVariantHash({
                 {"/Resource", QVariantHash({
                      {"/Name", "Normal RGB"},
                      {"/Features", defaultStyle}
                  })
                 }
             })
         })},
        {"/DisplayList", QVariantList({QVariantHash({{"/Resource", 0}})})}
    };
    documentResources.insert("/StyleSheetSet", styleSheetSet);
 
    QVariantHash textFrameSet;
    textFrameSet.insert("/Resources", QVariantList());
    documentResources.insert("/TextFrameSet", textFrameSet);
 
    // Document settings ----------
    QVariantHash DocumentSettings;
    DocumentSettings.insert("/DefaultStoryDir", 0);
    // smart quote?
    // alternate glyph?
    DocumentSettings.insert("/SubscriptPosition", 0.333);
    DocumentSettings.insert("/SubscriptSize", 0.583);
    DocumentSettings.insert("/SuperscriptPosition", 0.333);
    DocumentSettings.insert("/SuperscriptSize", 0.583);
    DocumentSettings.insert("/SmallCapSize", 0.7);
    DocumentSettings.insert("/NormalParagraphSheet", 0);
    DocumentSettings.insert("/NormalStyleSheet", 0);
    documentObjects.insert("/DocumentSettings", DocumentSettings);
    QVariantHash OriginalNormalParagraphFeatures = defaultParagraph;
    documentObjects.insert("/OriginalNormalParagraphFeatures", OriginalNormalParagraphFeatures);
    QVariantHash OriginalNormalStyleFeatures = defaultStyle;
    documentObjects.insert("/OriginalNormalStyleFeatures", OriginalNormalStyleFeatures);
    QVariantList TextObjects;
    documentObjects.insert("/TextObjects", TextObjects);
 
    doc.insert("/DocumentResources", documentResources);
    doc.insert("/DocumentObjects", documentObjects);
    return doc;
}

References defaultParagraph, defaultStyle, kinsokuHard, kinsokuNone, and kinsokuSoft.

tyShFromTxt2()

QVariantHash KisTxt2Utils::tyShFromTxt2 ( const QVariantHash Txt2, const QRectF boundsInPx, int textIndex )

static

tyShFromTxt2 Txt2 is more or less a superset of tySh, so this function allows generating the tySh data from a Txt2 hash.

Parameters

Txt2	the global txt2 hash.
textIndex	the text object index for which to generate the tySh data.

Returns

the tySh variantHash

Definition at line 1367 of file kis_txt2_utls.cpp.

{
    QVariantHash tySh;
 
    const QVariantHash documentObjects = Txt2.value("/DocumentObjects").toHash();
    const QVariantList textObjects = documentObjects.value("/TextObjects").toList();
    QVariantHash textObject;
    if (textIndex < textObjects.size()) {
        textObject = textObjects.value(textIndex).toHash();
    }
 
 
    const QVariantHash model = textObject.value("/Model").toHash();
    const QVariantHash view = textObject.value("/View").toHash();
 
    const QVariantHash documentResources = Txt2.value("/DocumentResources").toHash();
    const QVariantList textFrames = documentResources.value("/TextFrameSet").toHash().value("/Resources").toList();
 
    QVariantHash engineDict;
 
    QVariantHash editor;
    editor.insert("/Text", model.value("/Text"));
    engineDict.insert("/Editor", editor);
 
 
    engineDict.insert("/GridInfo", defaultGrid);
 
    // paragraph
    const QVariantHash para = model.value("/ParagraphRun").toHash();
    const QVariantList paraRunArray = para.value("/RunArray").toList();
    // if we want to go over each entry, here's the moment to do so.
    const int length = paraRunArray.value(0).toHash().value("/Length").toInt();
    const QVariantHash paraSheet = paraRunArray.value(0).toHash().value("/RunData").toHash()["/ParagraphSheet"].toHash();
    const QVariantHash paragraphStyle = simplifyParagraphSheet(paraSheet.value("/Features").toHash());
    QVariantHash paragraphRun;
    paragraphRun["/RunLengthArray"] = QVariantList({QVariant(length)});
    QVariantHash paragraphAdjustments  = QVariantHash {
    {"/Axis", QVariantList({1.0, 0.0, 1.0})},
    {"/XY", QVariantList({0.0, 0.0})}
    };
    paragraphRun["/RunArray"] = QVariantList({ QVariantHash{
                                                {"/ParagraphSheet", paragraphStyle},
                                                {"/Adjustments", paragraphAdjustments}
                                            }
                                            });
    paragraphRun.insert("/IsJoinable", 1); //no idea what this means.
    paragraphRun.insert("/DefaultRunData", QVariantHash{
    {"/ParagraphSheet",
            QVariantHash{{"/DefaultStyleSheet", 0},
                        {"/Properties", QVariantHash()}} },
    {"/Adjustments", paragraphAdjustments}});
 
    engineDict.insert("/ParagraphRun", paragraphRun);
 
    const QVariantHash txt2StyleRun = model.value("/StyleRun").toHash();
    const QVariantList txt2RunArray = txt2StyleRun.value("/RunArray").toList();
    QVariantHash styleRun;
 
    QVariantList properStyleRun;
    QVariantList styleRunArray;
    Q_FOREACH(const QVariant entry, txt2RunArray) {
        QVariantHash properStyle;
        const QVariantHash fea = entry.toHash().value("/RunData").toHash().value("/StyleSheet").toHash().value("/Features").toHash();
        properStyle.insert("/StyleSheetData", simplifyStyleSheet(fea));
        QVariantHash s;
        s.insert("/StyleSheet", properStyle);
        properStyleRun.append(s);
        styleRunArray.append(entry.toHash().value("/Length").toInt());
    }
    styleRun.insert("/RunArray", properStyleRun);
    styleRun.insert("/RunLengthArray", styleRunArray);
    styleRun.insert("/IsJoinable", 2);
 
    styleRun.insert("/DefaultRunData", QVariantHash{{"/StyleSheet", QVariantHash{{"/StyleSheetData", QVariantHash()}} }});
    engineDict.insert("/StyleRun", styleRun);
    // rendered data...
 
    const int frameIndex = view.value("/Frames").toList().value(0).toHash().value("/Resource").toInt();
    const QVariantHash textFrame = textFrames.value(frameIndex).toHash().value("/Resource").toHash();
    const QVariantHash textFrameData = textFrame.value("/Data").toHash();
    QVariantHash rendered;
    int shapeType = textFrameData.value("/Type", QVariant(0)).toInt(); // 0 point, 1 paragraph, 2, text on path
    int writingDirection = textFrameData.value("/LineOrientation", QVariant(0)).toInt();
    QVariantHash photoshop = QVariantHash {{"/ShapeType", qMax(1, shapeType)},
    {"/TransformPoint0", QVariantList({1.0, 0.0})},
    {"/TransformPoint1", QVariantList({0.0, 1.0})},
    {"/TransformPoint2", QVariantList({0.0, 0.0})}};
    if (shapeType == 0) {
        photoshop["/PointBase"] = QVariantList({0.0, 0.0});
    } else if (shapeType == 1) {
        // this is the bounding box of the paragraph shape.
        photoshop["/BoxBounds"] = QVariantList({0.0, 0.0, boundsInPx.width(), boundsInPx.height()});
    }
    QVariantHash renderChild = QVariantHash{
    {"/ShapeType", shapeType},
    {"/Procession", 0},
    {"/Lines", QVariantHash{{"/WritingDirection", writingDirection}, {"/Children", QVariantList()}}},
    {"/Cookie", QVariantHash{{"/Photoshop", photoshop}}}};
    rendered["/Version"] = 1;
    rendered["/Shapes"] = QVariantHash{{"/WritingDirection", writingDirection}, {"/Children", QVariantList({renderChild})}};
 
    engineDict.insert("/Rendered", rendered);
 
    // storysheet
    const QVariantHash storySheet = textObject.value("/StorySheet").toHash();
    engineDict.insert("/UseFractionalGlyphWidths", storySheet.value("/UseFractionalGlyphWidths", QVariant(true)).toBool());
    engineDict.insert("/AntiAlias", storySheet.value("/AntiAlias", QVariant(1)).toInt());
 
    QVariantHash resourceDict;
 
    const QVariantList docFontSet = documentResources.value("/FontSet").toHash().value("/Resources").toList();
    QVariantList fontSet;
    Q_FOREACH(QVariant entry, docFontSet) {
        const QVariantHash docFont = entry.toHash().value("/Resource").toHash();
        QVariantHash font = docFont.value("/Identifier").toHash();
        font.insert("/FontType", font.value("/Type"));
        font.remove("/Version");
        font.remove("/Type");
        font.insert("/Script", 0);
        font.insert("/Synthetic", 0);
        fontSet.append(font);
    }
    resourceDict.insert("/FontSet", fontSet);
 
    const QVariantHash documentSettings = documentObjects.value("/DocumentSettings").toHash();
 
    QVariantHash kinHard = kinsokuHard;
    kinHard.remove("/PredefinedTag");
    kinHard.insert("/Name", "PhotoshopKinsokuHard");
    QVariantHash kinSoft = kinsokuSoft;
    kinSoft.remove("/PredefinedTag");
    kinSoft.insert("/Name", "PhotoshopKinsokuSoft");
    resourceDict.insert("/KinsokuSet", QVariantList({kinHard, kinSoft}));
    resourceDict.insert("/MojiKumiSet", QVariantList( {QVariantHash{{"/InternalName", "Photoshop6MojiKumiSet1"}},
                                               QVariantHash{{"/InternalName", "Photoshop6MojiKumiSet2"}},
                                               QVariantHash{{"/InternalName", "Photoshop6MojiKumiSet3"}},
                                               QVariantHash{{"/InternalName", "Photoshop6MojiKumiSet4"}}
                                              }));
    resourceDict.insert("/SubscriptPosition", documentSettings.value("/SubscriptPosition"));
    resourceDict.insert("/SubscriptSize", documentSettings.value("/SubscriptSize"));
    resourceDict.insert("/SuperscriptPosition", documentSettings.value("/SuperscriptPosition"));
    resourceDict.insert("/SuperscriptSize", documentSettings.value("/SuperscriptSize"));
    resourceDict.insert("/SmallCapSize", documentSettings.value("/SmallCapSize"));
    resourceDict.insert("/TheNormalParagraphSheet", documentSettings.value("/NormalParagraphSheet"));
    resourceDict.insert("/TheNormalStyleSheet", documentSettings.value("/NormalStyleSheet"));
 
    const QVariantList docStyleSheetSets = documentResources.value("/StyleSheetSet").toHash().value("/Resources").toList();
    QVariantList resourceStyleSheetList;
    Q_FOREACH(QVariant entry, docStyleSheetSets) {
        const QVariantHash styleSheet = entry.toHash().value("/Resource").toHash();
        QVariantHash newSheet;
        newSheet.insert("/Name", styleSheet.value("/Name"));
        newSheet.insert("/StyleSheetData", simplifyStyleSheet(styleSheet.value("/Features").toHash()));
        resourceStyleSheetList.append(newSheet);
    }
 
    const QVariantList docParagraphSheetSets = documentResources.value("/ParagraphSheetSet").toHash().value("/Resources").toList();
    QVariantList resourceParagraphSheetList;
    Q_FOREACH(QVariant entry, docParagraphSheetSets) {
        const QVariantHash styleSheet = entry.toHash().value("/Resource").toHash();
        QVariantHash newSheet;
        newSheet.insert("/Name", styleSheet.value("/Name"));
        newSheet.insert("/Properties", simplifyParagraphSheet(styleSheet.value("/Features").toHash()));
        newSheet.insert("/DefaultStyleSheet", 0);
        resourceParagraphSheetList.append(newSheet);
    }
 
    resourceDict.insert("/StyleSheetSet", resourceStyleSheetList);
    resourceDict.insert("/ParagraphSheetSet", resourceParagraphSheetList);
 
    tySh.insert("/EngineDict", engineDict);
    tySh.insert("/DocumentResources", resourceDict);
    tySh.insert("/ResourceDict", resourceDict);
    return tySh;
}

References defaultGrid, kinsokuHard, kinsokuSoft, length(), simplifyParagraphSheet(), and simplifyStyleSheet().

uncompressKeys()

QVariantHash KisTxt2Utils::uncompressKeys ( QVariantHash doc )

static

uncompressKeys One of the problems with the Txt2 block is that older versions of photoshop (cs2-cs3 era) stored the dictionary keys as names, while new versions stores it as numbers. This function translates the numbers to the names.

Thankfully the inkscape devs had already figured out the numbers and their keys, so special thanks to them for documenting that:

https://gitlab.com/inkscape/extras/extension-ai/-/blob/main/ docs/specification_amendments/text_documents.md?ref_type=heads

Parameters

doc	input txt2 doc.

Returns

documented with keys translated to names.

Definition at line 887 of file kis_txt2_utls.cpp.

{
 
    QVariantHash newDoc;
    Q_FOREACH(QString key, doc.keys()) {
        if (key == "/0") {
            newDoc.insert("/DocumentResources", uncompressKeysDocumentResources(doc.value(key).toHash()));
        } else if (key == "/1") {
            newDoc.insert("/DocumentObjects", uncompressKeysDocumentObjects(doc.value(key).toHash()));
        } else {
            newDoc.insert(key, doc.value(key));
        }
    }
    return newDoc;
}

References uncompressKeysDocumentObjects(), and uncompressKeysDocumentResources().

---

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

• libs/psdutils/cos/kis_txt2_utls.h
• libs/psdutils/cos/kis_txt2_utls.cpp