mirror of
https://gitlab.linphone.org/BC/public/linphone-desktop.git
synced 2026-01-17 11:28:07 +00:00
e795f0ea51
Instantiate SDK thread. Add logger. Format logs to match SDK syntax. Change log domain to 'app'.
969 lines
53 KiB
C++
969 lines
53 KiB
C++
/*
|
|
* Copyright (c) 2010-2020 Belledonne Communications SARL.
|
|
*
|
|
* This file is part of linphone-desktop
|
|
* (see https://www.linphone.org).
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <QAction>
|
|
#include <QBitmap>
|
|
#include <QCoreApplication>
|
|
#include <QCryptographicHash>
|
|
#include <QCursor>
|
|
#include <QDebug>
|
|
#include <QDir>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QImageReader>
|
|
#include <QMimeDatabase>
|
|
#include <QTimeZone>
|
|
#include <QUrl>
|
|
|
|
#include "config.h"
|
|
|
|
#ifdef PDF_ENABLED
|
|
#include "components/pdf/PdfWidget.hpp"
|
|
#include <QtPdf/QPdfDocument>
|
|
#include <QtPdfWidgets/QPdfView>
|
|
#endif
|
|
|
|
//#include "UriTools.hpp"
|
|
#include "Utils.hpp"
|
|
|
|
#ifdef _WIN32
|
|
#include <time.h>
|
|
#endif
|
|
|
|
// =============================================================================
|
|
|
|
char *Utils::rstrstr(const char *a, const char *b) {
|
|
size_t a_len = strlen(a);
|
|
size_t b_len = strlen(b);
|
|
|
|
if (b_len > a_len) return nullptr;
|
|
|
|
for (const char *s = a + a_len - b_len; s >= a; --s) {
|
|
if (!strncmp(s, b, b_len)) return const_cast<char *>(s);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
/*
|
|
namespace {
|
|
constexpr int SafeFilePathLimit = 100;
|
|
|
|
}
|
|
|
|
std::shared_ptr<linphone::Address> Utils::interpretUrl(const QString& address){
|
|
bool usePrefix = CoreManager::getInstance()->getAccountSettingsModel()->getUseInternationalPrefixForCallsAndChats();
|
|
auto interpretedAddress = CoreManager::getInstance()->getCore()->interpretUrl(Utils::appStringToCoreString(address),
|
|
usePrefix); if(!interpretedAddress){// Try by removing scheme. QStringList splitted = address.split(":");
|
|
if(splitted.size() > 0 && splitted[0] == "sip"){
|
|
splitted.removeFirst();
|
|
interpretedAddress =
|
|
CoreManager::getInstance()->getCore()->interpretUrl(Utils::appStringToCoreString(splitted.join(":")), usePrefix);
|
|
}
|
|
}
|
|
return interpretedAddress;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool Utils::hasCapability(const QString& address, const LinphoneEnums::FriendCapability& capability, bool
|
|
defaultCapability){ auto addressCleaned = cleanSipAddress(address); auto contact =
|
|
CoreManager::getInstance()->getContactsListModel()->findContactModelFromSipAddress(addressCleaned); if(contact) return
|
|
contact->hasCapability(capability); else return defaultCapability;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
QDateTime Utils::addMinutes(QDateTime date, const int& min){
|
|
return date.addSecs(min*60);
|
|
}
|
|
|
|
QDateTime Utils::getOffsettedUTC(const QDateTime& date){
|
|
QDateTime utc = date.toUTC();// Get a date free of any offsets.
|
|
auto timezone = date.timeZone();
|
|
utc = utc.addSecs(timezone.offsetFromUtc(date));// add offset from date timezone
|
|
utc.setTimeSpec(Qt::OffsetFromUTC);// ensure to have an UTC date
|
|
return utc;
|
|
}
|
|
|
|
QString Utils::toDateTimeString(QDateTime date, const QString& format){
|
|
if(date.date() == QDate::currentDate())
|
|
return toTimeString(date);
|
|
else{
|
|
return getOffsettedUTC(date).toString(format);
|
|
}
|
|
}
|
|
|
|
QString Utils::toTimeString(QDateTime date, const QString& format){
|
|
// Issue : date.toString() will not print the good time in timezones. Get it from date and add ourself the offset.
|
|
return getOffsettedUTC(date).toString(format);
|
|
}
|
|
|
|
QString Utils::toDateString(QDateTime date, const QString& format){
|
|
return QLocale().toString(getOffsettedUTC(date), (!format.isEmpty() ? format : QLocale().dateFormat()) );
|
|
}
|
|
|
|
QString Utils::toDateString(QDate date, const QString& format){
|
|
return QLocale().toString(date, (!format.isEmpty() ? format : QLocale().dateFormat()) );
|
|
}
|
|
|
|
// Return custom address to be displayed on UI.
|
|
// In order to return only the username and to remove all domains from the GUI, you may just change the default mode.
|
|
QString Utils::toDisplayString(const QString& str, SipDisplayMode displayMode){
|
|
if(displayMode == SIP_DISPLAY_ALL) return str;
|
|
std::shared_ptr<linphone::Address> addr = linphone::Factory::get()->createAddress(str.toStdString());
|
|
QString displayString;
|
|
if( addr && ( (displayMode & SIP_DISPLAY_USERNAME) == SIP_DISPLAY_USERNAME))
|
|
displayString = Utils::coreStringToAppString(addr->getUsername());
|
|
if(displayString.isEmpty())
|
|
return str;
|
|
else
|
|
return displayString;
|
|
}
|
|
|
|
QDate Utils::getCurrentDate() {
|
|
return QDate::currentDate();
|
|
}
|
|
|
|
DateModel* Utils::getCurrentDateModel() {
|
|
return new DateModel(QDate::currentDate());
|
|
}
|
|
|
|
QDate Utils::getMinDate() {
|
|
return QDate(1,1,1);
|
|
}
|
|
DateModel* Utils::getMinDateModel() {
|
|
return new DateModel(QDate(1,1,1));
|
|
}
|
|
QDate Utils::toDate(const QString& str, const QString& format) {
|
|
return QDate::fromString(str, format);
|
|
}
|
|
DateModel* Utils::toDateModel(const QString& str, const QString& format) {
|
|
return new DateModel(toDate(str, format));
|
|
}
|
|
QDate Utils::getDate(int year, int month, int day) {
|
|
auto d = QDate(year, month, day);
|
|
if(!d.isValid() ){
|
|
auto first = QDate(year, month, 1);
|
|
if(first.isValid()) {
|
|
d = first.addDays(day-1);
|
|
}
|
|
}
|
|
return d;
|
|
}
|
|
|
|
DateModel* Utils::getDateModel(int year, int month, int day) {
|
|
auto d = QDate(year, month, day);
|
|
if(!d.isValid() ){
|
|
auto first = QDate(year, month, 1);
|
|
if(first.isValid()) {
|
|
d = first.addDays(day-1);
|
|
}
|
|
}
|
|
return new DateModel(d);
|
|
}
|
|
|
|
int Utils::getFullYear(const QDate& date) {
|
|
return date.year();
|
|
}
|
|
|
|
int Utils::getMonth(const QDate& date) {
|
|
return date.month();
|
|
}
|
|
|
|
int Utils::getDay(const QDate& date) {
|
|
return date.day();
|
|
}
|
|
|
|
int Utils::getDayOfWeek(const QDate& date) {
|
|
return date.dayOfWeek();
|
|
}
|
|
|
|
bool Utils::equals(const QDate& d1, const QDate& d2){
|
|
return d1 == d2;
|
|
}
|
|
|
|
bool Utils::isGreatherThan(const QDate& d1, const QDate& d2) {
|
|
return d1 >= d2;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
QString Utils::getDisplayName(const QString& address){
|
|
QString displayName = getDisplayName(interpretUrl(address));
|
|
return displayName.isEmpty() ? address : displayName;
|
|
}
|
|
|
|
QString Utils::getInitials(const QString& username){
|
|
if(username.isEmpty()) return "";
|
|
|
|
QRegularExpression regex("[\\s\\.]+");
|
|
QStringList words = username.split(regex);// Qt 5.14: Qt::SkipEmptyParts
|
|
QStringList initials;
|
|
auto str32 = words[0].toStdU32String();
|
|
std::u32string char32;
|
|
char32 += str32[0];
|
|
initials << QString::fromStdU32String(char32);
|
|
for(int i = 1; i < words.size() && initials.size() <= 1 ; ++i) {
|
|
if( words[i].size() > 0){
|
|
str32 = words[i].toStdU32String();
|
|
char32[0] = str32[0];
|
|
initials << QString::fromStdU32String(char32);
|
|
}
|
|
}
|
|
return App::getInstance()->getLocale().toUpper(initials.join(""));
|
|
}
|
|
|
|
QString Utils::toString(const LinphoneEnums::TunnelMode& mode){
|
|
switch(mode){
|
|
case LinphoneEnums::TunnelMode::TunnelModeEnable :
|
|
//: 'Enable' : One word for button action to enable tunnel mode.
|
|
return QObject::tr("LinphoneEnums_TunnelModeEnable");
|
|
case LinphoneEnums::TunnelMode::TunnelModeDisable :
|
|
//: 'Disable' : One word for button action to disable tunnel mode.
|
|
return QObject::tr("LinphoneEnums_TunnelModeDisable");
|
|
case LinphoneEnums::TunnelMode::TunnelModeAuto :
|
|
//: 'Auto' : One word for button action to set the auto tunnel mode.
|
|
return QObject::tr("LinphoneEnums_TunnelModeAuto");
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
QImage Utils::getImage(const QString &pUri) {
|
|
QImage image(pUri);
|
|
QImageReader reader(pUri);
|
|
reader.setAutoTransform(true);
|
|
if(image.isNull()){// Try to determine format from headers instead of using suffix
|
|
reader.setDecideFormatFromContent(true);
|
|
}
|
|
return reader.read();
|
|
}
|
|
QString Utils::getSafeFilePath (const QString &filePath, bool *soFarSoGood) {
|
|
if (soFarSoGood)
|
|
*soFarSoGood = true;
|
|
|
|
QFileInfo info(filePath);
|
|
if (!info.exists())
|
|
return filePath;
|
|
|
|
const QString prefix = QStringLiteral("%1/%2").arg(info.absolutePath()).arg(info.baseName());
|
|
const QString ext = info.completeSuffix();
|
|
|
|
for (int i = 1; i < SafeFilePathLimit; ++i) {
|
|
QString safePath = QStringLiteral("%1 (%3).%4").arg(prefix).arg(i).arg(ext);
|
|
if (!QFileInfo::exists(safePath))
|
|
return safePath;
|
|
}
|
|
|
|
if (soFarSoGood)
|
|
*soFarSoGood = false;
|
|
|
|
return QString("");
|
|
}
|
|
std::shared_ptr<linphone::Address> Utils::getMatchingLocalAddress(std::shared_ptr<linphone::Address> p_localAddress){
|
|
QVector<std::shared_ptr<linphone::Address> > addresses;
|
|
// Get default account
|
|
addresses.push_back(CoreManager::getInstance()->getCore()->createPrimaryContactParsed());
|
|
auto accounts = CoreManager::getInstance()->getAccountList();
|
|
foreach(auto account, accounts)
|
|
addresses.push_back(account->getParams()->getIdentityAddress()->clone());
|
|
foreach(auto address, addresses){
|
|
if( address->getUsername() == p_localAddress->getUsername() && address->getDomain() ==
|
|
p_localAddress->getDomain()) return address;
|
|
}
|
|
return p_localAddress;
|
|
}
|
|
// Return at most : sip:username@domain
|
|
QString Utils::cleanSipAddress (const QString &sipAddress) {
|
|
std::shared_ptr<linphone::Address> addr = linphone::Factory::get()->createAddress(sipAddress.toStdString());
|
|
if( addr) {
|
|
addr->clean();
|
|
QStringList fields = Utils::coreStringToAppString(addr->asStringUriOnly()).split('@');
|
|
if(fields.size() > 0){// maybe useless but it's just to be sure to have a domain
|
|
fields.removeLast();
|
|
QString domain = Utils::coreStringToAppString(addr->getDomain());
|
|
if( domain.count(':')>1)
|
|
fields.append('['+domain+']');
|
|
else
|
|
fields.append(domain);
|
|
return fields.join('@');
|
|
}
|
|
}
|
|
return sipAddress;
|
|
}
|
|
// Data to retrieve WIN32 process
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
struct EnumData {
|
|
DWORD dwProcessId;
|
|
HWND hWnd;
|
|
};
|
|
// Application-defined callback for EnumWindows
|
|
BOOL CALLBACK EnumProc(HWND hWnd, LPARAM lParam) {
|
|
// Retrieve storage location for communication data
|
|
EnumData& ed = *(EnumData*)lParam;
|
|
DWORD dwProcessId = 0x0;
|
|
// Query process ID for hWnd
|
|
GetWindowThreadProcessId(hWnd, &dwProcessId);
|
|
// Apply filter - if you want to implement additional restrictions,
|
|
// this is the place to do so.
|
|
if (ed.dwProcessId == dwProcessId) {
|
|
// Found a window matching the process ID
|
|
ed.hWnd = hWnd;
|
|
// Report success
|
|
SetLastError(ERROR_SUCCESS);
|
|
// Stop enumeration
|
|
return FALSE;
|
|
}
|
|
// Continue enumeration
|
|
return TRUE;
|
|
}
|
|
// Main entry
|
|
HWND FindWindowFromProcessId(DWORD dwProcessId) {
|
|
EnumData ed = { dwProcessId };
|
|
if (!EnumWindows(EnumProc, (LPARAM)&ed) &&
|
|
(GetLastError() == ERROR_SUCCESS)) {
|
|
return ed.hWnd;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Helper method for convenience
|
|
HWND FindWindowFromProcess(HANDLE hProcess) {
|
|
return FindWindowFromProcessId(GetProcessId(hProcess));
|
|
}
|
|
#endif
|
|
|
|
bool Utils::processExists(const quint64& p_processId)
|
|
{
|
|
#ifdef _WIN32
|
|
return FindWindowFromProcessId(p_processId) != NULL;
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
QString Utils::getCountryName(const QLocale::Country& p_country)
|
|
{
|
|
QString countryName;
|
|
switch(p_country)
|
|
{
|
|
case QLocale::Afghanistan: if((countryName = QCoreApplication::translate("country", "Afghanistan"))==
|
|
"Afghanistan") countryName = "";break; case QLocale::Albania: if((countryName = QCoreApplication::translate("country",
|
|
"Albania"))== "Albania") countryName = "";break; case QLocale::Algeria: if((countryName =
|
|
QCoreApplication::translate("country", "Algeria"))== "Algeria") countryName = "";break; case QLocale::AmericanSamoa:
|
|
if((countryName = QCoreApplication::translate("country", "AmericanSamoa"))== "AmericanSamoa") countryName = "";break;
|
|
case QLocale::Andorra: if((countryName = QCoreApplication::translate("country", "Andorra"))== "Andorra")
|
|
countryName = "";break; case QLocale::Angola: if((countryName = QCoreApplication::translate("country", "Angola"))==
|
|
"Angola") countryName = "";break; case QLocale::Anguilla: if((countryName = QCoreApplication::translate("country",
|
|
"Anguilla"))== "Anguilla") countryName = "";break; case QLocale::AntiguaAndBarbuda: if((countryName =
|
|
QCoreApplication::translate("country", "AntiguaAndBarbuda"))== "AntiguaAndBarbuda") countryName = "";break; case
|
|
QLocale::Argentina: if((countryName = QCoreApplication::translate("country", "Argentina"))== "Argentina") countryName =
|
|
"";break; case QLocale::Armenia: if((countryName = QCoreApplication::translate("country", "Armenia"))== "Armenia")
|
|
countryName = "";break; case QLocale::Aruba: if((countryName = QCoreApplication::translate("country", "Aruba"))==
|
|
"Aruba") countryName = "";break; case QLocale::Australia: if((countryName = QCoreApplication::translate("country",
|
|
"Australia"))== "Australia") countryName = "";break; case QLocale::Austria: if((countryName =
|
|
QCoreApplication::translate("country", "Austria"))== "Austria") countryName = "";break; case QLocale::Azerbaijan:
|
|
if((countryName = QCoreApplication::translate("country", "Azerbaijan"))== "Azerbaijan") countryName = "";break; case
|
|
QLocale::Bahamas: if((countryName = QCoreApplication::translate("country", "Bahamas"))== "Bahamas") countryName =
|
|
"";break; case QLocale::Bahrain: if((countryName = QCoreApplication::translate("country", "Bahrain"))== "Bahrain")
|
|
countryName = "";break; case QLocale::Bangladesh: if((countryName = QCoreApplication::translate("country",
|
|
"Bangladesh"))== "Bangladesh") countryName = "";break; case QLocale::Barbados: if((countryName =
|
|
QCoreApplication::translate("country", "Barbados"))== "Barbados") countryName = "";break; case QLocale::Belarus:
|
|
if((countryName = QCoreApplication::translate("country", "Belarus"))== "Belarus") countryName = "";break; case
|
|
QLocale::Belgium: if((countryName = QCoreApplication::translate("country", "Belgium"))== "Belgium") countryName =
|
|
"";break; case QLocale::Belize: if((countryName = QCoreApplication::translate("country", "Belize"))== "Belize")
|
|
countryName = "";break; case QLocale::Benin: if((countryName = QCoreApplication::translate("country", "Benin"))==
|
|
"Benin") countryName = "";break; case QLocale::Bermuda: if((countryName = QCoreApplication::translate("country",
|
|
"Bermuda"))== "Bermuda") countryName = "";break; case QLocale::Bhutan: if((countryName =
|
|
QCoreApplication::translate("country", "Bhutan"))== "Bhutan") countryName = "";break; case QLocale::Bolivia:
|
|
if((countryName = QCoreApplication::translate("country", "Bolivia"))== "Bolivia") countryName = "";break; case
|
|
QLocale::BosniaAndHerzegowina: if((countryName = QCoreApplication::translate("country", "BosniaAndHerzegowina"))==
|
|
"BosniaAndHerzegowina") countryName = "";break; case QLocale::Botswana: if((countryName =
|
|
QCoreApplication::translate("country", "Botswana"))== "Botswana") countryName = "";break; case QLocale::Brazil:
|
|
if((countryName = QCoreApplication::translate("country", "Brazil"))== "Brazil") countryName = "";break; case
|
|
QLocale::Brunei: if((countryName = QCoreApplication::translate("country", "Brunei"))== "Brunei") countryName = "";break;
|
|
case QLocale::Bulgaria: if((countryName = QCoreApplication::translate("country", "Bulgaria"))== "Bulgaria")
|
|
countryName = "";break; case QLocale::BurkinaFaso: if((countryName = QCoreApplication::translate("country",
|
|
"BurkinaFaso"))== "BurkinaFaso") countryName = "";break; case QLocale::Burundi: if((countryName =
|
|
QCoreApplication::translate("country", "Burundi"))== "Burundi") countryName = "";break; case QLocale::Cambodia:
|
|
if((countryName = QCoreApplication::translate("country", "Cambodia"))== "Cambodia") countryName = "";break; case
|
|
QLocale::Cameroon: if((countryName = QCoreApplication::translate("country", "Cameroon"))== "Cameroon") countryName =
|
|
"";break; case QLocale::Canada: if((countryName = QCoreApplication::translate("country", "Canada"))== "Canada")
|
|
countryName = "";break; case QLocale::CapeVerde: if((countryName = QCoreApplication::translate("country",
|
|
"CapeVerde"))== "CapeVerde") countryName = "";break; case QLocale::CaymanIslands: if((countryName =
|
|
QCoreApplication::translate("country", "CaymanIslands"))== "CaymanIslands") countryName = "";break; case
|
|
QLocale::CentralAfricanRepublic: if((countryName = QCoreApplication::translate("country", "CentralAfricanRepublic"))==
|
|
"CentralAfricanRepublic") countryName = "";break; case QLocale::Chad: if((countryName =
|
|
QCoreApplication::translate("country", "Chad"))== "Chad") countryName = "";break; case QLocale::Chile: if((countryName =
|
|
QCoreApplication::translate("country", "Chile"))== "Chile") countryName = "";break; case QLocale::China: if((countryName
|
|
= QCoreApplication::translate("country", "China"))== "China") countryName = "";break; case QLocale::Colombia:
|
|
if((countryName = QCoreApplication::translate("country", "Colombia"))== "Colombia") countryName = "";break; case
|
|
QLocale::Comoros: if((countryName = QCoreApplication::translate("country", "Comoros"))== "Comoros") countryName =
|
|
"";break; case QLocale::PeoplesRepublicOfCongo: if((countryName = QCoreApplication::translate("country",
|
|
"PeoplesRepublicOfCongo"))== "PeoplesRepublicOfCongo") countryName = "";break; case QLocale::DemocraticRepublicOfCongo:
|
|
if((countryName = QCoreApplication::translate("country", "DemocraticRepublicOfCongo"))== "DemocraticRepublicOfCongo")
|
|
countryName = "";break; case QLocale::CookIslands: if((countryName = QCoreApplication::translate("country",
|
|
"CookIslands"))== "CookIslands") countryName = "";break; case QLocale::CostaRica: if((countryName =
|
|
QCoreApplication::translate("country", "CostaRica"))== "CostaRica") countryName = "";break; case QLocale::IvoryCoast:
|
|
if((countryName = QCoreApplication::translate("country", "IvoryCoast"))== "IvoryCoast") countryName = "";break; case
|
|
QLocale::Croatia: if((countryName = QCoreApplication::translate("country", "Croatia"))== "Croatia") countryName =
|
|
"";break; case QLocale::Cuba: if((countryName = QCoreApplication::translate("country", "Cuba"))== "Cuba") countryName =
|
|
"";break; case QLocale::Cyprus: if((countryName = QCoreApplication::translate("country", "Cyprus"))== "Cyprus")
|
|
countryName = "";break; case QLocale::CzechRepublic: if((countryName = QCoreApplication::translate("country",
|
|
"CzechRepublic"))== "CzechRepublic") countryName = "";break; case QLocale::Denmark: if((countryName =
|
|
QCoreApplication::translate("country", "Denmark"))== "Denmark") countryName = "";break; case QLocale::Djibouti:
|
|
if((countryName = QCoreApplication::translate("country", "Djibouti"))== "Djibouti") countryName = "";break; case
|
|
QLocale::Dominica: if((countryName = QCoreApplication::translate("country", "Dominica"))== "Dominica") countryName =
|
|
"";break; case QLocale::DominicanRepublic: if((countryName = QCoreApplication::translate("country",
|
|
"DominicanRepublic"))== "DominicanRepublic") countryName = "";break; case QLocale::Ecuador: if((countryName =
|
|
QCoreApplication::translate("country", "Ecuador"))== "Ecuador") countryName = "";break; case QLocale::Egypt:
|
|
if((countryName = QCoreApplication::translate("country", "Egypt"))== "Egypt") countryName = "";break; case
|
|
QLocale::ElSalvador: if((countryName = QCoreApplication::translate("country", "ElSalvador"))== "ElSalvador") countryName
|
|
= "";break; case QLocale::EquatorialGuinea: if((countryName = QCoreApplication::translate("country",
|
|
"EquatorialGuinea"))== "EquatorialGuinea") countryName = "";break; case QLocale::Eritrea: if((countryName =
|
|
QCoreApplication::translate("country", "Eritrea"))== "Eritrea") countryName = "";break; case QLocale::Estonia:
|
|
if((countryName = QCoreApplication::translate("country", "Estonia"))== "Estonia") countryName = "";break; case
|
|
QLocale::Ethiopia: if((countryName = QCoreApplication::translate("country", "Ethiopia"))== "Ethiopia") countryName =
|
|
"";break; case QLocale::FalklandIslands: if((countryName = QCoreApplication::translate("country", "FalklandIslands"))==
|
|
"FalklandIslands") countryName = "";break; case QLocale::FaroeIslands: if((countryName =
|
|
QCoreApplication::translate("country", "FaroeIslands"))== "FaroeIslands") countryName = "";break; case QLocale::Fiji:
|
|
if((countryName = QCoreApplication::translate("country", "Fiji"))== "Fiji") countryName = "";break; case
|
|
QLocale::Finland: if((countryName = QCoreApplication::translate("country", "Finland"))== "Finland") countryName =
|
|
"";break; case QLocale::France: if((countryName = QCoreApplication::translate("country", "France"))== "France")
|
|
countryName = "";break; case QLocale::FrenchGuiana: if((countryName = QCoreApplication::translate("country",
|
|
"FrenchGuiana"))== "FrenchGuiana") countryName = "";break; case QLocale::FrenchPolynesia: if((countryName =
|
|
QCoreApplication::translate("country", "FrenchPolynesia"))== "FrenchPolynesia") countryName = "";break; case
|
|
QLocale::Gabon: if((countryName = QCoreApplication::translate("country", "Gabon"))== "Gabon") countryName = "";break;
|
|
case QLocale::Gambia: if((countryName = QCoreApplication::translate("country", "Gambia"))== "Gambia")
|
|
countryName = "";break; case QLocale::Georgia: if((countryName = QCoreApplication::translate("country", "Georgia"))==
|
|
"Georgia") countryName = "";break; case QLocale::Germany: if((countryName = QCoreApplication::translate("country",
|
|
"Germany"))== "Germany") countryName = "";break; case QLocale::Ghana: if((countryName =
|
|
QCoreApplication::translate("country", "Ghana"))== "Ghana") countryName = "";break; case QLocale::Gibraltar:
|
|
if((countryName = QCoreApplication::translate("country", "Gibraltar"))== "Gibraltar") countryName = "";break; case
|
|
QLocale::Greece: if((countryName = QCoreApplication::translate("country", "Greece"))== "Greece") countryName = "";break;
|
|
case QLocale::Greenland: if((countryName = QCoreApplication::translate("country", "Greenland"))== "Greenland")
|
|
countryName = "";break; case QLocale::Grenada: if((countryName = QCoreApplication::translate("country", "Grenada"))==
|
|
"Grenada") countryName = "";break; case QLocale::Guadeloupe: if((countryName = QCoreApplication::translate("country",
|
|
"Guadeloupe"))== "Guadeloupe") countryName = "";break; case QLocale::Guam: if((countryName =
|
|
QCoreApplication::translate("country", "Guam"))== "Guam") countryName = "";break; case QLocale::Guatemala:
|
|
if((countryName = QCoreApplication::translate("country", "Guatemala"))== "Guatemala") countryName = "";break; case
|
|
QLocale::Guinea: if((countryName = QCoreApplication::translate("country", "Guinea"))== "Guinea") countryName = "";break;
|
|
case QLocale::GuineaBissau: if((countryName = QCoreApplication::translate("country", "GuineaBissau"))==
|
|
"GuineaBissau") countryName = "";break; case QLocale::Guyana: if((countryName = QCoreApplication::translate("country",
|
|
"Guyana"))== "Guyana") countryName = "";break; case QLocale::Haiti: if((countryName =
|
|
QCoreApplication::translate("country", "Haiti"))== "Haiti") countryName = "";break; case QLocale::Honduras:
|
|
if((countryName = QCoreApplication::translate("country", "Honduras"))== "Honduras") countryName = "";break; case
|
|
QLocale::HongKong: if((countryName = QCoreApplication::translate("country", "HongKong"))== "HongKong") countryName =
|
|
"";break; case QLocale::Hungary: if((countryName = QCoreApplication::translate("country", "Hungary"))== "Hungary")
|
|
countryName = "";break; case QLocale::Iceland: if((countryName = QCoreApplication::translate("country", "Iceland"))==
|
|
"Iceland") countryName = "";break; case QLocale::India: if((countryName = QCoreApplication::translate("country",
|
|
"India"))== "India") countryName = "";break; case QLocale::Indonesia: if((countryName =
|
|
QCoreApplication::translate("country", "Indonesia"))== "Indonesia") countryName = "";break; case QLocale::Iran:
|
|
if((countryName = QCoreApplication::translate("country", "Iran"))== "Iran") countryName = "";break; case QLocale::Iraq:
|
|
if((countryName = QCoreApplication::translate("country", "Iraq"))== "Iraq") countryName = "";break; case
|
|
QLocale::Ireland: if((countryName = QCoreApplication::translate("country", "Ireland"))== "Ireland") countryName =
|
|
"";break; case QLocale::Israel: if((countryName = QCoreApplication::translate("country", "Israel"))== "Israel")
|
|
countryName = "";break; case QLocale::Italy: if((countryName = QCoreApplication::translate("country", "Italy"))==
|
|
"Italy") countryName = "";break; case QLocale::Jamaica: if((countryName = QCoreApplication::translate("country",
|
|
"Jamaica"))== "Jamaica") countryName = "";break; case QLocale::Japan: if((countryName =
|
|
QCoreApplication::translate("country", "Japan"))== "Japan") countryName = "";break; case QLocale::Jordan:
|
|
if((countryName = QCoreApplication::translate("country", "Jordan"))== "Jordan") countryName = "";break; case
|
|
QLocale::Kazakhstan: if((countryName = QCoreApplication::translate("country", "Kazakhstan"))== "Kazakhstan") countryName
|
|
= "";break; case QLocale::Kenya: if((countryName = QCoreApplication::translate("country", "Kenya"))== "Kenya")
|
|
countryName = "";break; case QLocale::Kiribati: if((countryName = QCoreApplication::translate("country", "Kiribati"))==
|
|
"Kiribati") countryName = "";break; case QLocale::DemocraticRepublicOfKorea: if((countryName =
|
|
QCoreApplication::translate("country", "DemocraticRepublicOfKorea"))== "DemocraticRepublicOfKorea") countryName =
|
|
"";break; case QLocale::RepublicOfKorea: if((countryName = QCoreApplication::translate("country", "RepublicOfKorea"))==
|
|
"RepublicOfKorea") countryName = "";break; case QLocale::Kuwait: if((countryName =
|
|
QCoreApplication::translate("country", "Kuwait"))== "Kuwait") countryName = "";break; case QLocale::Kyrgyzstan:
|
|
if((countryName = QCoreApplication::translate("country", "Kyrgyzstan"))== "Kyrgyzstan") countryName = "";break; case
|
|
QLocale::Laos: if((countryName = QCoreApplication::translate("country", "Laos"))== "Laos") countryName = "";break; case
|
|
QLocale::Latvia: if((countryName = QCoreApplication::translate("country", "Latvia"))== "Latvia") countryName = "";break;
|
|
case QLocale::Lebanon: if((countryName = QCoreApplication::translate("country", "Lebanon"))== "Lebanon")
|
|
countryName = "";break; case QLocale::Lesotho: if((countryName = QCoreApplication::translate("country", "Lesotho"))==
|
|
"Lesotho") countryName = "";break; case QLocale::Liberia: if((countryName = QCoreApplication::translate("country",
|
|
"Liberia"))== "Liberia") countryName = "";break; case QLocale::Libya: if((countryName =
|
|
QCoreApplication::translate("country", "Libya"))== "Libya") countryName = "";break; case QLocale::Liechtenstein:
|
|
if((countryName = QCoreApplication::translate("country", "Liechtenstein"))== "Liechtenstein") countryName = "";break;
|
|
case QLocale::Lithuania: if((countryName = QCoreApplication::translate("country", "Lithuania"))== "Lithuania")
|
|
countryName = "";break; case QLocale::Luxembourg: if((countryName = QCoreApplication::translate("country",
|
|
"Luxembourg"))== "Luxembourg") countryName = "";break; case QLocale::Macau: if((countryName =
|
|
QCoreApplication::translate("country", "Macau"))== "Macau") countryName = "";break; case QLocale::Macedonia:
|
|
if((countryName = QCoreApplication::translate("country", "Macedonia"))== "Macedonia") countryName = "";break; case
|
|
QLocale::Madagascar: if((countryName = QCoreApplication::translate("country", "Madagascar"))== "Madagascar") countryName
|
|
= "";break; case QLocale::Malawi: if((countryName = QCoreApplication::translate("country", "Malawi"))== "Malawi")
|
|
countryName = "";break; case QLocale::Malaysia: if((countryName = QCoreApplication::translate("country", "Malaysia"))==
|
|
"Malaysia") countryName = "";break; case QLocale::Maldives: if((countryName = QCoreApplication::translate("country",
|
|
"Maldives"))== "Maldives") countryName = "";break; case QLocale::Mali: if((countryName =
|
|
QCoreApplication::translate("country", "Mali"))== "Mali") countryName = "";break; case QLocale::Malta: if((countryName =
|
|
QCoreApplication::translate("country", "Malta"))== "Malta") countryName = "";break; case QLocale::MarshallIslands:
|
|
if((countryName = QCoreApplication::translate("country", "MarshallIslands"))== "MarshallIslands") countryName =
|
|
"";break; case QLocale::Martinique: if((countryName = QCoreApplication::translate("country", "Martinique"))==
|
|
"Martinique") countryName = "";break; case QLocale::Mauritania: if((countryName = QCoreApplication::translate("country",
|
|
"Mauritania"))== "Mauritania") countryName = "";break; case QLocale::Mauritius: if((countryName =
|
|
QCoreApplication::translate("country", "Mauritius"))== "Mauritius") countryName = "";break; case QLocale::Mayotte:
|
|
if((countryName = QCoreApplication::translate("country", "Mayotte"))== "Mayotte") countryName = "";break; case
|
|
QLocale::Mexico: if((countryName = QCoreApplication::translate("country", "Mexico"))== "Mexico") countryName = "";break;
|
|
case QLocale::Micronesia: if((countryName = QCoreApplication::translate("country", "Micronesia"))==
|
|
"Micronesia") countryName = "";break; case QLocale::Moldova: if((countryName = QCoreApplication::translate("country",
|
|
"Moldova"))== "Moldova") countryName = "";break; case QLocale::Monaco: if((countryName =
|
|
QCoreApplication::translate("country", "Monaco"))== "Monaco") countryName = "";break; case QLocale::Mongolia:
|
|
if((countryName = QCoreApplication::translate("country", "Mongolia"))== "Mongolia") countryName = "";break; case
|
|
QLocale::Montenegro: if((countryName = QCoreApplication::translate("country", "Montenegro"))== "Montenegro") countryName
|
|
= "";break; case QLocale::Montserrat: if((countryName = QCoreApplication::translate("country", "Montserrat"))==
|
|
"Montserrat") countryName = "";break; case QLocale::Morocco: if((countryName = QCoreApplication::translate("country",
|
|
"Morocco"))== "Morocco") countryName = "";break; case QLocale::Mozambique: if((countryName =
|
|
QCoreApplication::translate("country", "Mozambique"))== "Mozambique") countryName = "";break; case QLocale::Myanmar:
|
|
if((countryName = QCoreApplication::translate("country", "Myanmar"))== "Myanmar") countryName = "";break; case
|
|
QLocale::Namibia: if((countryName = QCoreApplication::translate("country", "Namibia"))== "Namibia") countryName =
|
|
"";break; case QLocale::NauruCountry: if((countryName = QCoreApplication::translate("country", "NauruCountry"))==
|
|
"NauruCountry") countryName = "";break; case QLocale::Nepal: if((countryName = QCoreApplication::translate("country",
|
|
"Nepal"))== "Nepal") countryName = "";break; case QLocale::Netherlands: if((countryName =
|
|
QCoreApplication::translate("country", "Netherlands"))== "Netherlands") countryName = "";break; case
|
|
QLocale::NewCaledonia: if((countryName = QCoreApplication::translate("country", "NewCaledonia"))== "NewCaledonia")
|
|
countryName = "";break; case QLocale::NewZealand: if((countryName = QCoreApplication::translate("country",
|
|
"NewZealand"))== "NewZealand") countryName = "";break; case QLocale::Nicaragua: if((countryName =
|
|
QCoreApplication::translate("country", "Nicaragua"))== "Nicaragua") countryName = "";break; case QLocale::Niger:
|
|
if((countryName = QCoreApplication::translate("country", "Niger"))== "Niger") countryName = "";break; case
|
|
QLocale::Nigeria: if((countryName = QCoreApplication::translate("country", "Nigeria"))== "Nigeria") countryName =
|
|
"";break; case QLocale::Niue: if((countryName = QCoreApplication::translate("country", "Niue"))== "Niue") countryName =
|
|
"";break; case QLocale::NorfolkIsland: if((countryName = QCoreApplication::translate("country", "NorfolkIsland"))==
|
|
"NorfolkIsland") countryName = "";break; case QLocale::NorthernMarianaIslands: if((countryName =
|
|
QCoreApplication::translate("country", "NorthernMarianaIslands"))== "NorthernMarianaIslands") countryName = "";break;
|
|
case QLocale::Norway: if((countryName = QCoreApplication::translate("country", "Norway"))== "Norway")
|
|
countryName = "";break; case QLocale::Oman: if((countryName = QCoreApplication::translate("country", "Oman"))== "Oman")
|
|
countryName = "";break; case QLocale::Pakistan: if((countryName = QCoreApplication::translate("country", "Pakistan"))==
|
|
"Pakistan") countryName = "";break; case QLocale::Palau: if((countryName = QCoreApplication::translate("country",
|
|
"Palau"))== "Palau") countryName = "";break; case QLocale::PalestinianTerritories: if((countryName =
|
|
QCoreApplication::translate("country", "PalestinianTerritories"))== "PalestinianTerritories") countryName = "";break;
|
|
case QLocale::Panama: if((countryName = QCoreApplication::translate("country", "Panama"))== "Panama")
|
|
countryName = "";break; case QLocale::PapuaNewGuinea: if((countryName = QCoreApplication::translate("country",
|
|
"PapuaNewGuinea"))== "PapuaNewGuinea") countryName = "";break; case QLocale::Paraguay: if((countryName =
|
|
QCoreApplication::translate("country", "Paraguay"))== "Paraguay") countryName = "";break; case QLocale::Peru:
|
|
if((countryName = QCoreApplication::translate("country", "Peru"))== "Peru") countryName = "";break; case
|
|
QLocale::Philippines: if((countryName = QCoreApplication::translate("country", "Philippines"))== "Philippines")
|
|
countryName = "";break; case QLocale::Poland: if((countryName = QCoreApplication::translate("country", "Poland"))==
|
|
"Poland") countryName = "";break; case QLocale::Portugal: if((countryName = QCoreApplication::translate("country",
|
|
"Portugal"))== "Portugal") countryName = "";break; case QLocale::PuertoRico: if((countryName =
|
|
QCoreApplication::translate("country", "PuertoRico"))== "PuertoRico") countryName = "";break; case QLocale::Qatar:
|
|
if((countryName = QCoreApplication::translate("country", "Qatar"))== "Qatar") countryName = "";break; case
|
|
QLocale::Reunion: if((countryName = QCoreApplication::translate("country", "Reunion"))== "Reunion") countryName =
|
|
"";break; case QLocale::Romania: if((countryName = QCoreApplication::translate("country", "Romania"))== "Romania")
|
|
countryName = "";break; case QLocale::RussianFederation: if((countryName = QCoreApplication::translate("country",
|
|
"RussianFederation"))== "RussianFederation") countryName = "";break; case QLocale::Rwanda: if((countryName =
|
|
QCoreApplication::translate("country", "Rwanda"))== "Rwanda") countryName = "";break; case QLocale::SaintHelena:
|
|
if((countryName = QCoreApplication::translate("country", "SaintHelena"))== "SaintHelena") countryName = "";break; case
|
|
QLocale::SaintKittsAndNevis: if((countryName = QCoreApplication::translate("country", "SaintKittsAndNevis"))==
|
|
"SaintKittsAndNevis") countryName = "";break; case QLocale::SaintLucia: if((countryName =
|
|
QCoreApplication::translate("country", "SaintLucia"))== "SaintLucia") countryName = "";break; case
|
|
QLocale::SaintPierreAndMiquelon: if((countryName = QCoreApplication::translate("country", "SaintPierreAndMiquelon"))==
|
|
"SaintPierreAndMiquelon") countryName = "";break; case QLocale::SaintVincentAndTheGrenadines: if((countryName =
|
|
QCoreApplication::translate("country", "SaintVincentAndTheGrenadines"))== "SaintVincentAndTheGrenadines") countryName =
|
|
"";break; case QLocale::Samoa: if((countryName = QCoreApplication::translate("country", "Samoa"))== "Samoa") countryName
|
|
= "";break; case QLocale::SanMarino: if((countryName = QCoreApplication::translate("country", "SanMarino"))==
|
|
"SanMarino") countryName = "";break; case QLocale::SaoTomeAndPrincipe: if((countryName =
|
|
QCoreApplication::translate("country", "SaoTomeAndPrincipe"))== "SaoTomeAndPrincipe") countryName = "";break; case
|
|
QLocale::SaudiArabia: if((countryName = QCoreApplication::translate("country", "SaudiArabia"))== "SaudiArabia")
|
|
countryName = "";break; case QLocale::Senegal: if((countryName = QCoreApplication::translate("country", "Senegal"))==
|
|
"Senegal") countryName = "";break; case QLocale::Serbia: if((countryName = QCoreApplication::translate("country",
|
|
"Serbia"))== "Serbia") countryName = "";break; case QLocale::Seychelles: if((countryName =
|
|
QCoreApplication::translate("country", "Seychelles"))== "Seychelles") countryName = "";break; case QLocale::SierraLeone:
|
|
if((countryName = QCoreApplication::translate("country", "SierraLeone"))== "SierraLeone") countryName = "";break; case
|
|
QLocale::Singapore: if((countryName = QCoreApplication::translate("country", "Singapore"))== "Singapore") countryName =
|
|
"";break; case QLocale::Slovakia: if((countryName = QCoreApplication::translate("country", "Slovakia"))== "Slovakia")
|
|
countryName = "";break; case QLocale::Slovenia: if((countryName = QCoreApplication::translate("country", "Slovenia"))==
|
|
"Slovenia") countryName = "";break; case QLocale::SolomonIslands: if((countryName =
|
|
QCoreApplication::translate("country", "SolomonIslands"))== "SolomonIslands") countryName = "";break; case
|
|
QLocale::Somalia: if((countryName = QCoreApplication::translate("country", "Somalia"))== "Somalia") countryName =
|
|
"";break; case QLocale::SouthAfrica: if((countryName = QCoreApplication::translate("country", "SouthAfrica"))==
|
|
"SouthAfrica") countryName = "";break; case QLocale::Spain: if((countryName = QCoreApplication::translate("country",
|
|
"Spain"))== "Spain") countryName = "";break; case QLocale::SriLanka: if((countryName =
|
|
QCoreApplication::translate("country", "SriLanka"))== "SriLanka") countryName = "";break; case QLocale::Sudan:
|
|
if((countryName = QCoreApplication::translate("country", "Sudan"))== "Sudan") countryName = "";break; case
|
|
QLocale::Suriname: if((countryName = QCoreApplication::translate("country", "Suriname"))== "Suriname") countryName =
|
|
"";break; case QLocale::Swaziland: if((countryName = QCoreApplication::translate("country", "Swaziland"))== "Swaziland")
|
|
countryName = "";break; case QLocale::Sweden: if((countryName = QCoreApplication::translate("country", "Sweden"))==
|
|
"Sweden") countryName = "";break; case QLocale::Switzerland: if((countryName = QCoreApplication::translate("country",
|
|
"Switzerland"))== "Switzerland") countryName = "";break; case QLocale::Syria: if((countryName =
|
|
QCoreApplication::translate("country", "Syria"))== "Syria") countryName = "";break; case QLocale::Taiwan:
|
|
if((countryName = QCoreApplication::translate("country", "Taiwan"))== "Taiwan") countryName = "";break; case
|
|
QLocale::Tajikistan: if((countryName = QCoreApplication::translate("country", "Tajikistan"))== "Tajikistan") countryName
|
|
= "";break; case QLocale::Tanzania: if((countryName = QCoreApplication::translate("country", "Tanzania"))== "Tanzania")
|
|
countryName = "";break; case QLocale::Thailand: if((countryName = QCoreApplication::translate("country", "Thailand"))==
|
|
"Thailand") countryName = "";break; case QLocale::Togo: if((countryName = QCoreApplication::translate("country",
|
|
"Togo"))== "Togo") countryName = "";break; case QLocale::Tokelau: if((countryName =
|
|
QCoreApplication::translate("country", "Tokelau"))== "Tokelau") countryName = "";break; case QLocale::Tonga:
|
|
if((countryName = QCoreApplication::translate("country", "Tonga"))== "Tonga") countryName = "";break; case
|
|
QLocale::TrinidadAndTobago: if((countryName = QCoreApplication::translate("country", "TrinidadAndTobago"))==
|
|
"TrinidadAndTobago") countryName = "";break; case QLocale::Tunisia: if((countryName =
|
|
QCoreApplication::translate("country", "Tunisia"))== "Tunisia") countryName = "";break; case QLocale::Turkey:
|
|
if((countryName = QCoreApplication::translate("country", "Turkey"))== "Turkey") countryName = "";break; case
|
|
QLocale::Turkmenistan: if((countryName = QCoreApplication::translate("country", "Turkmenistan"))== "Turkmenistan")
|
|
countryName = "";break; case QLocale::TurksAndCaicosIslands: if((countryName = QCoreApplication::translate("country",
|
|
"TurksAndCaicosIslands"))== "TurksAndCaicosIslands") countryName = "";break; case QLocale::Tuvalu: if((countryName =
|
|
QCoreApplication::translate("country", "Tuvalu"))== "Tuvalu") countryName = "";break; case QLocale::Uganda:
|
|
if((countryName = QCoreApplication::translate("country", "Uganda"))== "Uganda") countryName = "";break; case
|
|
QLocale::Ukraine: if((countryName = QCoreApplication::translate("country", "Ukraine"))== "Ukraine") countryName =
|
|
"";break; case QLocale::UnitedArabEmirates: if((countryName = QCoreApplication::translate("country",
|
|
"UnitedArabEmirates"))== "UnitedArabEmirates") countryName = "";break; case QLocale::UnitedKingdom: if((countryName =
|
|
QCoreApplication::translate("country", "UnitedKingdom"))== "UnitedKingdom") countryName = "";break; case
|
|
QLocale::UnitedStates: if((countryName = QCoreApplication::translate("country", "UnitedStates"))== "UnitedStates")
|
|
countryName = "";break; case QLocale::Uruguay: if((countryName = QCoreApplication::translate("country", "Uruguay"))==
|
|
"Uruguay") countryName = "";break; case QLocale::Uzbekistan: if((countryName = QCoreApplication::translate("country",
|
|
"Uzbekistan"))== "Uzbekistan") countryName = "";break; case QLocale::Vanuatu: if((countryName =
|
|
QCoreApplication::translate("country", "Vanuatu"))== "Vanuatu") countryName = "";break; case QLocale::Venezuela:
|
|
if((countryName = QCoreApplication::translate("country", "Venezuela"))== "Venezuela") countryName = "";break; case
|
|
QLocale::Vietnam: if((countryName = QCoreApplication::translate("country", "Vietnam"))== "Vietnam") countryName =
|
|
"";break; case QLocale::WallisAndFutunaIslands: if((countryName = QCoreApplication::translate("country",
|
|
"WallisAndFutunaIslands"))== "WallisAndFutunaIslands") countryName = "";break; case QLocale::Yemen: if((countryName =
|
|
QCoreApplication::translate("country", "Yemen"))== "Yemen") countryName = "";break; case QLocale::Zambia:
|
|
if((countryName = QCoreApplication::translate("country", "Zambia"))== "Zambia") countryName = "";break; case
|
|
QLocale::Zimbabwe: if((countryName = QCoreApplication::translate("country", "Zimbabwe"))== "Zimbabwe") countryName =
|
|
"";break; default: { countryName = QLocale::countryToString(p_country);
|
|
}
|
|
}
|
|
if( countryName == "")
|
|
countryName = QLocale::countryToString(p_country);
|
|
return countryName;
|
|
}
|
|
// Copy a folder recursively without erasing old file
|
|
void Utils::copyDir(QString from, QString to) {
|
|
QDir dir;
|
|
dir.setPath(from);
|
|
from += QDir::separator();
|
|
to += QDir::separator();
|
|
foreach (QString copyFile, dir.entryList(QDir::Files)) {// Copy each files
|
|
QString toFile = to + copyFile;
|
|
if (!QFile::exists(toFile))
|
|
QFile::copy(from+copyFile, toFile);
|
|
}
|
|
foreach (QString nextDir, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {// Copy folder
|
|
QString toDir = to + nextDir;
|
|
QDir().mkpath(toDir);// no need to check if dir exists
|
|
copyDir(from + nextDir, toDir);//Go up
|
|
}
|
|
}
|
|
|
|
QString Utils::getDisplayName(const std::shared_ptr<const linphone::Address>& address){
|
|
QString displayName;
|
|
if(address){
|
|
displayName = CoreManager::getInstance()->getSipAddressesModel()->getDisplayName(address);
|
|
}
|
|
return displayName;
|
|
}
|
|
|
|
std::shared_ptr<linphone::Config> Utils::getConfigIfExists (const QString &configPath) {
|
|
std::string factoryPath(Paths::getFactoryConfigFilePath());
|
|
if (!Paths::filePathExists(factoryPath))
|
|
factoryPath.clear();
|
|
|
|
return linphone::Config::newWithFactory(configPath.toStdString(), factoryPath);
|
|
}
|
|
|
|
QString Utils::getApplicationProduct(){
|
|
// Note: Keep '-' as a separator between application name and application type
|
|
return QString(APPLICATION_NAME"-Desktop").remove(' ')+"/"+QCoreApplication::applicationVersion();
|
|
}
|
|
|
|
QString Utils::getOsProduct(){
|
|
QString version = QSysInfo::productVersion().remove(' ');// A version can be "Server 2016" (for Windows Server 2016)
|
|
QString product = QSysInfo::productType().replace(' ', '-'); // Just in case
|
|
return product+"/"+version;
|
|
}
|
|
|
|
QString Utils::computeUserAgent(const std::shared_ptr<linphone::Config>& config){
|
|
return QStringLiteral("%1 (%2) %3 Qt/%4 LinphoneSDK")
|
|
.arg(Utils::getApplicationProduct())
|
|
.arg(SettingsModel::getDeviceName(config)
|
|
.replace('\\', "\\\\")
|
|
.replace('(', "\\(")
|
|
.replace(')', "\\)")
|
|
)
|
|
.arg(Utils::getOsProduct())
|
|
.arg(qVersion());
|
|
}
|
|
|
|
bool Utils::isMe(const QString& address){
|
|
return !address.isEmpty() ?
|
|
CoreManager::getInstance()->getAccountSettingsModel()->getUsedSipAddress()->weakEqual(Utils::interpretUrl(address)) :
|
|
false;
|
|
}
|
|
|
|
bool Utils::isMe(const std::shared_ptr<const linphone::Address>& address){
|
|
return address ? CoreManager::getInstance()->getAccountSettingsModel()->getUsedSipAddress()->weakEqual(address) :
|
|
false;
|
|
}
|
|
|
|
bool Utils::isAnimatedImage(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
QFileInfo info(path);
|
|
if( !info.exists() || !QMimeDatabase().mimeTypeForFile(info).name().contains("image/"))
|
|
return false;
|
|
QImageReader reader(path);
|
|
return reader.canRead() && reader.supportsAnimation() && reader.imageCount() > 1;
|
|
}
|
|
|
|
bool Utils::isImage(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
QFileInfo info(path);
|
|
if( !info.exists() || CoreManager::getInstance()->getSettingsModel()->getVfsEncrypted()){
|
|
return QMimeDatabase().mimeTypeForFile(info, QMimeDatabase::MatchExtension).name().contains("image/");
|
|
}else if(!QMimeDatabase().mimeTypeForFile(info).name().contains("image/"))
|
|
return false;
|
|
QImageReader reader(path);
|
|
return reader.canRead() && reader.imageCount() == 1;
|
|
}
|
|
|
|
bool Utils::isVideo(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
return QMimeDatabase().mimeTypeForFile(path).name().contains("video/");
|
|
}
|
|
|
|
bool Utils::isPdf(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
return QMimeDatabase().mimeTypeForFile(path).name().contains("application/pdf");
|
|
}
|
|
|
|
bool Utils::isSupportedForDisplay(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
return !QMimeDatabase().mimeTypeForFile(path).name().contains("application");// "for pdf : "application/pdf". Note :
|
|
Make an exception when supported.
|
|
}
|
|
|
|
bool Utils::canHaveThumbnail(const QString& path){
|
|
if(path.isEmpty()) return false;
|
|
return isImage(path) || isAnimatedImage(path) || isPdf(path) || isVideo(path);
|
|
}
|
|
|
|
bool Utils::isPhoneNumber(const QString& txt){
|
|
auto core = CoreManager::getInstance()->getCore();
|
|
if(!core)
|
|
return false;
|
|
auto account = core->getDefaultAccount();
|
|
return account && account->isPhoneNumber(Utils::appStringToCoreString(txt));
|
|
}
|
|
|
|
bool Utils::isUsername(const QString& txt){
|
|
QRegularExpression regex("^(<?sips?:)?[a-zA-Z0-9+_.\\-]+>?$");
|
|
QRegularExpressionMatch match = regex.match(txt);
|
|
return match.hasMatch(); // true
|
|
}
|
|
|
|
bool Utils::isValidUrl(const QString& url){
|
|
return QUrl(url).isValid();
|
|
}
|
|
|
|
QSize Utils::getImageSize(const QString& url){
|
|
QString path;
|
|
QUrl urlDecode(url);
|
|
if(urlDecode.isLocalFile())
|
|
path = QDir::toNativeSeparators(urlDecode.toLocalFile());
|
|
else
|
|
path = url;
|
|
QFileInfo info(path);
|
|
if( !info.exists())
|
|
return QSize(0,0);
|
|
QImageReader reader(path);
|
|
QSize s = reader.size();
|
|
if( s.isValid())
|
|
return s;
|
|
else
|
|
return QSize(0,0);
|
|
}
|
|
|
|
QPoint Utils::getCursorPosition(){
|
|
return QCursor::pos();
|
|
}
|
|
|
|
QString Utils::getFileChecksum(const QString& filePath){
|
|
QFile file(filePath);
|
|
if (file.open(QFile::ReadOnly)) {
|
|
QCryptographicHash hash(QCryptographicHash::Sha256);
|
|
if (hash.addData(&file)) {
|
|
return hash.result().toHex();
|
|
}
|
|
}
|
|
return QString();
|
|
}
|
|
bool Utils::codepointIsEmoji(uint code){
|
|
return (code >= 0x2600 && code <= 0x27bf) || (code >= 0x2b00 && code <= 0x2bff) ||
|
|
(code >= 0x1f000 && code <= 0x1faff) || code == 0x200d || code == 0xfe0f;
|
|
}
|
|
|
|
bool Utils::codepointIsVisible(uint code) {
|
|
return code > 0x00020;
|
|
}
|
|
|
|
QString Utils::encodeEmojiToQmlRichFormat(const QString &body){
|
|
QString fmtBody = "";
|
|
QVector<uint> utf32_string = body.toUcs4();
|
|
|
|
bool insideFontBlock = false;
|
|
for (auto &code : utf32_string) {
|
|
if (Utils::codepointIsEmoji(code)) {
|
|
if (!insideFontBlock) {
|
|
fmtBody += QString("<font face=\"" +
|
|
CoreManager::getInstance()->getSettingsModel()->getEmojiFont().family() + "\">");
|
|
insideFontBlock = true;
|
|
}
|
|
} else {
|
|
if (insideFontBlock) {
|
|
fmtBody += "</font>";
|
|
insideFontBlock = false;
|
|
}
|
|
}
|
|
fmtBody += QString::fromUcs4(&code, 1);
|
|
}
|
|
if (insideFontBlock) {
|
|
fmtBody += "</font>";
|
|
}
|
|
return fmtBody;
|
|
}
|
|
|
|
bool Utils::isOnlyEmojis(const QString& text){
|
|
if(text.isEmpty()) return false;
|
|
QVector<uint> utf32_string = text.toUcs4();
|
|
for (auto &code : utf32_string)
|
|
if(codepointIsVisible(code) && !Utils::codepointIsEmoji(code))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
QString Utils::encodeTextToQmlRichFormat(const QString& text, const QVariantMap& options){
|
|
//QString images;
|
|
//QStringList imageFormat;
|
|
//for(auto format : QImageReader::supportedImageFormats())
|
|
// imageFormat.append(QString::fromLatin1(format).toUpper());
|
|
|
|
QStringList formattedText;
|
|
bool lastWasUrl = false;
|
|
|
|
if(options.contains("noLink") && options["noLink"].toBool()){
|
|
formattedText.append(encodeEmojiToQmlRichFormat(text));
|
|
}else{
|
|
auto primaryColor = App::getInstance()->getColorListModel()->getColor("i")->getColor();
|
|
auto iriParsed = UriTools::parseIri(text);
|
|
|
|
for(int i = 0 ; i < iriParsed.size() ; ++i){
|
|
QString iri = iriParsed[i].second.replace('&', "&")
|
|
.replace('<', "\u2063<")
|
|
.replace('>', "\u2063>")
|
|
.replace('"', """)
|
|
.replace('\'', "'");
|
|
if(!iriParsed[i].first){
|
|
if(lastWasUrl){
|
|
lastWasUrl = false;
|
|
if(iri.front() != ' ')
|
|
iri.push_front(' ');
|
|
}
|
|
formattedText.append(encodeEmojiToQmlRichFormat(iri));
|
|
}else{
|
|
QString uri = iriParsed[i].second.left(3) == "www" ? "http://"+iriParsed[i].second : iriParsed[i].second
|
|
;
|
|
/* TODO : preview from link
|
|
//int extIndex = iriParsed[i].second.lastIndexOf('.');
|
|
//QString ext;
|
|
//if( extIndex >= 0)
|
|
// ext = iriParsed[i].second.mid(extIndex+1).toUpper();
|
|
//if(imageFormat.contains(ext.toLatin1())){// imagesHeight is not used because of bugs on display (blank
|
|
image if set without width)
|
|
// images += "<a href=\"" + uri + "\"><img" + (
|
|
// options.contains("imagesWidth")
|
|
// ? QString(" width='") + options["imagesWidth"].toString() + "'"
|
|
// : ""
|
|
// ) + (
|
|
// options.contains("imagesWidth")
|
|
// ? QString(" height='auto'")
|
|
// : ""
|
|
// ) + " src=\"" + iriParsed[i].second + "\" />"+uri+"</a>";
|
|
//}else{
|
|
formattedText.append( "<a style=\"color:"+ primaryColor.name() +";\" href=\"" + uri + "\">" + iri +
|
|
"</a>"); lastWasUrl = true;
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
if(lastWasUrl && formattedText.last().back() != ' '){
|
|
formattedText.push_back(" ");
|
|
}
|
|
return "<p style=\"white-space:pre-wrap;\">" + formattedText.join("") + "</p>";
|
|
}
|
|
|
|
QString Utils::getFileContent(const QString& filePath){
|
|
QString contents;
|
|
QFile file(filePath);
|
|
if (!file.open(QFile::ReadOnly | QFile::Text))
|
|
return "";
|
|
return file.readAll();
|
|
}
|
|
static QStringList gDbPaths;
|
|
|
|
void Utils::deleteAllUserData(){
|
|
// Store usable data like custom folders
|
|
gDbPaths.clear();
|
|
gDbPaths.append(Utils::coreStringToAppString(linphone::Factory::get()->getDataDir(nullptr)));
|
|
gDbPaths.append(Utils::coreStringToAppString(linphone::Factory::get()->getConfigDir(nullptr)));
|
|
// Exit with a delete code
|
|
App::getInstance()->exit(App::DeleteDataCode);
|
|
}
|
|
|
|
void Utils::deleteAllUserDataOffline(){
|
|
qWarning() << "Deleting all data! ";
|
|
for(int i = 0 ; i < gDbPaths.size() ; ++i){
|
|
QDir dir(gDbPaths[i]);
|
|
qWarning() << "Deleting " << gDbPaths[i] << " : " << (dir.removeRecursively() ? "Successfully" : "Failed");
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------
|
|
// WIDGETS
|
|
//-------------------------------------------------------------------------------------------------------
|
|
|
|
bool Utils::openWithPdfViewer(ContentModel * contentModel, const QString& filePath, const int& width, const int& height)
|
|
{ #ifdef PDF_ENABLED PdfWidget *view = new PdfWidget(contentModel); view->setMinimumSize(QSize(width, height));
|
|
view->show();
|
|
view->open(filePath);
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void Utils::setFamilyFont(QAction * dest, const QString& family){
|
|
QFont font(dest->font());
|
|
font.setFamily(family);
|
|
dest->setFont(font);
|
|
}
|
|
void Utils::setFamilyFont(QWidget * dest, const QString& family){
|
|
QFont font(dest->font());
|
|
font.setFamily(family);
|
|
dest->setFont(font);
|
|
}
|
|
QPixmap Utils::getMaskedPixmap(const QString& name, const QColor& color){
|
|
QSize size;
|
|
QPixmap img = ImageProvider::computePixmap(name, &size);
|
|
QPixmap pxr( img.size() );
|
|
pxr.fill( color );
|
|
pxr.setMask( img.createMaskFromColor( Qt::transparent ) );
|
|
return pxr;
|
|
}
|
|
*/
|