#include <MyLocalization.h>

Inheritance diagram for MyLocalization:

Public Types
enum	MyMessageTypes { Information = 100 , Question = 101 , Warning = 102 , Critical = 103 , Debug = 104 }

Public Member Functions
	MyLocalization (QObject parent=nullptr, MyOrgSettings thisSetting=nullptr)
	TranslationFiles Constructor. More...

void	setDebugMessage (bool thisState)
	set Debug Message More...

bool	getDebugMessage ()
	get Debug Message More...

void	setMessage (const QString &thisMessage, MyLocalization::MyMessageTypes thisMessageType)
	set Message More...

QStringList	getQmFiles (const QString &thisFolder)
	find Qm Files More...

QStringList	findTsFiles (const QString &thisFolder)
	find Ts Files More...

bool	languageMatch (const QString &thisPrefix, const QString &thisLang, const QString &thisQmFile)
	language Match More...

QString	languageNameFromFile (const QString &thisTranslationFile)
	language Name From File More...

QString	getLocalizerCode (const QString &thisPrefix, const QString &thisQmFile)
	get Localizer Code More...

QString	getLangCode (const QString &thisString)
	get Lang Code More...

void	removeArgs (const QString &thisString, const QString &thisTransFile)
	remove Args file creation More...

void	fileRemoveArgs ()
	file Remove Args More...

void	fixTranslationFile (const QString &thisFile)
	fix Translation File More...

QString	getLocalizedCodeFromFile (const QString &thisPrefix, const QString &thisQmFile)
	get Localized Code From File More...

QString	languageNameToCode (const QString &lang)
	language Name to Code Added by Light-Wizzard More...

QString	languageCodeToName (const QString &lang)
	language Code to Name Added by Light-Wizzard More...

QString	getDefaultLanguageCode ()
	Added by Light-Wizzard language Code to Name. More...

void	loadLanguage (const QString &thisQmLanguageFile)
	load Language More...

QString	etLanguageFile (const QString &thisLanguageCode, const QString &thisPath, const QString &thisPrefix)
	get Language File More...

QString	getLanguageFromFile (const QString &thisPrefix, const QString &thisQmLanguageFile)
	getLanguageFromFile More...

QString	getTranslationSource ()
	get Translation Source More...

void	setTranslationSource (const QString &thisTranslationSource)
	set Translation Source More...

QString	getHelpSource ()
	get Help Source More...

void	setHelpSource (const QString &thisHelpSource)
	set Help Source More...

QString	getTransFilePrefix ()
	get TransFile Prefix More...

void	setTransFilePrefix (const QString &thisTransFilePrefix)
	set TransFile Prefix More...

QString	readLanguage ()
	read Language More...

void	writeLanguage (const QString &thisCurrentLanguageCode)
	write Language More...

QString	language (const QLocale &thisLocale)
	language More...

void	setLanguageCode (const QString &thisLanguageCode)
	set Language Code More...

QString	getLanguageCode ()
	get Language Code More...

void	setMainLoaded (bool thisMainLoaded)
	set Main Loaded More...

bool	getMainLoaded ()
	get Main Loaded More...

QString	languageName (const QLocale &thisLocale)
	language Name More...

QString	getLanguageFile (const QString &thisLanguageCode, const QString &thisPath, const QString &thisPrefix)
	get Language File. getLanguageFile More...

Public Attributes
MyOrgSettings *	mySetting
	`mySetting` More...

const QString	MY_LANG_CODE = "LanguageCode"
	`MY_LANG_CODE` More...

const QString	MY_LANG_NAME = "LanguageName"
	`MY_LANG_NAME` More...

const QString	MY_LOCALE_LANG_CODE = "LocaleLanguageCode"
	`MY_CURRENT_LANG_CODE` More...

Detailed Description

Definition at line 34 of file MyLocalization.h.

Member Enumeration Documentation

◆ MyMessageTypes

enum MyLocalization::MyMessageTypes

Enumerator
Information	`Information` Information
Question	`Question` Question
Warning	`Warning` Warning
Critical	`Critical` Critical
Debug	`Debug` Debug

Definition at line 39 of file MyLocalization.h.

        {
            Information = 100, 
            Question    = 101, 
            Warning     = 102, 
            Critical    = 103, 
            Debug       = 104, 
        }; // end enum MyFileinfo

Constructor & Destructor Documentation

◆ MyLocalization()

MyLocalization::MyLocalization	(	QObject *	parent = `nullptr`,
		MyOrgSettings *	thisSetting = `nullptr`
	)

explicit

TranslationFiles Constructor.

Translation Files Constructor. MyLocalization.

Definition at line 7 of file MyLocalization.cpp.

                                                                           : QObject(parent), mySetting(thisSetting)
{
    myTranslator = new QTranslator(qApp);
}

Member Function Documentation

◆ etLanguageFile()

QString MyLocalization::etLanguageFile	(	const QString &	thisLanguageCode,
		const QString &	thisPath,
		const QString &	thisPrefix
	)

get Language File

◆ fileRemoveArgs()

void MyLocalization::fileRemoveArgs ( )

file Remove Args

file Remove Args "String %1". fileRemoveArgs

Definition at line 177 of file MyLocalization.cpp.

{
    setMessage("fileRemoveArgs", Debug);
    if (!myRemoveTransArgs.isEmpty())
    {
        QString theRemoveFileName = QString("%1").arg(mySetting->getAppDataLocation(), QDir::separator(), "RemoveArgFile.txt");
        mySetting->writeFile(theRemoveFileName, myRemoveTransArgs);
        mySetting->showMessageBox(QObject::tr("Remove Args file is created").toLocal8Bit(), QString("%1: %2 %3 %4").arg(tr("Remove Args"), myRemoveTransArgs, tr("File: "), theRemoveFileName).toLocal8Bit(), mySetting->Warning);
    }
} // end fileRemoveArgs

◆ findTsFiles()

QStringList MyLocalization::findTsFiles ( const QString & thisFolder )

find Ts Files

find Ts Files. findTsFiles

Definition at line 252 of file MyLocalization.cpp.

{
    setMessage("findTsFiles", Debug);
    QDir dir(thisFolder);
    QStringList fileNames = dir.entryList(QStringList("*.ts"), QDir::Files, QDir::Name);
    for (QString &fileName : fileNames)
        { fileName = dir.filePath(fileName); }
    return fileNames;
}

◆ fixTranslationFile()

void MyLocalization::fixTranslationFile ( const QString & thisFile )

fix Translation File

fix Translation File; mostly Arabic gets the value before the ID on some fields. fixTranslationFile

Definition at line 191 of file MyLocalization.cpp.

{
    setMessage("fixTranslationFile", Debug);
    if (!mySetting->isFileExists(thisFile)) { mySetting->showMessageBox(tr("File not found").toLocal8Bit(), QString("%1: %2").arg(tr("File not found"), thisFile).toLocal8Bit(), mySetting->Critical); return; }
    //
    QString theNewFileContent;
    QFile theInputTxtFile(thisFile);
    if (theInputTxtFile.open(QIODevice::ReadOnly))
    {
        QTextStream theFileStream(&theInputTxtFile);
        while (!theFileStream.atEnd())
        {
            QString theLine = theFileStream.readLine();
            if (theLine.mid(0, 1) != "[")
            {
                QString theTransValue = theLine;
                theTransValue.remove(QRegExp("\[([^)]+)\\]"));
                //
                QRegExp rx("\[([^)]+)\\]");
                QString theOnlyID = theLine;
                if (rx.indexIn(theLine) == 0) { theOnlyID = rx.cap(1); }
                theNewFileContent.append(QString("%1 %2\n").arg(theOnlyID, theTransValue));
            }
        }
    }
} // end fixTranslationFile

◆ getDebugMessage()

bool MyLocalization::getDebugMessage ( )

get Debug Message

get Debug Message. getDebugMessage

Definition at line 127 of file MyLocalization.cpp.

{
    setMessage("getDebugMessage", Debug);
    return isDebugMessage;
}

◆ getDefaultLanguageCode()

QString MyLocalization::getDefaultLanguageCode ( )

Added by Light-Wizzard language Code to Name.

languageCodeToName

Definition at line 308 of file MyLocalization.cpp.

{
    return language(QLocale());
}

◆ getHelpSource()

QString MyLocalization::getHelpSource ( )

get Help Source

get Help Source. getHelpSource

Definition at line 43 of file MyLocalization.cpp.

{
    setMessage("getHelpSource", Debug);
    return myHelpSource;
}

◆ getLangCode()

QString MyLocalization::getLangCode ( const QString & thisString )

get Lang Code

get Lang Code. getLangCode

Definition at line 277 of file MyLocalization.cpp.

{
    setMessage("getLangCode", Debug);
    QString theLangCode = thisString;
    if (theLangCode.indexOf('_') < 0) { return ""; }
    if (theLangCode.indexOf('.') > 0)
        { theLangCode = theLangCode.mid(0, theLangCode.indexOf('.')); }
    return theLangCode.mid(theLangCode.indexOf('_') + 1);
}

◆ getLanguageCode()

QString MyLocalization::getLanguageCode ( )

get Language Code

get Debug Message. getDebugMessage

Definition at line 345 of file MyLocalization.cpp.

{
    setMessage("getLanguageCode", Debug);
    if (myLanguageCode.isEmpty())
    {
        QString theLangCode = language(QLocale());
        myLanguageCode = mySetting->readSettings(MY_LANG_CODE, theLangCode);
    }
    return myLanguageCode;
}

◆ getLanguageFile()

QString MyLocalization::getLanguageFile	(	const QString &	thisLanguageCode,
		const QString &	thisPath,
		const QString &	thisPrefix
	)

get Language File. getLanguageFile

Definition at line 98 of file MyLocalization.cpp.

{
    setMessage("getLanguageFile", Debug);
    QString theLang = thisLanguageCode;
    if (theLang.contains("-"))
    { theLang = theLang.replace("-", "_"); }
    const QStringList theQmFiles = getQmFiles(thisPath);
    for (int i = 0; i < theQmFiles.size(); ++i)
    {
        if (languageMatch(thisPrefix, theLang, theQmFiles.at(i)))
        {
            return theQmFiles.at(i);
        }
    }
    return "";
}

◆ getLanguageFromFile()

QString MyLocalization::getLanguageFromFile	(	const QString &	thisPrefix,
		const QString &	thisQmLanguageFile
	)

getLanguageFromFile

get Language File. getLanguageFromFile QString thisLangFile = getLanguageFromFile(getTransFilePrefix(), "?.qm");

Definition at line 16 of file MyLocalization.cpp.

{
    setMessage("getLanguageFromFile", Debug);
    return getLocalizerCode(thisPrefix, thisQmLanguageFile);
}

◆ getLocalizedCodeFromFile()

QString MyLocalization::getLocalizedCodeFromFile	(	const QString &	thisPrefix,
		const QString &	thisQmFile
	)

get Localized Code From File

language Match qmFile naming. languageMatch

Definition at line 148 of file MyLocalization.cpp.

{
    setMessage("getLocalizedCodeFromFile", Debug);
    QFileInfo theFileInfo(thisQmFile);
 
    QString theFileName = theFileInfo.baseName();
    theFileName = theFileName.remove(QString("%1_").arg(thisPrefix));
    if (theFileName.contains("_"))
    {
        if (!theFileName.contains("zh"))
        {
            theFileName = theFileName.section("_", 0, 0);
        }
    }
    return theFileName;
}

◆ getLocalizerCode()

QString MyLocalization::getLocalizerCode	(	const QString &	thisPrefix,
		const QString &	thisQmFile
	)

get Localizer Code

get Localizer Code. getLocalizerCode

Definition at line 265 of file MyLocalization.cpp.

{
    setMessage("getLocalizerCode", Debug);
    QString theQmLang = getLocalizedCodeFromFile(thisPrefix, thisQmFile);
    if (theQmLang.contains("_"))
    { theQmLang = theQmLang.replace("_", "-"); }
    return languageCodeToName(theQmLang);
}

◆ getMainLoaded()

bool MyLocalization::getMainLoaded ( )

get Main Loaded

get Main Loaded. getMainLoaded

Definition at line 368 of file MyLocalization.cpp.

{
    setMessage("getMainLoaded", Debug);
    return isMainLoaded;
}

◆ getQmFiles()

QStringList MyLocalization::getQmFiles ( const QString & thisFolder )

find Qm Files

find Qm Files. findQmFiles

Definition at line 237 of file MyLocalization.cpp.

{
    setMessage("findQmFiles", Debug);
    QDir dir(QString(":/%1").arg(thisFolder));
    QStringList fileNames = dir.entryList(QStringList("*.qm"), QDir::Files, QDir::Name);
    for (QString &fileName : fileNames)
    {
        fileName = dir.filePath(fileName);
    }
    return fileNames;
}

◆ getTransFilePrefix()

QString MyLocalization::getTransFilePrefix ( )

get TransFile Prefix

get Trans File Prefix. getTransFilePrefix

Definition at line 61 of file MyLocalization.cpp.

{
    setMessage("getTransFilePrefix", Debug);
    return myTransFilePrefix;
}

◆ getTranslationSource()

QString MyLocalization::getTranslationSource ( )

get Translation Source

get Translation Source. getTranslationSource

Definition at line 25 of file MyLocalization.cpp.

{
    setMessage("getTranslationSource", Debug);
    return myTranslationSource;
}

◆ language()

QString MyLocalization::language ( const QLocale & thisLocale )

language

language. language

Parameters

thisLocale QLocale given QLocale() returns Country Code

Definition at line 378 of file MyLocalization.cpp.

{
    setMessage("language", Debug);
    switch (thisLocale.language())
    {
        case QLocale::Afrikaans:        return QStringLiteral("af");
        case QLocale::Albanian:         return QStringLiteral("sq");
        case QLocale::Amharic:          return QStringLiteral("am");
        case QLocale::Arabic:           return QStringLiteral("ar");
        case QLocale::Armenian:         return QStringLiteral("hy");
        case QLocale::Azerbaijani:      return QStringLiteral("az");
        case QLocale::Bashkir:          return QStringLiteral("ba");
        case QLocale::Basque:           return QStringLiteral("eu");
        case QLocale::Belarusian:       return QStringLiteral("be");
        case QLocale::Bengali:          return QStringLiteral("bn");
        case QLocale::Bosnian:          return QStringLiteral("bs");
        case QLocale::Bulgarian:        return QStringLiteral("bg");
        case QLocale::Catalan:          return QStringLiteral("ca");
        case QLocale::Chinese:          return QStringLiteral("zh-CN");
        case QLocale::LiteraryChinese:  return QStringLiteral("zh-TW");
        case QLocale::Corsican:         return QStringLiteral("co");
        case QLocale::Croatian:         return QStringLiteral("hr");
        case QLocale::Czech:            return QStringLiteral("cs");
        case QLocale::Cantonese:        return QStringLiteral("yue");
        case QLocale::Cebuano:          return QStringLiteral("ceb");
        case QLocale::Chickasaw:        return QStringLiteral("ny");
        case QLocale::Danish:           return QStringLiteral("da");
        case QLocale::Dutch:            return QStringLiteral("nl");
        case QLocale::Esperanto:        return QStringLiteral("eo");
        case QLocale::Estonian:         return QStringLiteral("et");
        case QLocale::Finnish:          return QStringLiteral("fi");
        case QLocale::French:           return QStringLiteral("fr");
        case QLocale::Frisian:          return QStringLiteral("fy");
        case QLocale::Fijian:           return QStringLiteral("fj");
        case QLocale::Galician:         return QStringLiteral("gl");
        case QLocale::Georgian:         return QStringLiteral("ka");
        case QLocale::German:           return QStringLiteral("de");
        case QLocale::Greek:            return QStringLiteral("el");
        case QLocale::Gujarati:         return QStringLiteral("gu");
        case QLocale::Haitian:          return QStringLiteral("ht");
        case QLocale::Hausa:            return QStringLiteral("ha");
        case QLocale::Hawaiian:         return QStringLiteral("haw");
        case QLocale::Hebrew:           return QStringLiteral("he");
        case QLocale::Hindi:            return QStringLiteral("hi");
        case QLocale::Hungarian:        return QStringLiteral("hu");
        //case QLocale::HillMari:       return QStringLiteral("mrj");
        //case QLocale::HmongNjua Hmong:return QStringLiteral("hmn");
        case QLocale::Icelandic:        return QStringLiteral("is");
        case QLocale::Igbo:             return QStringLiteral("ig");
        case QLocale::Indonesian:       return QStringLiteral("id");
        case QLocale::Irish:            return QStringLiteral("ga");
        case QLocale::Italian:          return QStringLiteral("it");
        case QLocale::Japanese:         return QStringLiteral("ja");
        case QLocale::Javanese:         return QStringLiteral("jw");
        case QLocale::Kannada:          return QStringLiteral("kn");
        case QLocale::Kazakh:           return QStringLiteral("kk");
        case QLocale::Khmer:            return QStringLiteral("km");
        case QLocale::Kinyarwanda:      return QStringLiteral("rw");
        case QLocale::Korean:           return QStringLiteral("ko");
        case QLocale::Kurdish:          return QStringLiteral("ku");
        //case QLocale::Klingon:        return QStringLiteral("tlh");
        //case QLocale::KlingonPlqaD:   return QStringLiteral("tlh-Qaak");
        //case QLocale::Kyrgyzstan:     return QStringLiteral("ky");
        case QLocale::Lao:              return QStringLiteral("lo");
        case QLocale::Latin:            return QStringLiteral("la");
        case QLocale::Latvian:          return QStringLiteral("lv");
        case QLocale::Lithuanian:       return QStringLiteral("lt");
        case QLocale::Luxembourgish:    return QStringLiteral("lb");
        //case QLocale::LevantineArabic:return QStringLiteral("apc");
        //case QLocale::Mari:           return QStringLiteral("mhr");
        //case QLocale::Myanmar:        return QStringLiteral("my");
        case QLocale::Papiamento:       return QStringLiteral("pap");
        case QLocale::Macedonian:       return QStringLiteral("mk");
        case QLocale::Malagasy:         return QStringLiteral("mg");
        case QLocale::Malay:            return QStringLiteral("ms");
        case QLocale::Malayalam:        return QStringLiteral("ml");
        case QLocale::Maltese:          return QStringLiteral("mt");
        case QLocale::Maori:            return QStringLiteral("mi");
        case QLocale::Marathi:          return QStringLiteral("mr");
        case QLocale::Mongolian:        return QStringLiteral("mn");
        case QLocale::Nepali:           return QStringLiteral("ne");
        case QLocale::NorwegianBokmal:  return QStringLiteral("no");
        case QLocale::Oriya:            return QStringLiteral("or");
        //case QLocale::QueretaroOtomi: return QStringLiteral("otq");
        case QLocale::Pashto:           return QStringLiteral("ps");
        case QLocale::Persian:          return QStringLiteral("fa");
        case QLocale::Polish:           return QStringLiteral("pl");
        case QLocale::Portuguese:       return QStringLiteral("pt");
        case QLocale::Punjabi:          return QStringLiteral("pa");
        case QLocale::Romanian:         return QStringLiteral("ro");
        case QLocale::Russian:          return QStringLiteral("ru");
        case QLocale::Samoan:           return QStringLiteral("sm");
        case QLocale::Gaelic:           return QStringLiteral("gd");
        case QLocale::Serbian:          return QStringLiteral("sr");
        case QLocale::Shona:            return QStringLiteral("sn");
        case QLocale::Sindhi:           return QStringLiteral("sd");
        case QLocale::Sinhala:          return QStringLiteral("si");
        case QLocale::Slovak:           return QStringLiteral("sk");
        case QLocale::Slovenian:        return QStringLiteral("sl");
        case QLocale::Somali:           return QStringLiteral("so");
        case QLocale::Spanish:          return QStringLiteral("es");
        case QLocale::Sundanese:        return QStringLiteral("su");
        case QLocale::Swahili:          return QStringLiteral("sw");
        case QLocale::Swedish:          return QStringLiteral("sv");
        //case QLocale::SerbianLatin:   return QStringLiteral("sr-Latin");
        //case QLocale::Sesotho:        return QStringLiteral("st");
        case QLocale::Filipino:         return QStringLiteral("fil");
        case QLocale::Tajik:            return QStringLiteral("tg");
        case QLocale::Tamil:            return QStringLiteral("ta");
        case QLocale::Tatar:            return QStringLiteral("tt");
        case QLocale::Telugu:           return QStringLiteral("te");
        case QLocale::Thai:             return QStringLiteral("th");
        case QLocale::Turkish:          return QStringLiteral("tr");
        case QLocale::Turkmen:          return QStringLiteral("tk");
        //case QLocale::Tagalog:        return QStringLiteral("tl");
        case QLocale::Tahitian:         return QStringLiteral("ty");
        case QLocale::Tongan:           return QStringLiteral("to");
        case QLocale::Uighur:           return QStringLiteral("ug");
        case QLocale::Ukrainian:        return QStringLiteral("uk");
        case QLocale::Urdu:             return QStringLiteral("ur");
        case QLocale::Uzbek:            return QStringLiteral("uz");
        //case QLocale::Udmurt:         return QStringLiteral("udm");
        case QLocale::Vietnamese:       return QStringLiteral("vi");
        case QLocale::Welsh:            return QStringLiteral("cy");
        case QLocale::Xhosa:            return QStringLiteral("xh");
        case QLocale::Yiddish:          return QStringLiteral("yi");
        case QLocale::Yoruba:           return QStringLiteral("yo");
        //case QLocale::YucatecMaya:    return QStringLiteral("yua");
        case QLocale::Zulu:             return QStringLiteral("zu");
        default:
            if (thisLocale.name() == "HaitianCreole")
                { return QStringLiteral("ht"); }
            else if (thisLocale.name() == "HillMari")
                { return QStringLiteral("mrj"); }
            else if (thisLocale.name() == "Hmong")
                { return QStringLiteral("hmn"); }
            else if (thisLocale.name() == "Klingon")
                { return QStringLiteral("tlh"); }
            else if (thisLocale.name() == "KlingonPlqaD")
                { return QStringLiteral("tlh-Qaak"); }
            else if (thisLocale.name() == "Kyrgyz")
                { return QStringLiteral("ky"); }
            else if (thisLocale.name() == "LevantineArabic")
                { return QStringLiteral("apc"); }
            else if (thisLocale.name() == "Mari")
                { return QStringLiteral("mhr"); }
            else if (thisLocale.name() == "Myanmar")
                { return QStringLiteral("my"); }
            else if (thisLocale.name() == "Chichewa")
                { return QStringLiteral("ny"); }
            else if (thisLocale.name() == "QueretaroOtomi")
                { return QStringLiteral("otq"); }
            else if (thisLocale.name() == "ScotsGaelic")
                { return QStringLiteral("gd"); }
            else if (thisLocale.name() == "SerbianCyrillic")
                { return QStringLiteral("sr"); }
            else if (thisLocale.name() == "SerbianLatin")
                { return QStringLiteral("sr-Latin"); }
            else if (thisLocale.name() == "Sesotho")
                { return QStringLiteral("st"); }
            else if (thisLocale.name() == "Tagalog")
                { return QStringLiteral("tl"); }
            else if (thisLocale.name() == "Udmurt")
                { return QStringLiteral("udm"); }
            else if (thisLocale.name() == "YucatecMaya")
                { return QStringLiteral("yua"); }
            return QStringLiteral("en");
    }
} // end language(const QLocale

◆ languageCodeToName()

QString MyLocalization::languageCodeToName ( const QString & lang )

language Code to Name Added by Light-Wizzard

Added by Light-Wizzard language Code to Name.

languageCodeToName

Definition at line 299 of file MyLocalization.cpp.

{
    setMessage("languageCodeToName", Debug);
    return s_genericLanguageCodeToName.value(lang);
} // end languageCodeToName

◆ languageMatch()

bool MyLocalization::languageMatch	(	const QString &	thisPrefix,
		const QString &	thisLang,
		const QString &	thisQmFile
	)

language Match

language Match qmFile naming. languageMatch

Definition at line 221 of file MyLocalization.cpp.

{
    setMessage("languageMatch", Debug);
    // qmFile: ProjectName_xx.qm
    QString theLang = thisLang;
    QString theLocalizer = getLocalizedCodeFromFile(thisPrefix, thisQmFile);
    if (theLocalizer.contains("_"))
    { theLocalizer = theLocalizer.section("_", 0, 0); }
    if (thisLang.contains("_"))
    { theLang = thisLang.section("_", 0, 0); }
    return theLocalizer == theLang;
}

◆ languageName()

QString MyLocalization::languageName ( const QLocale & thisLocale )

language Name

language Name. languageName

Definition at line 820 of file MyLocalization.cpp.

{
    switch (thisLocale.language())
    {
    case QLocale::Afrikaans:             return tr("Afrikaans");
    case QLocale::Albanian:              return tr("Albanian");
    case QLocale::Amharic:               return tr("Amharic");
    case QLocale::Arabic:                return tr("Arabic");
    case QLocale::Armenian:              return tr("Armenian");
    case QLocale::Azerbaijani:           return tr("Azeerbaijani");
    case QLocale::Basque:                return tr("Basque");
    case QLocale::Bashkir:               return tr("Bashkir");
    case QLocale::Belarusian:            return tr("Belarusian");
    case QLocale::Bengali:               return tr("Bengali");
    case QLocale::Bosnian:               return tr("Bosnian");
    case QLocale::Bulgarian:             return tr("Bulgarian");
    case QLocale::Catalan:               return tr("Catalan");
    case QLocale::Cantonese:             return tr("Cantonese");
    case QLocale::Cebuano:               return tr("Cebuano");
    case QLocale::Chinese:               return tr("Chinese (Simplified)");
    case QLocale::LiteraryChinese:       return tr("Chinese (Traditional)");
    case QLocale::Corsican:              return tr("Corsican");
    case QLocale::Croatian:              return tr("Croatian");
    case QLocale::Czech:                 return tr("Czech");
    case QLocale::Danish:                return tr("Danish");
    case QLocale::Dutch:                 return tr("Dutch");
    case QLocale::English:               return tr("English");
    case QLocale::Esperanto:             return tr("Esperanto");
    case QLocale::Estonian:              return tr("Estonian");
    case QLocale::Fijian:                return tr("Fijian");
    case QLocale::Filipino:              return tr("Filipino");
    case QLocale::Finnish:               return tr("Finnish");
    case QLocale::French:                return tr("French");
    case QLocale::Frisian:               return tr("Frisian");
    case QLocale::Galician:              return tr("Galician");
    case QLocale::Georgian:              return tr("Georgian");
    case QLocale::German:                return tr("German");
    case QLocale::Greek:                 return tr("Greek");
    case QLocale::Gujarati:              return tr("Gujarati");
    //case QLocale::HaitianCreole:       return tr("Haitian Creole");
    case QLocale::Hausa:                 return tr("Hausa");
    case QLocale::Hawaiian:              return tr("Hawaiian");
    case QLocale::Hebrew:                return tr("Hebrew");
    //case QLocale::HillMari:            return tr("Hill Mari");
    case QLocale::Hindi:                 return tr("Hindi");
    //case QLocale::Hmong:               return tr("Hmong");
    case QLocale::Hungarian:             return tr("Hungarian");
    case QLocale::Icelandic:             return tr("Icelandic");
    case QLocale::Igbo:                  return tr("Igbo");
    case QLocale::Indonesian:            return tr("Indonesian");
    case QLocale::Irish:                 return tr("Irish");
    case QLocale::Italian:               return tr("Italian");
    case QLocale::Japanese:              return tr("Japanese");
    case QLocale::Javanese:              return tr("Javanese");
    case QLocale::Kannada:               return tr("Kannada");
    case QLocale::Kazakh:                return tr("Kazakh");
    case QLocale::Khmer:                 return tr("Khmer");
    case QLocale::Kinyarwanda:           return tr("Kinyarwanda");
    //case QLocale::Klingon:             return tr("Klingon");
    //case QLocale::KlingonPlqaD:        return tr("Klingon (PlqaD)");
    case QLocale::Korean:                return tr("Korean");
    case QLocale::Kurdish:               return tr("Kurdish");
    //case QLocale::Kyrgyz:              return tr("Kyrgyz");
    case QLocale::Lao:                   return tr("Lao");
    case QLocale::Latin:                 return tr("Latin");
    case QLocale::Latvian:               return tr("Latvian");
    //case QLocale::LevantineArabic:     return tr("Levantine Arabic");
    case QLocale::Lithuanian:            return tr("Lithuanian");
    case QLocale::Luxembourgish:         return tr("Luxembourgish");
    case QLocale::Macedonian:            return tr("Macedonian");
    case QLocale::Malagasy:              return tr("Malagasy");
    case QLocale::Malay:                 return tr("Malay");
    case QLocale::Malayalam:             return tr("Malayalam");
    case QLocale::Maltese:               return tr("Maltese");
    case QLocale::Maori:                 return tr("Maori");
    case QLocale::Marathi:               return tr("Marathi");
    //case QLocale::Mari:                return tr("Mari");
    case QLocale::Mongolian:             return tr("Mongolian");
    //case QLocale::Myanmar:             return tr("Myanmar");
    case QLocale::Nepali:                return tr("Nepali");
    //case QLocale::Norwegian:           return tr("Norwegian");
    case QLocale::Oriya:                 return tr("Oriya");
    //case QLocale::Chichewa:            return tr("Chichewa");
    case QLocale::Papiamento:            return tr("Papiamento");
    case QLocale::Pashto:                return tr("Pashto");
    case QLocale::Persian:               return tr("Persian");
    case QLocale::Polish:                return tr("Polish");
    case QLocale::Portuguese:            return tr("Portuguese");
    case QLocale::Punjabi:               return tr("Punjabi");
    //case QLocale::QueretaroOtomi:      return tr("Queretaro Otomi");
    case QLocale::Romanian:              return tr("Romanian");
    case QLocale::Russian:               return tr("Russian");
    case QLocale::Samoan:                return tr("Samoan");
    //case QLocale::ScotsGaelic:         return tr("Scots Gaelic");
    //case QLocale::SerbianCyrillic:     return tr("Serbian (Cyrillic)");
    //case QLocale::SerbianLatin:        return tr("Serbian (Latin)");
    //case QLocale::Sesotho:             return tr("Sesotho");
    case QLocale::Shona:                 return tr("Shona");
    case QLocale::Sindhi:                return tr("Sindhi");
    case QLocale::Sinhala:               return tr("Sinhala");
    case QLocale::Slovak:                return tr("Slovak");
    case QLocale::Slovenian:             return tr("Slovenian");
    case QLocale::Somali:                return tr("Somali");
    case QLocale::Spanish:               return tr("Spanish");
    case QLocale::Sundanese:             return tr("Sundanese");
    case QLocale::Swahili:               return tr("Swahili");
    case QLocale::Swedish:               return tr("Swedish");
    //case QLocale::Tagalog:             return tr("Tagalog");
    case QLocale::Tahitian:              return tr("Tahitian");
    case QLocale::Tajik:                 return tr("Tajik");
    case QLocale::Tamil:                 return tr("Tamil");
    case QLocale::Tatar:                 return tr("Tatar");
    case QLocale::Telugu:                return tr("Telugu");
    case QLocale::Thai:                  return tr("Thai");
    case QLocale::Tongan:                return tr("Tongan");
    case QLocale::Turkish:               return tr("Turkish");
    case QLocale::Turkmen:               return tr("Turkmen");
    //case QLocale::Udmurt:              return tr("Udmurt");
    case QLocale::Uighur:                return tr("Uighur");
    case QLocale::Ukrainian:             return tr("Ukrainian");
    case QLocale::Urdu:                  return tr("Urdu");
    case QLocale::Uzbek:                 return tr("Uzbek");
    case QLocale::Vietnamese:            return tr("Vietnamese");
    case QLocale::Welsh:                 return tr("Welsh");
    case QLocale::Xhosa:                 return tr("Xhosa");
    case QLocale::Yiddish:               return tr("Yiddish");
    case QLocale::Yoruba:                return tr("Yoruba");
    //case QLocale::YucatecMaya:         return tr("Yucatec Maya");
    case QLocale::Zulu:                  return tr("Zulu");
    default:
        if (thisLocale.name() == "HaitianCreole")
            { return tr("Haitian Creole"); }
        else if (thisLocale.name() == "HillMari")
            { return tr("Hill Mari"); }
        else if (thisLocale.name() == "Hmong")
            { return tr("Hmong"); }
        else if (thisLocale.name() == "Klingon")
            { return tr("Klingon"); }
        else if (thisLocale.name() == "KlingonPlqaD")
            { return tr("Klingon (PlqaD)"); }
        else if (thisLocale.name() == "Kyrgyz")
            { return tr("Kyrgyz"); }
        else if (thisLocale.name() == "LevantineArabic")
            { return tr("Levantine Arabic"); }
        else if (thisLocale.name() == "Mari")
            { return tr("Mari"); }
        else if (thisLocale.name() == "Myanmar")
            { return tr("Myanmar"); }
        else if (thisLocale.name() == "Chichewa")
            { return tr("Chichewa"); }
        else if (thisLocale.name() == "QueretaroOtomi")
            { return tr("Queretaro Otomi"); }
        else if (thisLocale.name() == "ScotsGaelic")
            { return tr("Scots Gaelic"); }
        else if (thisLocale.name() == "SerbianCyrillic")
            { return tr("Serbian (Cyrillic)"); }
        else if (thisLocale.name() == "SerbianLatin")
            { return tr("Serbian (Latin)"); }
        else if (thisLocale.name() == "Sesotho")
            { return tr("Sesotho"); }
        else if (thisLocale.name() == "Tagalog")
            { return tr("Tagalog"); }
        else if (thisLocale.name() == "Udmurt")
            { return tr("Udmurt"); }
        else if (thisLocale.name() == "YucatecMaya")
            { return tr("Yucatec Maya"); }
        return QString();
    } // end switch (lang)
} // end languageName(Language lang)

◆ languageNameFromFile()

QString MyLocalization::languageNameFromFile ( const QString & thisTranslationFile )

language Name From File

language Name From File. languageNameFromFile

Definition at line 136 of file MyLocalization.cpp.

{
    setMessage("languageNameFromFile", Debug);
    QTranslator translator;
    translator.load(thisTranslationFile);
    // FIXME
    return translator.translate("MainWindow", "English");
}

◆ languageNameToCode()

QString MyLocalization::languageNameToCode ( const QString & lang )

language Name to Code Added by Light-Wizzard

Added by Light-Wizzard language Name to Code. languageNameToCode.

Definition at line 290 of file MyLocalization.cpp.

{
    setMessage("languageNameToCode", Debug);
    return s_genericLanguageNameToCode.value(lang);
} // end languageNameToCode

◆ loadLanguage()

void MyLocalization::loadLanguage ( const QString & thisQmLanguageFile )

load Language

load Language. loadLanguage

Definition at line 79 of file MyLocalization.cpp.

{
    setMessage("loadLanguage", Debug);
 
    if (myTranslator->load(thisQmLanguageFile))
    {
        if (myLastTranslator == nullptr ) { qApp->removeTranslator(myLastTranslator); }
        qApp->installTranslator(myTranslator);
        myLastTranslator = myTranslator;
    }
    else
    {
        qCritical() << "loadLanguage failed";
    }
}

◆ readLanguage()

QString MyLocalization::readLanguage ( )

read Language

read Language. readLanguage

Definition at line 316 of file MyLocalization.cpp.

{
    setMessage("readLanguage", Debug);
    setLanguageCode(mySetting->readSettings(MY_LOCALE_LANG_CODE, getDefaultLanguageCode()));
    return myLanguageCode;
}

◆ removeArgs()

void MyLocalization::removeArgs	(	const QString &	thisString,
		const QString &	thisTransFile
	)

remove Args file creation

remove Args like "String %1" list. removeArgs

Definition at line 168 of file MyLocalization.cpp.

{
    setMessage("removeArgs", Debug);
    myRemoveTransArgs.append(QString("%1 |%2| in file %3").arg(tr("Remove Arguments that use Percent Sign x"), thisString, thisTransFile));
} // end removeArgs

◆ setDebugMessage()

void MyLocalization::setDebugMessage ( bool thisState )

set Debug Message

set Debug Message. setDebugMessage

Definition at line 118 of file MyLocalization.cpp.

{
    isDebugMessage = thisState;
    setMessage("setDebugMessage", Debug);
}

◆ setHelpSource()

void MyLocalization::setHelpSource ( const QString & thisHelpSource )

set Help Source

set Help Source. setHelpSource

Definition at line 52 of file MyLocalization.cpp.

{
    setMessage("setHelpSource", Debug);
    myHelpSource = thisHelpSource;
}

◆ setLanguageCode()

void MyLocalization::setLanguageCode ( const QString & thisLanguageCode )

set Language Code

set Debug Message. setDebugMessage

Definition at line 336 of file MyLocalization.cpp.

{
    setMessage("setLanguageCode", Debug);
    myLanguageCode = thisLanguageCode;
}

◆ setMainLoaded()

void MyLocalization::setMainLoaded ( bool thisMainLoaded )

set Main Loaded

language. language

Definition at line 359 of file MyLocalization.cpp.

{
    setMessage("setMainLoaded", Debug);
    isMainLoaded = thisMainLoaded;
}

◆ setMessage()

void MyLocalization::setMessage	(	const QString &	thisMessage,
		MyLocalization::MyMessageTypes	thisMessageType
	)

set Message

set Message. setMessage

Definition at line 993 of file MyLocalization.cpp.

{
    if (isDebugMessage && isMainLoaded) { return; }
    switch (thisMessageType)
    {
        case Information:
            mySetting->showMessageBox(thisMessage, thisMessage, mySetting->Information);
            break;
        case Warning:
            mySetting->showMessageBox(thisMessage, thisMessage, mySetting->Warning);
            break;
        case Critical:
            mySetting->showMessageBox(thisMessage, thisMessage, mySetting->Critical);
            break;
        case Question:
        case Debug:
            if (isDebugMessage)
            {
                qDebug() << thisMessage;
                //std::cout << thisMessage.toStdString() << std::endl;
            }
            break;
    }
}

◆ setTransFilePrefix()

void MyLocalization::setTransFilePrefix ( const QString & thisTransFilePrefix )

set TransFile Prefix

set Trans File Prefix setTransFilePrefix("ProjectName");. setTransFilePrefix

Definition at line 70 of file MyLocalization.cpp.

{
    setMessage("setTransFilePrefix", Debug);
    myTransFilePrefix = thisTransFilePrefix;
}

◆ setTranslationSource()

void MyLocalization::setTranslationSource ( const QString & thisTranslationSource )

set Translation Source

set Translation Source. setTranslationSource

Definition at line 34 of file MyLocalization.cpp.

{
    setMessage("setTranslationSource", Debug);
    myTranslationSource = thisTranslationSource;
}

◆ writeLanguage()

void MyLocalization::writeLanguage ( const QString & thisCurrentLanguageCode )

write Language

write Language. writeLanguage

Definition at line 326 of file MyLocalization.cpp.

{
    setMessage("writeLanguage", Debug);
    setLanguageCode(thisCurrentLanguageCode);
    mySetting->writeSettings(MY_LOCALE_LANG_CODE, thisCurrentLanguageCode);
}

Member Data Documentation

◆ MY_LANG_CODE

const QString MyLocalization::MY_LANG_CODE = "LanguageCode"

MY_LANG_CODE

Field Name for Language Code

Definition at line 53 of file MyLocalization.h.

◆ MY_LANG_NAME

const QString MyLocalization::MY_LANG_NAME = "LanguageName"

MY_LANG_NAME

Field Name for Language Name

Definition at line 54 of file MyLocalization.h.

◆ MY_LOCALE_LANG_CODE

const QString MyLocalization::MY_LOCALE_LANG_CODE = "LocaleLanguageCode"

MY_CURRENT_LANG_CODE

Field Name for Current Language Code.

Definition at line 55 of file MyLocalization.h.

◆ mySetting

MyOrgSettings* MyLocalization::mySetting

mySetting

Domain Settings

Definition at line 51 of file MyLocalization.h.

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

src/MyLocalization.h
src/MyLocalization.cpp

Public Types

Public Member Functions

Public Attributes