How to use QT internationalization - qt

Question

This may seem like a dumb question, but i'm having lots of trouble to have internationalization working well in QT 5.12.
There are at least 2 things i would like to do:
The possibility to save the language that was selected by the user and the next time the user runs the app its selected (but problably that would require at least a file to save that), or run the app in the native language of the SO.
Having a dynamic translation working, by this i mean the language to be automatically changed while the application is running.
About the first point i know that to install the translation of the native language of the system something like Translator.load("qt_" + QLocale::system().name(),QLibraryInfo::location(QLibraryInfo::TranslationsPath)) can be used.
The second point, i've found a solution but it requires that i place a folder with the name translation(on this case) on the release/debug folder where i place the individual .qm files.
I'm going to provide a simple example of what i've found so far:
main.cpp
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QFontDatabase>
#include <QFont>
#include <QtQml>
#include "trans.h"
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QTranslator Translator;
Translator.load(":/translations/translating-qml_ru.qm");
app.installTranslator(&Translator);
QQmlApplicationEngine engine;
// object of our class with "magic" property for translation
Trans trans(&engine);
// make this object available from QML side
engine.rootContext()->setContextProperty("trans", &trans);
engine.load(QUrl(QLatin1String("qrc:/main.qml")));
return app.exec();
}
main.qml
import QtQuick 2.7
import QtQuick.Layouts 1.3
import QtQuick.Controls 2.0
import QtQuick.Window 2.2
ApplicationWindow {
id: root
width: 800
minimumWidth: 500
height: 600
minimumHeight: 600
visible: true
title: "Translating QML application"
Column {
width: parent.width * 0.95
spacing: 15
padding: 15
RowLayout {
anchors.horizontalCenter: parent.horizontalCenter
Button {
Layout.preferredWidth: 76
Layout.preferredHeight: 53
text:"EN"
onClicked: {
onClicked: trans.selectLanguage("en");
}
}
Rectangle
{
Layout.preferredWidth: 2
Layout.fillHeight: true
Layout.margins: 10
color: "black"
}
Button {
text: "RU"
Layout.preferredWidth: 76
Layout.preferredHeight: 53
onClicked: {
onClicked: trans.selectLanguage("ru");
}
}
Rectangle
{
Layout.preferredWidth: 2
Layout.fillHeight: true
Layout.margins: 10
color: "black"
}
Button {
text: "NO"
Layout.preferredWidth: 76
Layout.preferredHeight: 53
onClicked: {
onClicked: trans.selectLanguage("no");
}
}
Rectangle
{
Layout.preferredWidth: 2
Layout.fillHeight: true
Layout.margins: 10
color: "black"
}
Button {
text: "DE"
Layout.preferredWidth: 76
Layout.preferredHeight: 53
onClicked: {
onClicked: trans.selectLanguage("de");
}
}
}
Label {
font.pixelSize: 16
text: qsTr("I woke up after midnight and realised - <b>IT DOES</b>!<br/>"
+ "Everything goes according to the plan.")
}
}
}
trans.cpp
#include "trans.h"
Trans::Trans(QQmlEngine *engine)
{
_translator = new QTranslator(this);
_engine = engine;
}
void Trans::selectLanguage(QString language)
{
QString languagesArray[] = { "en", "pt", "es", "br", "de", "dk", "fi", "fr", "it", "lt", "no", "ro", "tr", "hu" };
QDir dir = QDir(qApp->applicationDirPath()).absolutePath();
for(int i=0;i<languagesArray->length();i++){
if(languagesArray[i] != language){
_translator->load(QString("Lang-%1").arg(languagesArray[i]),QString("%1/translation").arg(dir.path()));
qApp->removeTranslator(_translator);
}
}
if (!_translator->load(
QString("translating-qml_%1").arg(language),
// look for the file in translations folder within working directory
QString("%1/translations").arg(dir.path())
)
)
{
qDebug() << "Failed to load translation file, falling back to English";
}
// it's a global thing, we can use it anywhere (after #including <QGuiApplication>)
qApp->installTranslator(_translator);
_engine->retranslate();
emit languageChanged();
}
trans.h
#ifndef TRANS_H
#define TRANS_H
#include <QObject>
#include <QTranslator>
#include <QDebug>
#include <QGuiApplication>
#include <QDir>
#include <QQmlEngine>
class Trans : public QObject
{
Q_OBJECT
public:
Trans(QQmlEngine *engine);
Q_INVOKABLE void selectLanguage(QString language);
signals:
void languageChanged();
private:
QTranslator *_translator;
QQmlEngine *_engine;
};
#endif // TRANS_H
I want to know step by step what i have to do to have this system fully working, because the info i've found the web (including qt docs) is confuse to me.

Answer 1

For the first point it is only necessary to save the information that identifies the language on the hard disk through QSettings. When the application is started, the QSettings should be read and, accordingly, the translation should be done and when the language is modified it should be saved.
Your second point is not very clear, but I suppose you want what are the steps to use Qt Internationalization, there are several methods since some tasks can be done manually and others can be automated.
First add the following instruction to the .pro:
TRANSLATIONS = /path/of/some_name1.ts \
/path/of/some_name2.ts \
/path/of/some_name3.ts
In my example I use the following structure:
TARGET = AppTranslations
# ...
TRANSLATIONS = i18n/$${TARGET}_en.ts \
i18n/$${TARGET}_de.ts \
i18n/$${TARGET}_no.ts \
i18n/$${TARGET}_ru.ts
Then you must open the terminal or CMD in the folder where your .pro is and execute the following command:
lupdate your_project.pro
This generates the .ts where you indicated, then you have to use Qt Linguist to edit that file doing the translations.
Then you convert the .ts to .qm with:
lrelease your_project.pro
Then you can add the .qm to a qresource embedding in the application, but in my case I prefer that it is in a folder on the side of the executable so the executable does not weigh much and could add more translations without recompiling the project, and for it to be automated the next command to be copied to the side of the executable.
COPY_CONFIG = $$files(i18n/*.qm, true)
copy_cmd.input = COPY_CONFIG
copy_cmd.output = i18n/${QMAKE_FILE_IN_BASE}${QMAKE_FILE_EXT}
copy_cmd.commands = $$QMAKE_COPY_DIR ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
copy_cmd.CONFIG += no_link_no_clean
copy_cmd.variable_out = PRE_TARGETDEPS
QMAKE_EXTRA_COMPILERS += copy_cmd
So in the end the build folder will have the following structure:
├── AppTranslations
├── i18n
│   ├── AppTranslations_de.qm
│   ├── AppTranslations_en.qm
│   ├── AppTranslations_no.qm
│   └── AppTranslations_ru.qm
│  ...
Now that you have the .qm, the logic of using it in the application is implemented. Before Qt 5.10 you had to do the trick of adding an empty string for the translation to work but the latest versions do not require it.
On the other hand in my case I implement a logic to get the .qm and so the languages available since I use a default format:
{Name_Of_Application}_{lang}.qm
The other part of the logic is similar to yours so I will not go into much detail and I will show you the code:
translator.h
#ifndef TRANSLATOR_H
#define TRANSLATOR_H
#include <QDir>
#include <QObject>
#include <QQmlEngine>
#include <QTranslator>
class Translator : public QObject
{
Q_OBJECT
Q_PROPERTY(QStringList languages READ languages NOTIFY languagesChanged)
Q_PROPERTY(QString currentLanguage READ currentLanguage NOTIFY currentLanguageChanged)
public:
explicit Translator(QQmlEngine *engine, QObject *parent = nullptr);
Q_INVOKABLE void selectLanguage(const QString & language);
QStringList languages() const;
QString currentLanguage() const;
Q_INVOKABLE static QString languageByCode(const QString & code);
signals:
void languageChanged();
void languagesChanged();
void currentLanguageChanged();
private:
const QString extension = ".qm";
QQmlEngine *m_engine;
QTranslator *m_translator;
QStringList m_languages;
QString m_currentLanguage;
QDir m_dir;
};
#endif // TRANSLATOR_H
translator.cpp
#include "translator.h"
#include <QGuiApplication>
#include <QDirIterator>
#include <QSettings>
Translator::Translator(QQmlEngine *engine, QObject *parent) :
QObject(parent),
m_engine(engine)
{
m_translator = new QTranslator(this);
m_dir = QDir(QGuiApplication::applicationDirPath(),
"*"+extension,
QDir::Name|QDir::IgnoreCase,
QDir::Files);
m_dir.cd("i18n");
m_languages.clear();
for(QString entry: m_dir.entryList()){
entry.remove(0, QGuiApplication::applicationName().length()+1);
entry.chop(extension.length());
m_languages.append(entry);
}
emit languagesChanged();
QSettings settings;
QString lang =settings.value("Language/current", QLocale::system().bcp47Name()).toString();
selectLanguage(lang);
}
QStringList Translator::languages() const
{
return m_languages;
}
QString Translator::currentLanguage() const
{
return m_currentLanguage;
}
QString Translator::languageByCode(const QString &code)
{
QLocale lo(code);
return QLocale::languageToString(lo.language());
}
void Translator::selectLanguage(const QString &language)
{
qApp->removeTranslator(m_translator);
if(m_languages.contains(language)){
QString file = QString("%1_%2%3").arg(QGuiApplication::applicationName()).arg(language).arg(extension);
if(m_translator->load(m_dir.absoluteFilePath(file))){
m_currentLanguage = language;
QSettings settings;
settings.setValue("Language/current", language);
emit currentLanguageChanged();
}
}
qApp->installTranslator(m_translator);
m_engine->retranslate();
emit languageChanged();
}
And then it applies to your project:
main.cpp
#include "translator.h"
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QCoreApplication::setOrganizationName("Translations INC");
QCoreApplication::setOrganizationDomain("translations.com");
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
Translator trans(&engine);
engine.rootContext()->setContextProperty("trans", &trans);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
main.qml
import QtQuick 2.7
import QtQuick.Layouts 1.3
import QtQuick.Controls 2.0
import QtQuick.Window 2.2
ApplicationWindow {
id: root
width: 800
minimumWidth: 500
height: 600
minimumHeight: 600
visible: true
title: "Translating QML application"
Column {
width: parent.width * 0.95
spacing: 15
padding: 15
RowLayout {
anchors.horizontalCenter: parent.horizontalCenter
Repeater{
model: trans.languages
Button{
id: btn
property string code: modelData
text: trans.languageByCode(code)
onClicked: trans.selectLanguage(btn.code)
Layout.preferredWidth: 100
Layout.preferredHeight: 50
highlighted: code == trans.currentLanguage
}
}
}
Label {
font.pixelSize: 16
text: qsTr("I woke up after midnight and realised - <b>IT DOES</b>!<br/>"
+ "Everything goes according to the plan.")
}
}
}
The complete example you find here.