KoWritingSystemUtils Class Reference

The KoScriptUtils class. More...

#include <KoWritingSystemUtils.h>

Classes
struct	Bcp47Locale
	The Bcp47Locale class This holds a parsed BCP47 locale. QLocale is primarily made for POSIX locale format, and even there ignores the @modifier tag. On top of that, many minority languages are not handled by QLocale. To keep track of that extra data we use this BCP Locale struct. More...

Static Public Member Functions
static QLocale	localeFromBcp47Locale (const Bcp47Locale &locale)
static QLocale	localeFromBcp47Locale (const QString &locale)
static Bcp47Locale	parseBcp47Locale (const QString &locale)
static QChar::Script	qCharScriptForScriptTag (const QString &tag)
static QMap< QString, QString >	samples ()
static QString	sampleTagForQLocale (const QLocale &locale)
static QLocale::Script	scriptForScriptTag (const QString &tag)
static QString	scriptTagForQCharScript (QChar::Script script)
static QString	scriptTagForQLocaleScript (QLocale::Script script)
static QString	scriptTagForWritingSystem (QFontDatabase::WritingSystem system)
static QFontDatabase::WritingSystem	writingSystemForScriptTag (const QString &tag)

Detailed Description

The KoScriptUtils class.

Collection of utility functions to wrangle the different script and writing system enums in QFontDataBase, QLocale and QChar and ISO 15924 tags

Definition at line 19 of file KoWritingSystemUtils.h.

Member Function Documentation

localeFromBcp47Locale() [1/2]

QLocale KoWritingSystemUtils::localeFromBcp47Locale ( const Bcp47Locale & locale )

static

Definition at line 549 of file KoWritingSystemUtils.cpp.

{
    return QLocale(locale.toPosixLocaleFormat());
}

References KoWritingSystemUtils::Bcp47Locale::toPosixLocaleFormat().

localeFromBcp47Locale() [2/2]

QLocale KoWritingSystemUtils::localeFromBcp47Locale ( const QString & locale )

static

Definition at line 554 of file KoWritingSystemUtils.cpp.

{
    return localeFromBcp47Locale(parseBcp47Locale(locale));
}

References localeFromBcp47Locale(), and parseBcp47Locale().

parseBcp47Locale()

KoWritingSystemUtils::Bcp47Locale KoWritingSystemUtils::parseBcp47Locale ( const QString & locale )

static

Definition at line 444 of file KoWritingSystemUtils.cpp.

{
    Bcp47Locale bcp;
 
    QStringList tags = grandFathered.value(locale, locale).split("-");
 
    if (tags.isEmpty()) return bcp;
 
    auto isAlphaOnly = [] (const QString &string) {
        auto resultIt = std::find_if(string.begin(), string.end(), [] (QChar ch) {
            return !ch.isLetter();
        });
 
        return resultIt == string.end();
    };
 
    auto isDigitOnly = [] (const QString &string) {
        auto resultIt = std::find_if(string.begin(), string.end(), [] (QChar ch) {
            return !ch.isDigit();
        });
 
        return resultIt == string.end();
    };
 
    // Language -- single primary language, followed by optional 3 letter extended tags.
    if (tags.first().size() == 2 || tags.first().size() == 3) {
        bcp.languageTags.append(tags.takeFirst().toLower());
 
        // extensions only happen when first tag is 2 or 3 long.
        while (!tags.isEmpty() && tags.first().size() == 3 && isAlphaOnly(tags.first())) {
            bcp.languageTags.append(tags.takeFirst().toLower());
        }
    } else if (tags.first().size() >= 4 || tags.first().size() <= 8) {
        // 4 alpha is reserved for future use and 5-8 is also legit, but practically doesn't exist...
        bcp.languageTags.append(tags.takeFirst().toLower());
    } else if (tags.first() == "i" && tags.size() > 0) {
        QString total = tags.takeFirst();
        total += "-"+tags.takeFirst();
        bcp.languageTags.append(total.toLower());
    }
 
    if (tags.isEmpty()) return bcp;
 
    // Script -- This is an 4 letter alpha only.
 
    if (isAlphaOnly(tags.first()) && tags.first().size() == 4) {
        bcp.scriptTag = tags.takeFirst().toLower();
        bcp.scriptTag = bcp.scriptTag.at(0).toUpper()+bcp.scriptTag.mid(1);
    }
 
    if (tags.isEmpty()) return bcp;
 
    // Region -- 2 letter alpha only.
 
    if ((isAlphaOnly(tags.first()) && tags.first().size() == 2)
            || (isDigitOnly(tags.first()) && tags.first().size() == 3)) {
        bcp.regionTag = tags.takeFirst().toUpper();
    }
 
    if (tags.isEmpty()) return bcp;
 
    // Variants -- [0+] alpha numerics, either between 5-8 char long, or 4 but starting with a digit.
 
    auto isVariantAlphaNumeric = [] (const QString &string) {
        if (string.size() != 4) return false;
        if (!string.at(0).isDigit()) return false;
        if (!string.at(1).isLetterOrNumber() || !string.at(2).isLetterOrNumber() || !string.at(3).isLetterOrNumber())
            return false;
        return true;
    };
 
    while (!tags.isEmpty()
           && ( (tags.first().size() >= 5 && tags.first().size() <= 8)
               || isVariantAlphaNumeric(tags.first()) )
           ) {
        bcp.variantTags.append(tags.takeFirst().toLower());
    }
 
    if (tags.isEmpty()) return bcp;
    // extension and private use subtags. Each starts with a single letter to indicate the extension type.
 
    QStringList currentExtension;
    while (!tags.isEmpty()) {
        if (!currentExtension.isEmpty() && tags.first().size() == 1) {
            if (currentExtension.first() == "x") {
                bcp.privateUseTags.append(currentExtension.join("-"));
            } else {
                bcp.extensionTags.append(currentExtension.join("-"));
            }
            currentExtension.clear();
        }
        currentExtension.append(tags.takeFirst().toLower());
    }
 
    if (!currentExtension.isEmpty()) {
        if (currentExtension.first() == "x") {
            bcp.privateUseTags.append(currentExtension.join("-"));
        } else {
            bcp.extensionTags.append(currentExtension.join("-"));
        }
    }
 
    return bcp;
}

References KoWritingSystemUtils::Bcp47Locale::extensionTags, grandFathered, KoWritingSystemUtils::Bcp47Locale::languageTags, KoWritingSystemUtils::Bcp47Locale::privateUseTags, KoWritingSystemUtils::Bcp47Locale::regionTag, KoWritingSystemUtils::Bcp47Locale::scriptTag, and KoWritingSystemUtils::Bcp47Locale::variantTags.

qCharScriptForScriptTag()

QChar::Script KoWritingSystemUtils::qCharScriptForScriptTag ( const QString & tag )

static

Definition at line 372 of file KoWritingSystemUtils.cpp.

{
    return QCHAR_SCRIPT_MAP.key(tag, QChar::Script_Unknown);
}

References QCHAR_SCRIPT_MAP.

samples()

QMap< QString, QString > KoWritingSystemUtils::samples ( )

static

This returns a map of samples and an associated tag. Note that the Sample is the first entry, the tag the second. This is because Latin, for example, has multiple sample strings associated depending on Latin coverage in the font. String it is stored with is s_<ISO 15924> tag for scripts and l_<BCP 47 Language> tag for languages. This way we can have samples per language as is useful for vietnamese.

Definition at line 378 of file KoWritingSystemUtils.cpp.

{
    QMap <QString, QString> samples;
    // Also add simplified latin sample. By doing this first, it'll fall back nicely.
    samples.insert("AaBbGg", "s_Latn");
 
    // Some symbol samples...
    samples.insert("\u263A\u2764\u2693\U0001F308", "s_Zsye"); // Emoji
    samples.insert("∆∅∞≠", "s_Zmth"); // Some math operators
    samples.insert("𝄞𝅘𝅥𝅮𝄿𝄻", "s_Zsym"); // Musical notes
    samples.insert("←↕↝↴", "s_Zsym"); // Arrows
    for (int i = 0; i < QFontDatabase::WritingSystemsCount; i++) {
        QFontDatabase::WritingSystem w = QFontDatabase::WritingSystem(i);
        if (w == QFontDatabase::WritingSystem::Any) continue;
 
        if (w == QFontDatabase::WritingSystem::Vietnamese) {
            samples.insert(QFontDatabase::writingSystemSample(QFontDatabase::Vietnamese),
                           "l_vi");
        } else {
            samples.insert(QFontDatabase::writingSystemSample(w),
                           "s_"+WRITINGSYSTEM_SCRIPT_MAP.value(w, "Zyyy"));
        }
    }
 
    return samples;
}

References samples(), and WRITINGSYSTEM_SCRIPT_MAP.

sampleTagForQLocale()

QString KoWritingSystemUtils::sampleTagForQLocale ( const QLocale & locale )

static

Definition at line 405 of file KoWritingSystemUtils.cpp.

{
    const QLocale vietnamese(QLocale::Vietnamese, QLocale::LatinScript, QLocale::AnyCountry);
 
    if (locale == vietnamese) {
        return "l_vi";
    }
 
    return "s_"+QLOCALE_SCRIPT_MAP.value(locale.script(), "Zyyy");
}

References QLOCALE_SCRIPT_MAP.

scriptForScriptTag()

QLocale::Script KoWritingSystemUtils::scriptForScriptTag ( const QString & tag )

static

Definition at line 362 of file KoWritingSystemUtils.cpp.

{
    return QLOCALE_SCRIPT_MAP.key(tag, QLocale::AnyScript);
}

References QLOCALE_SCRIPT_MAP.

scriptTagForQCharScript()

QString KoWritingSystemUtils::scriptTagForQCharScript ( QChar::Script script )

static

Definition at line 367 of file KoWritingSystemUtils.cpp.

{
    return QCHAR_SCRIPT_MAP.value(script);
}

References QCHAR_SCRIPT_MAP.

scriptTagForQLocaleScript()

QString KoWritingSystemUtils::scriptTagForQLocaleScript ( QLocale::Script script )

static

Definition at line 357 of file KoWritingSystemUtils.cpp.

{
    return QLOCALE_SCRIPT_MAP.value(script);
}

References QLOCALE_SCRIPT_MAP.

scriptTagForWritingSystem()

QString KoWritingSystemUtils::scriptTagForWritingSystem ( QFontDatabase::WritingSystem system )

static

Definition at line 348 of file KoWritingSystemUtils.cpp.

                                                                                         {
    return WRITINGSYSTEM_SCRIPT_MAP.value(system);
}

References WRITINGSYSTEM_SCRIPT_MAP.

writingSystemForScriptTag()

QFontDatabase::WritingSystem KoWritingSystemUtils::writingSystemForScriptTag ( const QString & tag )

static

Definition at line 352 of file KoWritingSystemUtils.cpp.

{
    return WRITINGSYSTEM_SCRIPT_MAP.key(tag, QFontDatabase::Any);
}

References WRITINGSYSTEM_SCRIPT_MAP.

---

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

• libs/flake/text/KoWritingSystemUtils.h
• libs/flake/text/KoWritingSystemUtils.cpp