Qt/C++ Tutorial 092. Creating translations for external text sources

Qt 6, Qt, Qt 5, QtLinguist, translation

Today we will discuss a rather interesting option for adding translation to a Qt/C++ application. Namely, adding translations for texts from external sources when you display texts from databases, an external API, or just some other files.

Such a situation can arise in the following case, for example, analysts in your project form sets of data and texts in some external database or text files, but there is no possibility of multilingualism for some reason. And therefore, you do not have the option to select the language as an additional parameter when requesting this data. Or, for example, the final data is downloaded from an external resource and stored in a SQLite database, of course, without additional translations. But at the same time, you are developing a multilingual application and you need to somehow generate translation files for these texts, so that the translation team can translate them, and you can connect them in the application.

But in Qt it is possible to solve this problem as well. In such situations, you can also generate source code files in the same way, for example, generate them when importing data during application development, and then generate translation files with the extension *.ts , which are used in QtLinguist to translate the application to Qt, and then generate binary *.qm translation files that will be included in the application.

Let's see how it works and what needs to be done for this.

Adding source files

In order for the lupdate application to be able to create *.ts files, the project must have header and source files. But they don't have to be compiled. It turns out such an interesting trick, in which there are non-compiled files in the project, but without them it will not be possible to generate *.ts files.

pro file

Let's look at the contents of the pro file to understand which files are needed in our project.

TRANSLATIONS= myapp_en.ts\
               myapp_cs.ts\
               myapp_de.ts\
               myapp_es.ts

SOURCES += \
    translations_generated.cpp

HEADERS += \
    translations_generated.h

As you can see, there are *.ts translation files, as well as two files translations_generated.h and translations_generated.cpp .
These files are generated or added by you manually, it doesn't matter, it doesn't matter how exactly you create and add these files.
The main thing is that these files have appropriate content.

translations_generated.h

You will be surprised, but we leave this file empty.

translations_generated.cpp

And here is the most important content.

#ifdef TRANSLATOR_GUARD

//
// Uncompiled file, only as source for lupdate.exe
//
namespace my
{
namespace translation
{
namespace example
{
Q_OBJECT
tr("Height");
tr("total length");
tr("Length");
tr("Home");
} // namespace my
} // namespace translation
} // namespace example

#endif // TRANSLATOR_GUARD

Notice a few important things about this file:

• TRANSLATOR_GUARD - which prevents the file from being compiled, we don't need it
• namespace - namespaces create the context in which the translation will be generated. In this case, the context will be "my::translation::example"
• Q_OBJECT - this macro will tell lupdate that there may be translation call functions here, with the help of which the translation file will be generated.

After you generate the translation files with the lupdate program, you can translate these strings in QtLinguist and then compile the binary translation files to be used correctly in your application.

Using translations

Using translation will differ in that you will not write specific text, but pass a variable and context to the translation function QCoreApplication::translate .

Let's see how it would look like with an example class. This class has a variable that contains the string to be translated, as well as a method for returning the translated value.

#include <QCoreApplication>
#include <QString>

class ExampleTranslator
{
public:
    QString getTranslatedName() const
    {
        return QCoreApplication::translate("my::translation::example", m_name.toUtf8());
    }

private:
    QString m_name;
}

The QCoreApplication::translate method, with a properly invoked context, will try to find a translation for the passed text and, if successful, will return the translated value for the active language in the application.

Conclusion

Thus, it is possible to perform translations of any external texts, moreover, using standard Qt tools.