UITranslator.cpp@ 103977

Last change on this file since 103977 was 103362, checked in by vboxsync, 10 months ago
FE/Qt: bugref:10450: Get rid of QRegExp which is a part of Qt5 legacy API; This is necessary to get rid of Qt5 support lib.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.3 KB

Line
1	/* $Id: UITranslator.cpp 103362 2024-02-14 16:50:56Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UITranslator class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	/* Qt includes: */
29	#include <QApplication>
30	#include <QDir>
31	#include <QKeySequence>
32	#include <QRegularExpression>
33	#ifdef Q_OS_UNIX
34	# include <QLibraryInfo>
35	#endif
36
37	/* GUI includes: */
38	#include "UIConverter.h"
39	#include "UIMessageCenter.h"
40	#include "UITranslator.h"
41	#ifdef VBOX_WS_MAC
42	# include "VBoxUtils-darwin.h"
43	#endif
44
45	/* Other VBox includes: */
46	#include <iprt/assert.h>
47	#include <iprt/path.h>
48	#ifdef Q_OS_UNIX
49	# include <iprt/env.h>
50	#endif
51
52	/* External includes: */
53	#include <math.h>
54
55
56	/** Port config cache. */
57	struct PortConfig
58	{
59	const char *name;
60	const ulong IRQ;
61	const ulong IOBase;
62	};
63
64	/** Known port config COM ports. */
65	static const PortConfig kComKnownPorts[] =
66	{
67	{ "COM1", 4, 0x3F8 },
68	{ "COM2", 3, 0x2F8 },
69	{ "COM3", 4, 0x3E8 },
70	{ "COM4", 3, 0x2E8 },
71	/* Must not contain an element with IRQ=0 and IOBase=0 used to cause
72	* toCOMPortName() to return the "User-defined" string for these values. */
73	};
74
75
76	/* static */
77	UITranslator *UITranslator::s_pTranslator = 0;
78	bool UITranslator::s_fTranslationInProgress = false;
79	QString UITranslator::s_strLoadedLanguageId = UITranslator::vboxBuiltInLanguageName();
80
81	/* static */
82	void UITranslator::loadLanguage(const QString &strLangId /* = QString() */)
83	{
84	QString strEffectiveLangId = strLangId.isEmpty()
85	? systemLanguageId()
86	: strLangId;
87	QString strLanguageFileName;
88	QString strSelectedLangId = vboxBuiltInLanguageName();
89
90	/* If C is selected we change it temporary to en. This makes sure any extra
91	* "en" translation file will be loaded. This is necessary for loading the
92	* plural forms of some of our translations. */
93	bool fResetToC = false;
94	if (strEffectiveLangId == "C")
95	{
96	strEffectiveLangId = "en";
97	fResetToC = true;
98	}
99
100	char szNlsPath[RTPATH_MAX];
101	int rc;
102
103	rc = RTPathAppPrivateNoArch(szNlsPath, sizeof(szNlsPath));
104	AssertRC(rc);
105
106	QString strNlsPath = QString(szNlsPath) + vboxLanguageSubDirectory();
107	QDir nlsDir(strNlsPath);
108
109	Assert(!strEffectiveLangId.isEmpty());
110	if (!strEffectiveLangId.isEmpty() && strEffectiveLangId != vboxBuiltInLanguageName())
111	{
112	const QRegularExpression re(vboxLanguageIdRegExp());
113	const QRegularExpressionMatch mt = re.match(strEffectiveLangId);
114	/* The language ID should match the regexp completely: */
115	AssertReturnVoid(mt.capturedStart() == 0);
116
117	QString strStrippedLangId = mt.captured(2);
118
119	if (nlsDir.exists(vboxLanguageFileBase() + strEffectiveLangId + vboxLanguageFileExtension()))
120	{
121	strLanguageFileName = nlsDir.absoluteFilePath(vboxLanguageFileBase() +
122	strEffectiveLangId +
123	vboxLanguageFileExtension());
124	strSelectedLangId = strEffectiveLangId;
125	}
126	else if (nlsDir.exists(vboxLanguageFileBase() + strStrippedLangId + vboxLanguageFileExtension()))
127	{
128	strLanguageFileName = nlsDir.absoluteFilePath(vboxLanguageFileBase() +
129	strStrippedLangId +
130	vboxLanguageFileExtension());
131	strSelectedLangId = strStrippedLangId;
132	}
133	else
134	{
135	/* Never complain when the default language is requested. In any
136	* case, if no explicit language file exists, we will simply
137	* fall-back to English (built-in). */
138	if (!strLangId.isNull() && strEffectiveLangId != "en")
139	msgCenter().cannotFindLanguage(strEffectiveLangId, strNlsPath);
140	/* strSelectedLangId remains built-in here: */
141	AssertReturnVoid(strSelectedLangId == vboxBuiltInLanguageName());
142	}
143	}
144
145	/* Lock listener: */
146	s_fTranslationInProgress = true;
147	/* A list of translators to install: */
148	QList<QTranslator*> translators;
149
150	/* Delete the old translator if there is one: */
151	if (s_pTranslator)
152	{
153	/* QTranslator destructor will call qApp->removeTranslator() for
154	* us. It will also delete all its child translations we attach to it
155	* below, so we don't have to care about them specially. */
156	delete s_pTranslator;
157	}
158
159	/* Load new language files: */
160	s_pTranslator = new UITranslator(qApp);
161	Assert(s_pTranslator);
162	bool fLoadOk = true;
163	if (s_pTranslator)
164	{
165	if (strSelectedLangId != vboxBuiltInLanguageName())
166	{
167	Assert(!strLanguageFileName.isNull());
168	fLoadOk = s_pTranslator->loadFile(strLanguageFileName);
169	}
170	/* We install the translator in any case: on failure, this will
171	* activate an empty translator that will give us English (built-in): */
172	translators << s_pTranslator;
173	}
174	else
175	fLoadOk = false;
176
177	if (fLoadOk)
178	s_strLoadedLanguageId = strSelectedLangId;
179	else
180	{
181	msgCenter().cannotLoadLanguage(strLanguageFileName);
182	s_strLoadedLanguageId = vboxBuiltInLanguageName();
183	}
184
185	/* Try to load the corresponding Qt translation: */
186	if (languageId() != vboxBuiltInLanguageName() && languageId() != "en")
187	{
188	#ifdef Q_OS_UNIX
189	// We use system installations of Qt on Linux systems, so first, try
190	// to load the Qt translation from the system location.
191	strLanguageFileName = QLibraryInfo::path(QLibraryInfo::TranslationsPath) + "/qt_" +
192	languageId() + vboxLanguageFileExtension();
193	QTranslator *pQtSysTr = new QTranslator(s_pTranslator);
194	Assert(pQtSysTr);
195	if (pQtSysTr && pQtSysTr->load(strLanguageFileName))
196	translators << pQtSysTr;
197	// Note that the Qt translation supplied by Oracle is always loaded
198	// afterwards to make sure it will take precedence over the system
199	// translation (it may contain more decent variants of translation
200	// that better correspond to VirtualBox UI). We need to load both
201	// because a newer version of Qt may be installed on the user computer
202	// and the Oracle version may not fully support it. We don't do it on
203	// Win32 because we supply a Qt library there and therefore the
204	// Oracle translation is always the best one. */
205	#endif
206	strLanguageFileName = nlsDir.absoluteFilePath(QString("qt_") +
207	languageId() +
208	vboxLanguageFileExtension());
209	QTranslator *pQtTr = new QTranslator(s_pTranslator);
210	Assert(pQtTr);
211	if (pQtTr && (fLoadOk = pQtTr->load(strLanguageFileName)))
212	translators << pQtTr;
213	/* The below message doesn't fit 100% (because it's an additional
214	* language and the main one won't be reset to built-in on failure)
215	* but the load failure is so rare here that it's not worth a separate
216	* message (but still, having something is better than having none) */
217	if (!fLoadOk && !strLangId.isNull())
218	msgCenter().cannotLoadLanguage(strLanguageFileName);
219	}
220	if (fResetToC)
221	s_strLoadedLanguageId = vboxBuiltInLanguageName();
222	#ifdef VBOX_WS_MAC
223	// Qt doesn't translate the items in the Application menu initially.
224	// Manually trigger an update.
225	::darwinRetranslateAppMenu();
226	#endif
227
228	/* Iterate through all the translators: */
229	for (int i = 0; i < translators.size(); ++i)
230	{
231	/* Unlock listener before the last one translator: */
232	if (i == translators.size() - 1)
233	{
234	QCoreApplication::sendPostedEvents(0, QEvent::LanguageChange);
235	s_fTranslationInProgress = false;
236	}
237
238	/* Install current one: */
239	qApp->installTranslator(translators.at(i));
240	}
241
242	/* Unlock listener in case if it's still locked: */
243	s_fTranslationInProgress = false;
244	}
245
246	/* static */
247	QString UITranslator::vboxLanguageSubDirectory()
248	{
249	return "/nls";
250	}
251
252	/* static */
253	QString UITranslator::vboxLanguageFileBase()
254	{
255	return "VirtualBox_";
256	}
257
258	/* static */
259	QString UITranslator::vboxLanguageFileExtension()
260	{
261	return ".qm";
262	}
263
264	/* static */
265	QString UITranslator::vboxLanguageIdRegExp()
266	{
267	return "(([a-z]{2})(?:_([A-Z]{2}))?)\|(C)";
268	}
269
270	/* static */
271	QString UITranslator::vboxBuiltInLanguageName()
272	{
273	return "C";
274	}
275
276	/* static */
277	QString UITranslator::languageId()
278	{
279	/* Note that it may not match with UIExtraDataManager::languageId() if the specified language cannot be loaded.
280	*
281	* If the built-in language is active, this method returns "C". "C" is treated as the built-in language for
282	* simplicity -- the C locale is used in unix environments as a fallback when the requested locale is invalid.
283	* This way we don't need to process both the "built_in" language and the "C" language (which is a valid
284	* environment setting) separately. */
285
286	return s_strLoadedLanguageId;
287	}
288
289	/* static */
290	QString UITranslator::yearsToString(uint32_t cVal)
291	{
292	return QApplication::translate("UITranslator", "%n year(s)", "", cVal);
293	}
294
295	/* static */
296	QString UITranslator::monthsToString(uint32_t cVal)
297	{
298	return QApplication::translate("UITranslator", "%n month(s)", "", cVal);
299	}
300
301	/* static */
302	QString UITranslator::daysToString(uint32_t cVal)
303	{
304	return QApplication::translate("UITranslator", "%n day(s)", "", cVal);
305	}
306
307	/* static */
308	QString UITranslator::hoursToString(uint32_t cVal)
309	{
310	return QApplication::translate("UITranslator", "%n hour(s)", "", cVal);
311	}
312
313	/* static */
314	QString UITranslator::minutesToString(uint32_t cVal)
315	{
316	return QApplication::translate("UITranslator", "%n minute(s)", "", cVal);
317	}
318
319	/* static */
320	QString UITranslator::secondsToString(uint32_t cVal)
321	{
322	return QApplication::translate("UITranslator", "%n second(s)", "", cVal);
323	}
324
325	/* static */
326	QString UITranslator::yearsToStringAgo(uint32_t cVal)
327	{
328	return QApplication::translate("UITranslator", "%n year(s) ago", "", cVal);
329	}
330
331	/* static */
332	QString UITranslator::monthsToStringAgo(uint32_t cVal)
333	{
334	return QApplication::translate("UITranslator", "%n month(s) ago", "", cVal);
335	}
336
337	/* static */
338	QString UITranslator::daysToStringAgo(uint32_t cVal)
339	{
340	return QApplication::translate("UITranslator", "%n day(s) ago", "", cVal);
341	}
342
343	/* static */
344	QString UITranslator::hoursToStringAgo(uint32_t cVal)
345	{
346	return QApplication::translate("UITranslator", "%n hour(s) ago", "", cVal);
347	}
348
349	/* static */
350	QString UITranslator::minutesToStringAgo(uint32_t cVal)
351	{
352	return QApplication::translate("UITranslator", "%n minute(s) ago", "", cVal);
353	}
354
355	/* static */
356	QString UITranslator::secondsToStringAgo(uint32_t cVal)
357	{
358	return QApplication::translate("UITranslator", "%n second(s) ago", "", cVal);
359	}
360
361	/* static */
362	QString UITranslator::decimalSep()
363	{
364	return QString(QLocale::system().decimalPoint());
365	}
366
367	/* static */
368	QString UITranslator::sizeRegexp()
369	{
370	/* This regexp will capture 5 groups of text:
371	* - cap(1): integer number in case when no decimal point is present
372	* (if empty, it means that decimal point is present)
373	* - cap(2): size suffix in case when no decimal point is present (may be empty)
374	* - cap(3): integer number in case when decimal point is present (may be empty)
375	* - cap(4): fraction number (hundredth) in case when decimal point is present
376	* - cap(5): size suffix in case when decimal point is present (note that
377	* B cannot appear there). */
378
379	const QString strRegexp =
380	QString("^(?:(?:(\\d+)(?:\\s?(%2\|%3\|%4\|%5\|%6\|%7))?)\|(?:(\\d*)%1(\\d{1,2})(?:\\s?(%3\|%4\|%5\|%6\|%7))))$")
381	.arg(decimalSep())
382	.arg(tr("B", "size suffix Bytes"))
383	.arg(tr("KB", "size suffix KBytes=1024 Bytes"))
384	.arg(tr("MB", "size suffix MBytes=1024 KBytes"))
385	.arg(tr("GB", "size suffix GBytes=1024 MBytes"))
386	.arg(tr("TB", "size suffix TBytes=1024 GBytes"))
387	.arg(tr("PB", "size suffix PBytes=1024 TBytes"));
388	return strRegexp;
389	}
390
391	/* static */
392	quint64 UITranslator::parseSize(const QString &strText)
393	{
394	/* Text should be in form of B\|KB\|MB\|GB\|TB\|PB. */
395	const QRegularExpression re(sizeRegexp());
396	const QRegularExpressionMatch mt = re.match(strText);
397	if (mt.hasMatch())
398	{
399	QString strInteger = mt.captured(1);
400	QString strHundred;
401	QString strSuff = mt.captured(2);
402	if (strInteger.isEmpty())
403	{
404	strInteger = mt.captured(3);
405	strHundred = mt.captured(4);
406	strSuff = mt.captured(5);
407	}
408
409	quint64 uDenominator = 0;
410	if (strSuff.isEmpty() \|\| strSuff == tr("B", "size suffix Bytes"))
411	uDenominator = 1;
412	else if (strSuff == tr("KB", "size suffix KBytes=1024 Bytes"))
413	uDenominator = _1K;
414	else if (strSuff == tr("MB", "size suffix MBytes=1024 KBytes"))
415	uDenominator = _1M;
416	else if (strSuff == tr("GB", "size suffix GBytes=1024 MBytes"))
417	uDenominator = _1G;
418	else if (strSuff == tr("TB", "size suffix TBytes=1024 GBytes"))
419	uDenominator = _1T;
420	else if (strSuff == tr("PB", "size suffix PBytes=1024 TBytes"))
421	uDenominator = _1P;
422
423	quint64 iInteger = strInteger.toULongLong();
424	if (uDenominator == 1)
425	return iInteger;
426
427	quint64 iHundred = strHundred.leftJustified(2, '0').toULongLong();
428	iHundred = iHundred * uDenominator / 100;
429	iInteger = iInteger * uDenominator + iHundred;
430	return iInteger;
431	}
432	else
433	return 0;
434	}
435
436	/* static */
437	SizeSuffix UITranslator::parseSizeSuffix(const QString &strText)
438	{
439	/* Text should be in form of B\|KB\|MB\|GB\|TB\|PB. */
440	const QRegularExpression re(sizeRegexp());
441	const QRegularExpressionMatch mt = re.match(strText);
442	if (mt.hasMatch())
443	{
444	QString strInteger = mt.captured(1);
445	QString strSuff = mt.captured(2);
446	if (strInteger.isEmpty())
447	{
448	strInteger = mt.captured(3);
449	strSuff = mt.captured(5);
450	}
451
452	SizeSuffix enmSizeSuffix = SizeSuffix_Byte;
453
454	if (strSuff.isEmpty() \|\| strSuff == tr("B", "size suffix Bytes"))
455	enmSizeSuffix = SizeSuffix_Byte;
456	else if (strSuff == tr("KB", "size suffix KBytes=1024 Bytes"))
457	enmSizeSuffix = SizeSuffix_KiloByte;
458	else if (strSuff == tr("MB", "size suffix MBytes=1024 KBytes"))
459	enmSizeSuffix = SizeSuffix_MegaByte;
460	else if (strSuff == tr("GB", "size suffix GBytes=1024 MBytes"))
461	enmSizeSuffix = SizeSuffix_GigaByte;
462	else if (strSuff == tr("TB", "size suffix TBytes=1024 GBytes"))
463	enmSizeSuffix = SizeSuffix_TeraByte;
464	else if (strSuff == tr("PB", "size suffix PBytes=1024 TBytes"))
465	enmSizeSuffix = SizeSuffix_PetaByte;
466	return enmSizeSuffix;
467	}
468	else
469	return SizeSuffix_Byte;
470	}
471
472	/* static */
473	bool UITranslator::hasSizeSuffix(const QString &strText)
474	{
475	/* Text should be in form of B\|KB\|MB\|GB\|TB\|PB. */
476	const QRegularExpression re(sizeRegexp());
477	const QRegularExpressionMatch mt = re.match(strText);
478	if (mt.hasMatch())
479	{
480	QString strInteger = mt.captured(1);
481	QString strSuff = mt.captured(2);
482	if (strInteger.isEmpty())
483	{
484	strInteger = mt.captured(3);
485	strSuff = mt.captured(5);
486	}
487
488	if (strSuff.isEmpty())
489	return false;
490	if (strSuff == tr("B", "size suffix Bytes") \|\|
491	strSuff == tr("KB", "size suffix KBytes=1024 Bytes") \|\|
492	strSuff == tr("MB", "size suffix MBytes=1024 KBytes") \|\|
493	strSuff == tr("GB", "size suffix GBytes=1024 MBytes") \|\|
494	strSuff == tr("TB", "size suffix TBytes=1024 GBytes") \|\|
495	strSuff == tr("PB", "size suffix PBytes=1024 TBytes"))
496	return true;
497	return false;
498	}
499	else
500	return false;
501	}
502
503	/* static */
504	QString UITranslator::formatSize(quint64 uSize, uint cDecimal /* = 2 */,
505	FormatSize enmMode /* = FormatSize_Round */)
506	{
507	/* Text will be in form of B\|KB\|MB\|GB\|TB\|PB.
508	*
509	* When enmMode is FormatSize_Round, the result is rounded to the
510	* closest number containing @a aDecimal decimal digits.
511	* When enmMode is FormatSize_RoundDown, the result is rounded to the
512	* largest number with @a aDecimal decimal digits that is not greater than
513	* the result. This guarantees that converting the resulting string back to
514	* the integer value in bytes will not produce a value greater that the
515	* initial size parameter.
516	* When enmMode is FormatSize_RoundUp, the result is rounded to the
517	* smallest number with @a aDecimal decimal digits that is not less than the
518	* result. This guarantees that converting the resulting string back to the
519	* integer value in bytes will not produce a value less that the initial
520	* size parameter. */
521
522	quint64 uDenominator = 0;
523	int iSuffix = 0;
524
525	if (uSize < _1K)
526	{
527	uDenominator = 1;
528	iSuffix = 0;
529	}
530	else if (uSize < _1M)
531	{
532	uDenominator = _1K;
533	iSuffix = 1;
534	}
535	else if (uSize < _1G)
536	{
537	uDenominator = _1M;
538	iSuffix = 2;
539	}
540	else if (uSize < _1T)
541	{
542	uDenominator = _1G;
543	iSuffix = 3;
544	}
545	else if (uSize < _1P)
546	{
547	uDenominator = _1T;
548	iSuffix = 4;
549	}
550	else
551	{
552	uDenominator = _1P;
553	iSuffix = 5;
554	}
555
556	quint64 uInteger = uSize / uDenominator;
557	quint64 uDecimal = uSize % uDenominator;
558	quint64 uMult = 1;
559	for (uint i = 0; i < cDecimal; ++i)
560	uMult *= 10;
561
562	QString strNumber;
563	if (uDenominator > 1)
564	{
565	if (uDecimal)
566	{
567	uDecimal *= uMult;
568	/* Not greater: */
569	if (enmMode == FormatSize_RoundDown)
570	uDecimal = uDecimal / uDenominator;
571	/* Not less: */
572	else if (enmMode == FormatSize_RoundUp)
573	uDecimal = (uDecimal + uDenominator - 1) / uDenominator;
574	/* Nearest: */
575	else
576	uDecimal = (uDecimal + uDenominator / 2) / uDenominator;
577	}
578	/* Check for the fractional part overflow due to rounding: */
579	if (uDecimal == uMult)
580	{
581	uDecimal = 0;
582	++uInteger;
583	/* Check if we've got 1024 XB after rounding and scale down if so: */
584	if (uInteger == 1024 && iSuffix + 1 < (int)SizeSuffix_Max)
585	{
586	uInteger /= 1024;
587	++iSuffix;
588	}
589	}
590	strNumber = QString::number(uInteger);
591	if (cDecimal)
592	strNumber += QString("%1%2").arg(decimalSep())
593	.arg(QString::number(uDecimal).rightJustified(cDecimal, '0'));
594	}
595	else
596	{
597	strNumber = QString::number(uInteger);
598	}
599
600	return QString("%1 %2").arg(strNumber).arg(gpConverter->toString(static_cast<SizeSuffix>(iSuffix)));
601	}
602
603	/* static */
604	QString UITranslator::addMetricSuffixToNumber(quint64 uNumber)
605	{
606	if (uNumber <= 0)
607	return QString();
608	/* See https://en.wikipedia.org/wiki/Metric_prefix for metric suffixes:*/
609	char suffixes[] = {'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'};
610	int zeroCount = (int)log10((long double)uNumber);
611	if (zeroCount < 3)
612	return QString::number(uNumber);
613	int h = 3 * (zeroCount / 3);
614	char result[128];
615	sprintf(result, "%.2f", uNumber / (float)pow((double)10, h));
616	return QString("%1%2").arg(result).arg(suffixes[h / 3 - 1]);
617	}
618
619	/* static */
620	QStringList UITranslator::COMPortNames()
621	{
622	QStringList list;
623	for (size_t i = 0; i < RT_ELEMENTS(kComKnownPorts); ++i)
624	list << kComKnownPorts[i].name;
625
626	return list;
627	}
628
629	/* static */
630	QString UITranslator::toCOMPortName(ulong uIRQ, ulong uIOBase)
631	{
632	for (size_t i = 0; i < RT_ELEMENTS(kComKnownPorts); ++i)
633	if (kComKnownPorts[i].IRQ == uIRQ &&
634	kComKnownPorts[i].IOBase == uIOBase)
635	return kComKnownPorts[i].name;
636
637	return tr("User-defined", "serial port");;
638	}
639
640	/* static */
641	bool UITranslator::toCOMPortNumbers(const QString &strName, ulong &uIRQ, ulong &uIOBase)
642	{
643	for (size_t i = 0; i < RT_ELEMENTS(kComKnownPorts); ++i)
644	if (strcmp(kComKnownPorts[i].name, strName.toUtf8().data()) == 0)
645	{
646	uIRQ = kComKnownPorts[i].IRQ;
647	uIOBase = kComKnownPorts[i].IOBase;
648	return true;
649	}
650
651	return false;
652	}
653
654	/* Regular expressions used by both highlight and emphasize. They use the
655	same prefix and suffix expression. Unfortunately, QRegularExpression isn't
656	thread safe, so we only store the string contstants here. */
657	/** @todo qt6: Both these had bogus suffix sets '[:.-!);]', I've changed them to '[-:.!);]', hope that's correct. */
658	static char const g_szRxSingleQuotes[] = "((?:^\|\\s)[(]?)"
659	"'([^']*)'"
660	"(?=[-:.!);]?(?:\\s\|$))";
661	static const char g_szRxUuid[] = "((?:^\|\\s)[(]?)"
662	"(\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\})"
663	"(?=[-:.!);]?(?:\\s\|$))";
664
665	/* static */
666	QString UITranslator::highlight(QString strText, bool fToolTip /* = false */)
667	{
668	/* We should reformat the input strText so that:
669	* - strings in single quotes will be put inside <nobr> and marked
670	* with blue color;
671	* - UUIDs be put inside <nobr> and marked
672	* with green color;
673	* - replaces new line chars with </p><p> constructs to form paragraphs
674	* (note that <p\> and </p> are not appended to the beginning and to the
675	* end of the string respectively, to allow the result be appended
676	* or prepended to the existing paragraph).
677	*
678	* If @a fToolTip is true, colouring is not applied, only the <nobr> tag
679	* is added. Also, new line chars are replaced with <br> instead of <p>. */
680
681	QString strFont;
682	QString uuidFont;
683	QString endFont;
684	if (!fToolTip)
685	{
686	strFont = "<font color=#0000CC>";
687	uuidFont = "<font color=#008000>";
688	endFont = "</font>";
689	}
690
691	/* Replace special entities, '&' -- first! */
692	strText.replace('&', "&");
693	strText.replace('<', "<");
694	strText.replace('>', ">");
695	strText.replace('\"', """);
696
697	/* Mark strings in single quotes with color: */
698	strText.replace(QRegularExpression(g_szRxSingleQuotes), QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strFont).arg(endFont));
699
700	/* Mark UUIDs with color: */
701	strText.replace(QRegularExpression(g_szRxUuid), QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidFont).arg(endFont));
702
703	/* Split to paragraphs at \n chars: */
704	if (!fToolTip)
705	strText.replace('\n', "</p><p>");
706	else
707	strText.replace('\n', "<br>");
708
709	return strText;
710	}
711
712	/* static */
713	QString UITranslator::emphasize(QString strText)
714	{
715	/* We should reformat the input string @a strText so that:
716	* - strings in single quotes will be put inside \<nobr\> and marked
717	* with bold style;
718	* - UUIDs be put inside \<nobr\> and marked
719	* with italic style;
720	* - replaces new line chars with \</p\>\<p\> constructs to form paragraphs
721	* (note that \<p\> and \</p\> are not appended to the beginning and to the
722	* end of the string respectively, to allow the result be appended
723	* or prepended to the existing paragraph). */
724
725	QString strEmphStart("<b>");
726	QString strEmphEnd("</b>");
727	QString uuidEmphStart("<i>");
728	QString uuidEmphEnd("</i>");
729
730	/* Replace special entities, '&' -- first! */
731	strText.replace('&', "&");
732	strText.replace('<', "<");
733	strText.replace('>', ">");
734	strText.replace('\"', """);
735
736	/* Mark strings in single quotes with bold style: */
737	strText.replace(QRegularExpression(g_szRxSingleQuotes), QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strEmphStart).arg(strEmphEnd));
738
739	/* Mark UUIDs with italic style: */
740	strText.replace(QRegularExpression(g_szRxUuid), QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidEmphStart).arg(uuidEmphEnd));
741
742	/* Split to paragraphs at \n chars: */
743	strText.replace('\n', "</p><p>");
744
745	return strText;
746	}
747
748	/* static */
749	QString UITranslator::removeAccelMark(QString strText)
750	{
751	/* In order to support accelerators used in non-alphabet languages
752	* (e.g. Japanese) that has a form of "(&<L>)" (where <L> is a latin letter),
753	* this method first searches for this pattern and, if found, removes it as a
754	* whole. If such a pattern is not found, then the '&' character is simply
755	* removed from the string. */
756
757	const QRegularExpression re("\$&[a-zA-Z]\$");
758	const QRegularExpressionMatch mt = re.match(strText);
759	int iPos = mt.capturedStart();
760	if (iPos >= 0)
761	strText.remove(iPos, mt.capturedLength());
762	else
763	{
764	iPos = strText.indexOf('&');
765	if (iPos >= 0)
766	strText.remove(iPos, 1);
767	}
768
769	return strText;
770	}
771
772	/* static */
773	QString UITranslator::insertKeyToActionText(const QString &strText, const QString &strKey)
774	{
775	#ifdef VBOX_WS_MAC
776	QString strPattern("%1 (Host+%2)");
777	#else
778	QString strPattern("%1 \tHost+%2");
779	#endif
780	if ( strKey.isEmpty()
781	\|\| strKey.compare("None", Qt::CaseInsensitive) == 0)
782	return strText;
783	else
784	return strPattern.arg(strText).arg(QKeySequence(strKey).toString(QKeySequence::NativeText));
785	}
786
787	/* static */
788	bool UITranslator::isTranslationInProgress()
789	{
790	return s_fTranslationInProgress;
791	}
792
793	/* static */
794	QString UITranslator::byteStringToMegaByteString(const QString &strByteString)
795	{
796	if (strByteString.isEmpty())
797	return QString();
798	bool fConversionSuccess = false;
799	qulonglong uByte = strByteString.toULongLong(&fConversionSuccess);
800	AssertReturn(fConversionSuccess, QString());
801	return QString::number(uByte / _1M);
802	}
803
804	/* static */
805	QString UITranslator::megabyteStringToByteString(const QString &strMegaByteString)
806	{
807	if (strMegaByteString.isEmpty())
808	return QString();
809	bool fConversionSuccess = false;
810	qulonglong uMegaByte = strMegaByteString.toULongLong(&fConversionSuccess);
811	AssertReturn(fConversionSuccess, QString());
812	return QString::number(uMegaByte * _1M);
813	}
814
815	UITranslator::UITranslator(QObject pParent / = 0 */)
816	: QTranslator(pParent)
817	{
818	}
819
820	bool UITranslator::loadFile(const QString &strFileName)
821	{
822	QFile file(strFileName);
823	if (!file.open(QIODevice::ReadOnly))
824	return false;
825	m_data = file.readAll();
826	return load((uchar*)m_data.data(), m_data.size());
827	}
828
829	/* static */
830	QString UITranslator::languageName()
831	{
832	/* Returns "English" if no translation is installed
833	* or if the translation file is invalid. */
834	return QApplication::translate("@@@", "English",
835	"Native language name");
836	}
837
838	/* static */
839	QString UITranslator::languageCountry()
840	{
841	/* Returns "--" if no translation is installed or if the translation file
842	* is invalid, or if the language is independent on the country. */
843	return QApplication::translate("@@@", "--",
844	"Native language country name "
845	"(empty if this language is for all countries)");
846	}
847
848	/* static */
849	QString UITranslator::languageNameEnglish()
850	{
851	/* Returns "English" if no translation is installed
852	* or if the translation file is invalid. */
853	return QApplication::translate("@@@", "English",
854	"Language name, in English");
855	}
856
857	/* static */
858	QString UITranslator::languageCountryEnglish()
859	{
860	/* Returns "--" if no translation is installed or if the translation file
861	* is invalid, or if the language is independent on the country. */
862	return QApplication::translate("@@@", "--",
863	"Language country name, in English "
864	"(empty if native country name is empty)");
865	}
866
867	/* static */
868	QString UITranslator::languageTranslators()
869	{
870	/* Returns "Oracle Corporation" if no translation is installed or if the translation file
871	* is invalid, or if the translation is supplied by Oracle Corporation. */
872	return QApplication::translate("@@@", "Oracle Corporation",
873	"Comma-separated list of translators");
874	}
875
876	/* static */
877	QString UITranslator::systemLanguageId()
878	{
879	/* This does exactly the same as QLocale::system().name() but corrects its wrong behavior on Linux systems
880	* (LC_NUMERIC for some strange reason takes precedence over any other locale setting in the QLocale::system()
881	* implementation). This implementation first looks at LC_ALL (as defined by SUS), then looks at LC_MESSAGES
882	* which is designed to define a language for program messages in case if it differs from the language for
883	* other locale categories. Then it looks for LANG and finally falls back to QLocale::system().name().
884	*
885	* The order of precedence is well defined here:
886	* http://opengroup.org/onlinepubs/007908799/xbd/envvar.html
887	*
888	* This method will return "C" when the requested locale is invalid or when the "C" locale is set explicitly. */
889
890	#if defined(VBOX_WS_MAC)
891	// QLocale return the right id only if the user select the format
892	// of the language also. So we use our own implementation */
893	return ::darwinSystemLanguage();
894	#elif defined(Q_OS_UNIX)
895	const char *pszValue = RTEnvGet("LC_ALL");
896	if (pszValue == 0)
897	pszValue = RTEnvGet("LC_MESSAGES");
898	if (pszValue == 0)
899	pszValue = RTEnvGet("LANG");
900	if (pszValue != 0)
901	return QLocale(pszValue).name();
902	#endif
903	return QLocale::system().name();
904	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/globals/UITranslator.cpp@ 103977

Download in other formats: