src/Global.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2011 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "Global.h"
  23
  24 //Qt includes
  25 #include <QApplication>
  26 #include <QMessageBox>
  27 #include <QDir>
  28 #include <QUuid>
  29 #include <QMap>
  30 #include <QDate>
  31 #include <QIcon>
  32 #include <QPlastiqueStyle>
  33 #include <QImageReader>
  34 #include <QSharedMemory>
  35 #include <QSysInfo>
  36 #include <QStringList>
  37 #include <QSystemSemaphore>
  38 #include <QMutex>
  39 #include <QTextCodec>
  40 #include <QLibrary>
  41 #include <QRegExp>
  42 #include <QResource>
  43 #include <QTranslator>
  44
  45 //LameXP includes
  46 #include "Resource.h"
  47 #include "LockedFile.h"
  48
  49 //Windows includes
  50 #include <Windows.h>
  51
  52 //CRT includes
  53 #include <stdio.h>
  54 #include <io.h>
  55 #include <fcntl.h>
  56 #include <intrin.h>
  57
  58 //Debug only includes
  59 #ifdef _DEBUG
  60 #include <Psapi.h>
  61 #endif //_DEBUG
  62
  63 //Static build only macros
  64 #ifdef QT_NODLL
  65 #pragma warning(disable:4101)
  66 #define LAMEXP_INIT_QT_STATIC_PLUGIN(X) Q_IMPORT_PLUGIN(X)
  67 #else
  68 #define LAMEXP_INIT_QT_STATIC_PLUGIN(X)
  69 #endif
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72 // TYPES
  73 ///////////////////////////////////////////////////////////////////////////////
  74
  75 typedef struct
  76 {
  77         unsigned int command;
  78         unsigned int reserved_1;
  79         unsigned int reserved_2;
  80         char parameter[4096];
  81 } lamexp_ipc_t;
  82
  83 ///////////////////////////////////////////////////////////////////////////////
  84 // GLOBAL VARS
  85 ///////////////////////////////////////////////////////////////////////////////
  86
  87 //Build version
  88 static const struct
  89 {
  90         unsigned int ver_major;
  91         unsigned int ver_minor;
  92         unsigned int ver_build;
  93         char *ver_release_name;
  94 }
  95 g_lamexp_version =
  96 {
  97         VER_LAMEXP_MAJOR,
  98         VER_LAMEXP_MINOR,
  99         VER_LAMEXP_BUILD,
 100         VER_LAMEXP_RNAME
 101 };
 102
 103 //Build date
 104 static QDate g_lamexp_version_date;
 105 static const char *g_lamexp_months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 106 static const char *g_lamexp_version_raw_date = __DATE__;
 107
 108 //Compiler version
 109 #if _MSC_VER == 1400
 110         static const char *g_lamexp_version_compiler = "MSVC 8.0";
 111 #else
 112         #if _MSC_VER == 1500
 113                 static const char *g_lamexp_version_compiler = "MSVC 9.0";
 114         #else
 115                 #if _MSC_VER == 1600
 116                         static const char *g_lamexp_version_compiler = "MSVC 10.0";
 117                 #else
 118                         static const char *g_lamexp_version_compiler = "UNKNOWN";
 119                 #endif
 120         #endif
 121 #endif
 122
 123 //Tool versions (expected)
 124 static const unsigned int g_lamexp_toolver_neroaac = VER_LAMEXP_TOOL_NEROAAC;
 125
 126 //Special folders
 127 static QString g_lamexp_temp_folder;
 128
 129 //Tools
 130 static QMap<QString, LockedFile*> g_lamexp_tool_registry;
 131 static QMap<QString, unsigned int> g_lamexp_tool_versions;
 132
 133 //Languages
 134 static struct
 135 {
 136         QMap<QString, QString> files;
 137         QMap<QString, QString> names;
 138         QMap<QString, unsigned int> sysid;
 139 }
 140 g_lamexp_translation;
 141
 142 //Translator
 143 static QTranslator *g_lamexp_currentTranslator = NULL;
 144
 145 //Shared memory
 146 static const struct
 147 {
 148         char *sharedmem;
 149         char *semaphore_read;
 150         char *semaphore_write;
 151 }
 152 g_lamexp_ipc_uuid =
 153 {
 154         "{21A68A42-6923-43bb-9CF6-64BF151942EE}",
 155         "{7A605549-F58C-4d78-B4E5-06EFC34F405B}",
 156         "{60AA8D04-F6B8-497d-81EB-0F600F4A65B5}"
 157 };
 158 static struct
 159 {
 160         QSharedMemory *sharedmem;
 161         QSystemSemaphore *semaphore_read;
 162         QSystemSemaphore *semaphore_write;
 163 }
 164 g_lamexp_ipc_ptr =
 165 {
 166         NULL, NULL, NULL
 167 };
 168
 169 //Image formats
 170 static const char *g_lamexp_imageformats[] = {"png", "gif", "ico", "svg", NULL};
 171
 172 //Global locks
 173 static QMutex g_lamexp_message_mutex;
 174
 175 ///////////////////////////////////////////////////////////////////////////////
 176 // GLOBAL FUNCTIONS
 177 ///////////////////////////////////////////////////////////////////////////////
 178
 179 /*
 180  * Version getters
 181  */
 182 unsigned int lamexp_version_major(void) { return g_lamexp_version.ver_major; }
 183 unsigned int lamexp_version_minor(void) { return g_lamexp_version.ver_minor; }
 184 unsigned int lamexp_version_build(void) { return g_lamexp_version.ver_build; }
 185 const char *lamexp_version_release(void) { return g_lamexp_version.ver_release_name; }
 186 const char *lamexp_version_compiler(void) {return g_lamexp_version_compiler; }
 187 unsigned int lamexp_toolver_neroaac(void) { return g_lamexp_toolver_neroaac; }
 188
 189 bool lamexp_version_demo(void)
 190 {
 191
 192         return LAMEXP_DEBUG || !(strstr(g_lamexp_version.ver_release_name, "Final") || strstr(g_lamexp_version.ver_release_name, "Hotfix"));
 193 }
 194
 195 QDate lamexp_version_expires(void)
 196 {
 197         return lamexp_version_date().addDays(30);
 198 }
 199
 200 /*
 201  * Get build date date
 202  */
 203 const QDate &lamexp_version_date(void)
 204 {
 205         if(!g_lamexp_version_date.isValid())
 206         {
 207                 char temp[32];
 208                 int date[3];
 209
 210                 char *this_token = NULL;
 211                 char *next_token = NULL;
 212
 213                 strcpy_s(temp, 32, g_lamexp_version_raw_date);
 214                 this_token = strtok_s(temp, " ", &next_token);
 215
 216                 for(int i = 0; i < 3; i++)
 217                 {
 218                         date[i] = -1;
 219                         if(this_token)
 220                         {
 221                                 for(int j = 0; j < 12; j++)
 222                                 {
 223                                         if(!_strcmpi(this_token, g_lamexp_months[j]))
 224                                         {
 225                                                 date[i] = j+1;
 226                                                 break;
 227                                         }
 228                                 }
 229                                 if(date[i] < 0)
 230                                 {
 231                                         date[i] = atoi(this_token);
 232                                 }
 233                                 this_token = strtok_s(NULL, " ", &next_token);
 234                         }
 235                 }
 236
 237                 if(date[0] >= 0 && date[1] >= 0 && date[2] >= 0)
 238                 {
 239                         g_lamexp_version_date = QDate(date[2], date[0], date[1]);
 240                 }
 241         }
 242
 243         return g_lamexp_version_date;
 244 }
 245
 246 /*
 247  * Qt message handler
 248  */
 249 void lamexp_message_handler(QtMsgType type, const char *msg)
 250 {
 251         static HANDLE hConsole = NULL;
 252         QMutexLocker lock(&g_lamexp_message_mutex);
 253
 254         if(!hConsole)
 255         {
 256                 hConsole = CreateFile(L"CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
 257                 if(hConsole == INVALID_HANDLE_VALUE) hConsole = NULL;
 258         }
 259
 260         CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
 261         GetConsoleScreenBufferInfo(hConsole, &bufferInfo);
 262         SetConsoleOutputCP(CP_UTF8);
 263
 264         switch(type)
 265         {
 266         case QtCriticalMsg:
 267         case QtFatalMsg:
 268                 fflush(stdout);
 269                 fflush(stderr);
 270                 SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
 271                 fwprintf(stderr, L"\nGURU MEDITATION !!!\n%S\n\n", msg);
 272                 MessageBoxW(NULL, (wchar_t*) QString::fromUtf8(msg).utf16(), L"LameXP - GURU MEDITATION", MB_ICONERROR | MB_TOPMOST | MB_TASKMODAL);
 273                 break;
 274         case QtWarningMsg:
 275                 SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
 276                 //MessageBoxW(NULL, (wchar_t*) QString::fromUtf8(msg).utf16(), L"LameXP - GURU MEDITATION", MB_ICONWARNING | MB_TOPMOST | MB_TASKMODAL);
 277                 fwprintf(stderr, L"%S\n", msg);
 278                 fflush(stderr);
 279                 break;
 280         default:
 281                 SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
 282                 fwprintf(stderr, L"%S\n", msg);
 283                 fflush(stderr);
 284                 break;
 285         }
 286
 287         SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
 288
 289         if(type == QtCriticalMsg || type == QtFatalMsg)
 290         {
 291                 lock.unlock();
 292                 FatalAppExit(0, L"The application has encountered a critical error and will exit now!");
 293                 TerminateProcess(GetCurrentProcess(), -1);
 294         }
 295  }
 296
 297 /*
 298  * Initialize the console
 299  */
 300 void lamexp_init_console(int argc, char* argv[])
 301 {
 302         for(int i = 0; i < argc; i++)
 303         {
 304                 if(lamexp_version_demo() || !_stricmp(argv[i], "--console"))
 305                 {
 306                         if(AllocConsole())
 307                         {
 308                                 //See: http://support.microsoft.com/default.aspx?scid=kb;en-us;105305
 309                                 int hCrtStdOut = _open_osfhandle((long) GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
 310                                 int hCrtStdErr = _open_osfhandle((long) GetStdHandle(STD_ERROR_HANDLE), _O_TEXT);
 311                                 FILE *hfStdOut = _fdopen(hCrtStdOut, "w");
 312                                 FILE *hfStderr = _fdopen(hCrtStdErr, "w");
 313                                 *stdout = *hfStdOut;
 314                                 *stderr = *hfStderr;
 315                                 setvbuf(stdout, NULL, _IONBF, 0);
 316                                 setvbuf(stderr, NULL, _IONBF, 0);
 317                         }
 318
 319                         HMENU hMenu = GetSystemMenu(GetConsoleWindow(), 0);
 320                         EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
 321                         RemoveMenu(hMenu, SC_CLOSE, MF_BYCOMMAND);
 322
 323                         SetConsoleCtrlHandler(NULL, TRUE);
 324                         SetConsoleTitle(L"LameXP - Audio Encoder Front-End | Debug Console");
 325                         SetConsoleOutputCP(CP_UTF8);
 326
 327                         break;
 328                 }
 329         }
 330 }
 331
 332 /*
 333  * Detect CPU features
 334  */
 335 lamexp_cpu_t lamexp_detect_cpu_features(void)
 336 {
 337         typedef BOOL (WINAPI *IsWow64ProcessFun)(__in HANDLE hProcess, __out PBOOL Wow64Process);
 338         typedef VOID (WINAPI *GetNativeSystemInfoFun)(__out LPSYSTEM_INFO lpSystemInfo);
 339
 340         static IsWow64ProcessFun IsWow64ProcessPtr = NULL;
 341         static GetNativeSystemInfoFun GetNativeSystemInfoPtr = NULL;
 342
 343         lamexp_cpu_t features;
 344         SYSTEM_INFO systemInfo;
 345         int CPUInfo[4] = {-1};
 346         char CPUIdentificationString[0x40];
 347         char CPUBrandString[0x40];
 348
 349         memset(&features, 0, sizeof(lamexp_cpu_t));
 350         memset(&systemInfo, 0, sizeof(SYSTEM_INFO));
 351         memset(CPUIdentificationString, 0, sizeof(CPUIdentificationString));
 352         memset(CPUBrandString, 0, sizeof(CPUBrandString));
 353
 354         __cpuid(CPUInfo, 0);
 355         memcpy(CPUIdentificationString, &CPUInfo[1], sizeof(int));
 356         memcpy(CPUIdentificationString + 4, &CPUInfo[3], sizeof(int));
 357         memcpy(CPUIdentificationString + 8, &CPUInfo[2], sizeof(int));
 358         features.intel = (_stricmp(CPUIdentificationString, "GenuineIntel") == 0);
 359         strcpy_s(features.vendor, 0x40, CPUIdentificationString);
 360
 361         if(CPUInfo[0] >= 1)
 362         {
 363                 __cpuid(CPUInfo, 1);
 364                 features.mmx = (CPUInfo[3] & 0x800000) || false;
 365                 features.sse = (CPUInfo[3] & 0x2000000) || false;
 366                 features.sse2 = (CPUInfo[3] & 0x4000000) || false;
 367                 features.ssse3 = (CPUInfo[2] & 0x200) || false;
 368                 features.sse3 = (CPUInfo[2] & 0x1) || false;
 369                 features.ssse3 = (CPUInfo[2] & 0x200) || false;
 370                 features.stepping = CPUInfo[0] & 0xf;
 371                 features.model = ((CPUInfo[0] >> 4) & 0xf) + (((CPUInfo[0] >> 16) & 0xf) << 4);
 372                 features.family = ((CPUInfo[0] >> 8) & 0xf) + ((CPUInfo[0] >> 20) & 0xff);
 373         }
 374
 375         __cpuid(CPUInfo, 0x80000000);
 376         int nExIds = max(min(CPUInfo[0], 0x80000004), 0x80000000);
 377
 378         for(int i = 0x80000002; i <= nExIds; ++i)
 379         {
 380                 __cpuid(CPUInfo, i);
 381                 switch(i)
 382                 {
 383                 case 0x80000002:
 384                         memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));
 385                         break;
 386                 case 0x80000003:
 387                         memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));
 388                         break;
 389                 case 0x80000004:
 390                         memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));
 391                         break;
 392                 }
 393         }
 394
 395         strcpy_s(features.brand, 0x40, CPUBrandString);
 396
 397         if(strlen(features.brand) < 1) strcpy_s(features.brand, 0x40, "Unknown");
 398         if(strlen(features.vendor) < 1) strcpy_s(features.vendor, 0x40, "Unknown");
 399
 400 #if !defined(_M_X64 ) && !defined(_M_IA64)
 401         if(!IsWow64ProcessPtr || !GetNativeSystemInfoPtr)
 402         {
 403                 QLibrary Kernel32Lib("kernel32.dll");
 404                 IsWow64ProcessPtr = (IsWow64ProcessFun) Kernel32Lib.resolve("IsWow64Process");
 405                 GetNativeSystemInfoPtr = (GetNativeSystemInfoFun) Kernel32Lib.resolve("GetNativeSystemInfo");
 406         }
 407         if(IsWow64ProcessPtr)
 408         {
 409                 BOOL x64 = FALSE;
 410                 if(IsWow64ProcessPtr(GetCurrentProcess(), &x64))
 411                 {
 412                         features.x64 = x64;
 413                 }
 414         }
 415         if(GetNativeSystemInfoPtr)
 416         {
 417                 GetNativeSystemInfoPtr(&systemInfo);
 418         }
 419         else
 420         {
 421                 GetSystemInfo(&systemInfo);
 422         }
 423         features.count = systemInfo.dwNumberOfProcessors;
 424 #else
 425         GetNativeSystemInfo(&systemInfo);
 426         features.count = systemInfo.dwNumberOfProcessors;
 427         features.x64 = true;
 428 #endif
 429
 430         return features;
 431 }
 432
 433 /*
 434  * Check for debugger
 435  */
 436 void WINAPI debugThreadProc(__in LPVOID lpParameter)
 437 {
 438         BOOL remoteDebuggerPresent = FALSE;
 439         //CheckRemoteDebuggerPresent(GetCurrentProcess, &remoteDebuggerPresent);
 440
 441         while(!IsDebuggerPresent() && !remoteDebuggerPresent)
 442         {
 443                 Sleep(333);
 444                 //CheckRemoteDebuggerPresent(GetCurrentProcess, &remoteDebuggerPresent);
 445         }
 446
 447         TerminateProcess(GetCurrentProcess(), -1);
 448 }
 449
 450 /*
 451  * Check for compatibility mode
 452  */
 453 static bool lamexp_check_compatibility_mode(const char *exportName)
 454 {
 455         QLibrary kernel32("kernel32.dll");
 456
 457         if(exportName != NULL)
 458         {
 459                 if(kernel32.resolve(exportName) != NULL)
 460                 {
 461                         qFatal("Windows compatibility mode detected. Program will exit!");
 462                         return false;
 463                 }
 464         }
 465
 466         return true;
 467 }
 468
 469 /*
 470  * Check for process elevation
 471  */
 472 static bool lamexp_check_elevation(void)
 473 {
 474         typedef enum { lamexp_token_elevationType_class = 18, lamexp_token_elevation_class = 20 } LAMEXP_TOKEN_INFORMATION_CLASS;
 475         typedef enum { lamexp_elevationType_default = 1, lamexp_elevationType_full, lamexp_elevationType_limited } LAMEXP_TOKEN_ELEVATION_TYPE;
 476
 477         HANDLE hToken = NULL;
 478         bool bIsProcessElevated = false;
 479
 480         if(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 481         {
 482                 LAMEXP_TOKEN_ELEVATION_TYPE tokenElevationType;
 483                 DWORD returnLength;
 484                 if(GetTokenInformation(hToken, (TOKEN_INFORMATION_CLASS) lamexp_token_elevationType_class, &tokenElevationType, sizeof(LAMEXP_TOKEN_ELEVATION_TYPE), &returnLength))
 485                 {
 486                         if(returnLength == sizeof(LAMEXP_TOKEN_ELEVATION_TYPE))
 487                         {
 488                                 switch(tokenElevationType)
 489                                 {
 490                                 case lamexp_elevationType_default:
 491                                         qDebug("Process token elevation type: Default -> UAC is disabled.\n");
 492                                         break;
 493                                 case lamexp_elevationType_full:
 494                                         qWarning("Process token elevation type: Full -> potential security risk!\n");
 495                                         bIsProcessElevated = true;
 496                                         break;
 497                                 case lamexp_elevationType_limited:
 498                                         qDebug("Process token elevation type: Limited -> not elevated.\n");
 499                                         break;
 500                                 }
 501                         }
 502                 }
 503                 CloseHandle(hToken);
 504         }
 505         else
 506         {
 507                 qWarning("Failed to open process token!");
 508         }
 509
 510         return !bIsProcessElevated;
 511 }
 512
 513 /*
 514  * Initialize Qt framework
 515  */
 516 bool lamexp_init_qt(int argc, char* argv[])
 517 {
 518         static bool qt_initialized = false;
 519
 520         //Don't initialized again, if done already
 521         if(qt_initialized)
 522         {
 523                 return true;
 524         }
 525
 526         //Check Qt version
 527         qDebug("Using Qt Framework v%s, compiled with Qt v%s", qVersion(), QT_VERSION_STR);
 528         QT_REQUIRE_VERSION(argc, argv, QT_VERSION_STR);
 529
 530         //Check the Windows version
 531         switch(QSysInfo::windowsVersion() & QSysInfo::WV_NT_based)
 532         {
 533         case QSysInfo::WV_2000:
 534                 qDebug("Running on Windows 2000 (not offically supported!).\n");
 535                 lamexp_check_compatibility_mode("GetNativeSystemInfo");
 536                 break;
 537         case QSysInfo::WV_XP:
 538                 qDebug("Running on Windows XP.\n");
 539                 lamexp_check_compatibility_mode("GetLargePageMinimum");
 540                 break;
 541         case QSysInfo::WV_2003:
 542                 qDebug("Running on Windows Server 2003 or Windows XP x64-Edition.\n");
 543                 lamexp_check_compatibility_mode("GetLocaleInfoEx");
 544                 break;
 545         case QSysInfo::WV_VISTA:
 546                 qDebug("Running on Windows Vista or Windows Server 2008.\n");
 547                 lamexp_check_compatibility_mode("CreateRemoteThreadEx");
 548                 break;
 549         case QSysInfo::WV_WINDOWS7:
 550                 qDebug("Running on Windows 7 or Windows Server 2008 R2.\n");
 551                 lamexp_check_compatibility_mode(NULL);
 552                 break;
 553         default:
 554                 qFatal("Unsupported OS, only Windows 2000 or later is supported!");
 555                 break;
 556         }
 557
 558         //Create Qt application instance and setup version info
 559         QApplication *application = new QApplication(argc, argv);
 560         application->setApplicationName("LameXP - Audio Encoder Front-End");
 561         application->setApplicationVersion(QString().sprintf("%d.%02d.%04d", lamexp_version_major(), lamexp_version_minor(), lamexp_version_build()));
 562         application->setOrganizationName("LoRd_MuldeR");
 563         application->setOrganizationDomain("mulder.dummwiedeutsch.de");
 564         application->setWindowIcon(QIcon(":/MainIcon.png"));
 565
 566         //Load plugins from application directory
 567         QCoreApplication::setLibraryPaths(QStringList() << QApplication::applicationDirPath());
 568         qDebug("Library Path:\n%s\n", QApplication::libraryPaths().first().toUtf8().constData());
 569
 570         //Init static Qt plugins
 571         LAMEXP_INIT_QT_STATIC_PLUGIN(qico);
 572         LAMEXP_INIT_QT_STATIC_PLUGIN(qsvg);
 573
 574         //Check for supported image formats
 575         QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
 576         for(int i = 0; g_lamexp_imageformats[i]; i++)
 577         {
 578                 if(!supportedFormats.contains(g_lamexp_imageformats[i]))
 579                 {
 580                         qFatal("Qt initialization error: At least one image format plugin is missing! (%s)", g_lamexp_imageformats[i]);
 581                         return false;
 582                 }
 583         }
 584
 585         //Add default translations
 586         g_lamexp_translation.files.insert(LAMEXP_DEFAULT_LANGID, "");
 587         g_lamexp_translation.names.insert(LAMEXP_DEFAULT_LANGID, "English");
 588
 589         //Init language files
 590         //lamexp_init_translations();
 591
 592         //Check for process elevation
 593         if(!lamexp_check_elevation())
 594         {
 595                 if(QMessageBox::warning(NULL, "LameXP", "<nobr>LameXP was started with elevated rights. This is a potential security risk!</nobr>", "Quit Program (Recommended)", "Ignore") == 0)
 596                 {
 597                         return false;
 598                 }
 599         }
 600
 601         //Done
 602         qt_initialized = true;
 603         return true;
 604 }
 605
 606 /*
 607  * Initialize IPC
 608  */
 609 int lamexp_init_ipc(void)
 610 {
 611         if(g_lamexp_ipc_ptr.sharedmem && g_lamexp_ipc_ptr.semaphore_read && g_lamexp_ipc_ptr.semaphore_write)
 612         {
 613                 return 0;
 614         }
 615
 616         g_lamexp_ipc_ptr.semaphore_read = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_read), 0);
 617         g_lamexp_ipc_ptr.semaphore_write = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_write), 0);
 618
 619         if(g_lamexp_ipc_ptr.semaphore_read->error() != QSystemSemaphore::NoError)
 620         {
 621                 QString errorMessage = g_lamexp_ipc_ptr.semaphore_read->errorString();
 622                 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
 623                 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
 624                 qFatal("Failed to create system smaphore: %s", errorMessage.toUtf8().constData());
 625                 return -1;
 626         }
 627         if(g_lamexp_ipc_ptr.semaphore_write->error() != QSystemSemaphore::NoError)
 628         {
 629                 QString errorMessage = g_lamexp_ipc_ptr.semaphore_write->errorString();
 630                 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
 631                 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
 632                 qFatal("Failed to create system smaphore: %s", errorMessage.toUtf8().constData());
 633                 return -1;
 634         }
 635
 636         g_lamexp_ipc_ptr.sharedmem = new QSharedMemory(QString(g_lamexp_ipc_uuid.sharedmem), NULL);
 637
 638         if(!g_lamexp_ipc_ptr.sharedmem->create(sizeof(lamexp_ipc_t)))
 639         {
 640                 if(g_lamexp_ipc_ptr.sharedmem->error() == QSharedMemory::AlreadyExists)
 641                 {
 642                         g_lamexp_ipc_ptr.sharedmem->attach();
 643                         if(g_lamexp_ipc_ptr.sharedmem->error() == QSharedMemory::NoError)
 644                         {
 645                                 return 1;
 646                         }
 647                         else
 648                         {
 649                                 QString errorMessage = g_lamexp_ipc_ptr.sharedmem->errorString();
 650                                 qFatal("Failed to attach to shared memory: %s", errorMessage.toUtf8().constData());
 651                                 return -1;
 652                         }
 653                 }
 654                 else
 655                 {
 656                         QString errorMessage = g_lamexp_ipc_ptr.sharedmem->errorString();
 657                         qFatal("Failed to create shared memory: %s", errorMessage.toUtf8().constData());
 658                         return -1;
 659                 }
 660         }
 661
 662         memset(g_lamexp_ipc_ptr.sharedmem->data(), 0, sizeof(lamexp_ipc_t));
 663         g_lamexp_ipc_ptr.semaphore_write->release();
 664
 665         return 0;
 666 }
 667
 668 /*
 669  * IPC send message
 670  */
 671 void lamexp_ipc_send(unsigned int command, const char* message)
 672 {
 673         if(!g_lamexp_ipc_ptr.sharedmem || !g_lamexp_ipc_ptr.semaphore_read || !g_lamexp_ipc_ptr.semaphore_write)
 674         {
 675                 throw "Shared memory for IPC not initialized yet.";
 676         }
 677
 678         lamexp_ipc_t *lamexp_ipc = new lamexp_ipc_t;
 679         memset(lamexp_ipc, 0, sizeof(lamexp_ipc_t));
 680         lamexp_ipc->command = command;
 681         if(message)
 682         {
 683                 strcpy_s(lamexp_ipc->parameter, 4096, message);
 684         }
 685
 686         if(g_lamexp_ipc_ptr.semaphore_write->acquire())
 687         {
 688                 memcpy(g_lamexp_ipc_ptr.sharedmem->data(), lamexp_ipc, sizeof(lamexp_ipc_t));
 689                 g_lamexp_ipc_ptr.semaphore_read->release();
 690         }
 691
 692         LAMEXP_DELETE(lamexp_ipc);
 693 }
 694
 695 /*
 696  * IPC read message
 697  */
 698 void lamexp_ipc_read(unsigned int *command, char* message, size_t buffSize)
 699 {
 700         *command = 0;
 701         message[0] = '\0';
 702
 703         if(!g_lamexp_ipc_ptr.sharedmem || !g_lamexp_ipc_ptr.semaphore_read || !g_lamexp_ipc_ptr.semaphore_write)
 704         {
 705                 throw "Shared memory for IPC not initialized yet.";
 706         }
 707
 708         lamexp_ipc_t *lamexp_ipc = new lamexp_ipc_t;
 709         memset(lamexp_ipc, 0, sizeof(lamexp_ipc_t));
 710
 711         if(g_lamexp_ipc_ptr.semaphore_read->acquire())
 712         {
 713                 memcpy(lamexp_ipc, g_lamexp_ipc_ptr.sharedmem->data(), sizeof(lamexp_ipc_t));
 714                 g_lamexp_ipc_ptr.semaphore_write->release();
 715
 716                 if(!(lamexp_ipc->reserved_1 || lamexp_ipc->reserved_2))
 717                 {
 718                         *command = lamexp_ipc->command;
 719                         strcpy_s(message, buffSize, lamexp_ipc->parameter);
 720                 }
 721                 else
 722                 {
 723                         qWarning("Malformed IPC message, will be ignored");
 724                 }
 725         }
 726
 727         LAMEXP_DELETE(lamexp_ipc);
 728 }
 729
 730 /*
 731  * Check for LameXP "portable" mode
 732  */
 733 bool lamexp_portable_mode(void)
 734 {
 735         QString baseName = QFileInfo(QApplication::applicationFilePath()).completeBaseName();
 736         return baseName.contains("lamexp", Qt::CaseInsensitive) && baseName.contains("portable", Qt::CaseInsensitive);
 737 }
 738
 739 /*
 740  * Get a random string
 741  */
 742 QString lamexp_rand_str(void)
 743 {
 744         QRegExp regExp("\\{(\\w+)-(\\w+)-(\\w+)-(\\w+)-(\\w+)\\}");
 745         QString uuid = QUuid::createUuid().toString();
 746
 747         if(regExp.indexIn(uuid) >= 0)
 748         {
 749                 return QString().append(regExp.cap(1)).append(regExp.cap(2)).append(regExp.cap(3)).append(regExp.cap(4)).append(regExp.cap(5));
 750         }
 751
 752         throw "The RegExp didn't match on the UUID string. This shouldn't happen ;-)";
 753 }
 754
 755 /*
 756  * Get LameXP temp folder
 757  */
 758 const QString &lamexp_temp_folder(void)
 759 {
 760         static const char *TEMP_STR = "Temp";
 761
 762         if(g_lamexp_temp_folder.isEmpty())
 763         {
 764                 QDir temp = QDir::temp();
 765                 QDir localAppData = QDir(lamexp_known_folder(lamexp_folder_localappdata));
 766
 767                 if(!localAppData.path().isEmpty() && localAppData.exists())
 768                 {
 769                         if(!localAppData.entryList(QDir::AllDirs).contains(TEMP_STR, Qt::CaseInsensitive))
 770                         {
 771                                 localAppData.mkdir(TEMP_STR);
 772                         }
 773                         if(localAppData.cd(TEMP_STR))
 774                         {
 775                                 temp.setPath(localAppData.absolutePath());
 776                         }
 777                 }
 778
 779                 if(!temp.exists())
 780                 {
 781                         temp.mkpath(".");
 782                         if(!temp.exists())
 783                         {
 784                                 qFatal("The system's temporary directory does not exist:\n%s", temp.absolutePath().toUtf8().constData());
 785                                 return g_lamexp_temp_folder;
 786                         }
 787                 }
 788
 789                 QString subDir = QString("%1.tmp").arg(lamexp_rand_str());
 790                 if(!temp.mkdir(subDir))
 791                 {
 792                         qFatal("Temporary directory could not be created:\n%s", QString("%1/%2").arg(temp.canonicalPath(), subDir).toUtf8().constData());
 793                         return g_lamexp_temp_folder;
 794                 }
 795                 if(!temp.cd(subDir))
 796                 {
 797                         qFatal("Temporary directory could not be entered:\n%s", QString("%1/%2").arg(temp.canonicalPath(), subDir).toUtf8().constData());
 798                         return g_lamexp_temp_folder;
 799                 }
 800
 801                 QFile testFile(QString("%1/.%2").arg(temp.canonicalPath(), lamexp_rand_str()));
 802                 if(!testFile.open(QIODevice::ReadWrite) || testFile.write("LAMEXP_TEST\n") < 12)
 803                 {
 804                         qFatal("Write access to temporary directory has been denied:\n%s", temp.canonicalPath().toUtf8().constData());
 805                         return g_lamexp_temp_folder;
 806                 }
 807
 808                 testFile.close();
 809                 QFile::remove(testFile.fileName());
 810
 811                 g_lamexp_temp_folder = temp.canonicalPath();
 812         }
 813
 814         return g_lamexp_temp_folder;
 815 }
 816
 817 /*
 818  * Clean folder
 819  */
 820 bool lamexp_clean_folder(const QString folderPath)
 821 {
 822         QDir tempFolder(folderPath);
 823         QFileInfoList entryList = tempFolder.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot);
 824
 825         for(int i = 0; i < entryList.count(); i++)
 826         {
 827                 if(entryList.at(i).isDir())
 828                 {
 829                         lamexp_clean_folder(entryList.at(i).canonicalFilePath());
 830                 }
 831                 else
 832                 {
 833                         for(int j = 0; j < 3; j++)
 834                         {
 835                                 if(lamexp_remove_file(entryList.at(i).canonicalFilePath()))
 836                                 {
 837                                         break;
 838                                 }
 839                         }
 840                 }
 841         }
 842
 843         tempFolder.rmdir(".");
 844         return !tempFolder.exists();
 845 }
 846
 847 /*
 848  * Register tool
 849  */
 850 void lamexp_register_tool(const QString &toolName, LockedFile *file, unsigned int version)
 851 {
 852         if(g_lamexp_tool_registry.contains(toolName.toLower()))
 853         {
 854                 throw "lamexp_register_tool: Tool is already registered!";
 855         }
 856
 857         g_lamexp_tool_registry.insert(toolName.toLower(), file);
 858         g_lamexp_tool_versions.insert(toolName.toLower(), version);
 859 }
 860
 861 /*
 862  * Check for tool
 863  */
 864 bool lamexp_check_tool(const QString &toolName)
 865 {
 866         return g_lamexp_tool_registry.contains(toolName.toLower());
 867 }
 868
 869 /*
 870  * Lookup tool path
 871  */
 872 const QString lamexp_lookup_tool(const QString &toolName)
 873 {
 874         if(g_lamexp_tool_registry.contains(toolName.toLower()))
 875         {
 876                 return g_lamexp_tool_registry.value(toolName.toLower())->filePath();
 877         }
 878         else
 879         {
 880                 return QString();
 881         }
 882 }
 883
 884 /*
 885  * Lookup tool version
 886  */
 887 unsigned int lamexp_tool_version(const QString &toolName)
 888 {
 889         if(g_lamexp_tool_versions.contains(toolName.toLower()))
 890         {
 891                 return g_lamexp_tool_versions.value(toolName.toLower());
 892         }
 893         else
 894         {
 895                 return UINT_MAX;
 896         }
 897 }
 898
 899 /*
 900  * Version number to human-readable string
 901  */
 902 const QString lamexp_version2string(const QString &pattern, unsigned int version, const QString &defaultText)
 903 {
 904         if(version == UINT_MAX)
 905         {
 906                 return defaultText;
 907         }
 908
 909         QString result = pattern;
 910         int digits = result.count("?", Qt::CaseInsensitive);
 911
 912         if(digits < 1)
 913         {
 914                 return result;
 915         }
 916
 917         int pos = 0;
 918         QString versionStr = QString().sprintf(QString().sprintf("%%0%du", digits).toLatin1().constData(), version);
 919         int index = result.indexOf("?", Qt::CaseInsensitive);
 920
 921         while(index >= 0 && pos < versionStr.length())
 922         {
 923                 result[index] = versionStr[pos++];
 924                 index = result.indexOf("?", Qt::CaseInsensitive);
 925         }
 926
 927         return result;
 928 }
 929
 930 /*
 931  * Register a new translation
 932  */
 933 bool lamexp_translation_register(const QString &langId, const QString &qmFile, const QString &langName, unsigned int &systemId)
 934 {
 935         if(qmFile.isEmpty() || langName.isEmpty() || systemId < 1)
 936         {
 937                 return false;
 938         }
 939
 940         g_lamexp_translation.files.insert(langId, qmFile);
 941         g_lamexp_translation.names.insert(langId, langName);
 942         g_lamexp_translation.sysid.insert(langId, systemId);
 943
 944         return true;
 945 }
 946
 947 /*
 948  * Get list of all translations
 949  */
 950 QStringList lamexp_query_translations(void)
 951 {
 952         return g_lamexp_translation.files.keys();
 953 }
 954
 955 /*
 956  * Get translation name
 957  */
 958 QString lamexp_translation_name(const QString &langId)
 959 {
 960         return g_lamexp_translation.names.value(langId.toLower(), QString());
 961 }
 962
 963 /*
 964  * Get translation system id
 965  */
 966 unsigned int lamexp_translation_sysid(const QString &langId)
 967 {
 968         return g_lamexp_translation.sysid.value(langId.toLower(), 0);
 969 }
 970
 971 /*
 972  * Install a new translator
 973  */
 974 bool lamexp_install_translator(const QString &langId)
 975 {
 976         bool success = false;
 977
 978         if(langId.isEmpty() || langId.toLower().compare(LAMEXP_DEFAULT_LANGID) == 0)
 979         {
 980                 success = lamexp_install_translator_from_file(QString());
 981         }
 982         else
 983         {
 984                 QString qmFile = g_lamexp_translation.files.value(langId.toLower(), QString());
 985                 if(!qmFile.isEmpty())
 986                 {
 987                         success = lamexp_install_translator_from_file(QString(":/localization/%1").arg(qmFile));
 988                 }
 989                 else
 990                 {
 991                         qWarning("Translation '%s' not available!", langId.toLatin1().constData());
 992                 }
 993         }
 994
 995         return success;
 996 }
 997
 998 /*
 999  * Install a new translator from file
1000  */
1001 bool lamexp_install_translator_from_file(const QString &qmFile)
1002 {
1003         bool success = false;
1004
1005         if(!g_lamexp_currentTranslator)
1006         {
1007                 g_lamexp_currentTranslator = new QTranslator();
1008         }
1009
1010         if(!qmFile.isEmpty())
1011         {
1012                 QString qmPath = QFileInfo(qmFile).canonicalFilePath();
1013                 QApplication::removeTranslator(g_lamexp_currentTranslator);
1014                 success = g_lamexp_currentTranslator->load(qmPath);
1015                 QApplication::installTranslator(g_lamexp_currentTranslator);
1016                 if(!success)
1017                 {
1018                         qWarning("Failed to load translation:\n\"%s\"", qmPath.toLatin1().constData());
1019                 }
1020         }
1021         else
1022         {
1023                 QApplication::removeTranslator(g_lamexp_currentTranslator);
1024                 success = true;
1025         }
1026
1027         return success;
1028 }
1029
1030 /*
1031  * Locate known folder on local system
1032  */
1033 QString lamexp_known_folder(lamexp_known_folder_t folder_id)
1034 {
1035         typedef HRESULT (WINAPI *SHGetKnownFolderPathFun)(__in const GUID &rfid, __in DWORD dwFlags, __in HANDLE hToken, __out PWSTR *ppszPath);
1036         typedef HRESULT (WINAPI *SHGetFolderPathFun)(__in HWND hwndOwner, __in int nFolder, __in HANDLE hToken, __in DWORD dwFlags, __out LPWSTR pszPath);
1037
1038         static const int CSIDL_LOCAL_APPDATA = 0x001c;
1039         static const int CSIDL_PROGRAM_FILES = 0x0026;
1040         static const int CSIDL_SYSTEM_FOLDER = 0x0025;
1041         static const GUID GUID_LOCAL_APPDATA = {0xF1B32785,0x6FBA,0x4FCF,{0x9D,0x55,0x7B,0x8E,0x7F,0x15,0x70,0x91}};
1042         static const GUID GUID_LOCAL_APPDATA_LOW = {0xA520A1A4,0x1780,0x4FF6,{0xBD,0x18,0x16,0x73,0x43,0xC5,0xAF,0x16}};
1043         static const GUID GUID_PROGRAM_FILES = {0x905e63b6,0xc1bf,0x494e,{0xb2,0x9c,0x65,0xb7,0x32,0xd3,0xd2,0x1a}};
1044         static const GUID GUID_SYSTEM_FOLDER = {0x1AC14E77,0x02E7,0x4E5D,{0xB7,0x44,0x2E,0xB1,0xAE,0x51,0x98,0xB7}};
1045
1046         static QLibrary *Kernel32Lib = NULL;
1047         static SHGetKnownFolderPathFun SHGetKnownFolderPathPtr = NULL;
1048         static SHGetFolderPathFun SHGetFolderPathPtr = NULL;
1049
1050         if((!SHGetKnownFolderPathPtr) && (!SHGetFolderPathPtr))
1051         {
1052                 if(!Kernel32Lib) Kernel32Lib = new QLibrary("shell32.dll");
1053                 SHGetKnownFolderPathPtr = (SHGetKnownFolderPathFun) Kernel32Lib->resolve("SHGetKnownFolderPath");
1054                 SHGetFolderPathPtr = (SHGetFolderPathFun) Kernel32Lib->resolve("SHGetFolderPathW");
1055         }
1056
1057         int folderCSIDL = -1;
1058         GUID folderGUID = {0x0000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
1059
1060         switch(folder_id)
1061         {
1062         case lamexp_folder_localappdata:
1063                 folderCSIDL = CSIDL_LOCAL_APPDATA;
1064                 folderGUID = GUID_LOCAL_APPDATA;
1065                 break;
1066         case lamexp_folder_programfiles:
1067                 folderCSIDL = CSIDL_PROGRAM_FILES;
1068                 folderGUID = GUID_PROGRAM_FILES;
1069                 break;
1070         case lamexp_folder_systemfolder:
1071                 folderCSIDL = CSIDL_SYSTEM_FOLDER;
1072                 folderGUID = GUID_SYSTEM_FOLDER;
1073                 break;
1074         default:
1075                 return QString();
1076                 break;
1077         }
1078
1079         QString folder;
1080
1081         if(SHGetKnownFolderPathPtr)
1082         {
1083                 WCHAR *path = NULL;
1084                 if(SHGetKnownFolderPathPtr(folderGUID, 0x00008000, NULL, &path) == S_OK)
1085                 {
1086                         //MessageBoxW(0, path, L"SHGetKnownFolderPath", MB_TOPMOST);
1087                         QDir folderTemp = QDir(QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const unsigned short*>(path))));
1088                         if(!folderTemp.exists())
1089                         {
1090                                 folderTemp.mkpath(".");
1091                         }
1092                         if(folderTemp.exists())
1093                         {
1094                                 folder = folderTemp.canonicalPath();
1095                         }
1096                         CoTaskMemFree(path);
1097                 }
1098         }
1099         else if(SHGetFolderPathPtr)
1100         {
1101                 WCHAR *path = new WCHAR[4096];
1102                 if(SHGetFolderPathPtr(NULL, folderCSIDL, NULL, NULL, path) == S_OK)
1103                 {
1104                         //MessageBoxW(0, path, L"SHGetFolderPathW", MB_TOPMOST);
1105                         QDir folderTemp = QDir(QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const unsigned short*>(path))));
1106                         if(!folderTemp.exists())
1107                         {
1108                                 folderTemp.mkpath(".");
1109                         }
1110                         if(folderTemp.exists())
1111                         {
1112                                 folder = folderTemp.canonicalPath();
1113                         }
1114                 }
1115                 delete [] path;
1116         }
1117
1118         return folder;
1119 }
1120
1121 /*
1122  * Safely remove a file
1123  */
1124 bool lamexp_remove_file(const QString &filename)
1125 {
1126         if(!QFileInfo(filename).exists() || !QFileInfo(filename).isFile())
1127         {
1128                 return true;
1129         }
1130         else
1131         {
1132                 if(!QFile::remove(filename))
1133                 {
1134                         DWORD attributes = GetFileAttributesW(reinterpret_cast<const wchar_t*>(filename.utf16()));
1135                         SetFileAttributesW(reinterpret_cast<const wchar_t*>(filename.utf16()), (attributes & (~FILE_ATTRIBUTE_READONLY)));
1136                         if(!QFile::remove(filename))
1137                         {
1138                                 qWarning("Could not delete \"%s\"", filename.toLatin1().constData());
1139                                 return false;
1140                         }
1141                         else
1142                         {
1143                                 return true;
1144                         }
1145                 }
1146                 else
1147                 {
1148                         return true;
1149                 }
1150         }
1151 }
1152
1153 /*
1154  * Check if visual themes are enabled (WinXP and later)
1155  */
1156 bool lamexp_themes_enabled(void)
1157 {
1158         typedef int (WINAPI *IsAppThemedFun)(void);
1159
1160         bool isAppThemed = false;
1161         QLibrary uxTheme(QString("%1/UxTheme.dll").arg(lamexp_known_folder(lamexp_folder_systemfolder)));
1162         IsAppThemedFun IsAppThemedPtr = (IsAppThemedFun) uxTheme.resolve("IsAppThemed");
1163
1164         if(IsAppThemedPtr)
1165         {
1166                 isAppThemed = IsAppThemedPtr();
1167                 if(!isAppThemed)
1168                 {
1169                         qWarning("Theme support is disabled for this process!");
1170                 }
1171         }
1172
1173         return isAppThemed;
1174 }
1175
1176 /*
1177  * Get number of free bytes on disk
1178  */
1179 __int64 lamexp_free_diskspace(const QString &path)
1180 {
1181         ULARGE_INTEGER freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
1182         if(GetDiskFreeSpaceExW(reinterpret_cast<const wchar_t*>(QDir::toNativeSeparators(path).utf16()), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes))
1183         {
1184                 return freeBytesAvailable.QuadPart;
1185         }
1186         else
1187         {
1188                 return 0;
1189         }
1190 }
1191
1192 /*
1193  * Finalization function (final clean-up)
1194  */
1195 void lamexp_finalization(void)
1196 {
1197         //Free all tools
1198         if(!g_lamexp_tool_registry.isEmpty())
1199         {
1200                 QStringList keys = g_lamexp_tool_registry.keys();
1201                 for(int i = 0; i < keys.count(); i++)
1202                 {
1203                         LAMEXP_DELETE(g_lamexp_tool_registry[keys.at(i)]);
1204                 }
1205                 g_lamexp_tool_registry.clear();
1206                 g_lamexp_tool_versions.clear();
1207         }
1208
1209         //Delete temporary files
1210         if(!g_lamexp_temp_folder.isEmpty())
1211         {
1212                 for(int i = 0; i < 100; i++)
1213                 {
1214                         if(lamexp_clean_folder(g_lamexp_temp_folder))
1215                         {
1216                                 break;
1217                         }
1218                         Sleep(125);
1219                 }
1220                 g_lamexp_temp_folder.clear();
1221         }
1222
1223         //Clear languages
1224         if(g_lamexp_currentTranslator)
1225         {
1226                 QApplication::removeTranslator(g_lamexp_currentTranslator);
1227                 LAMEXP_DELETE(g_lamexp_currentTranslator);
1228         }
1229         g_lamexp_translation.files.clear();
1230         g_lamexp_translation.names.clear();
1231
1232         //Destroy Qt application object
1233         QApplication *application = dynamic_cast<QApplication*>(QApplication::instance());
1234         LAMEXP_DELETE(application);
1235
1236         //Detach from shared memory
1237         if(g_lamexp_ipc_ptr.sharedmem) g_lamexp_ipc_ptr.sharedmem->detach();
1238         LAMEXP_DELETE(g_lamexp_ipc_ptr.sharedmem);
1239         LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
1240         LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
1241 }
1242
1243 /*
1244  * Get number private bytes [debug only]
1245  */
1246 SIZE_T lamexp_dbg_private_bytes(void)
1247 {
1248 #ifdef _DEBUG
1249         PROCESS_MEMORY_COUNTERS_EX memoryCounters;
1250         memoryCounters.cb = sizeof(PROCESS_MEMORY_COUNTERS_EX);
1251         GetProcessMemoryInfo(GetCurrentProcess(), (PPROCESS_MEMORY_COUNTERS) &memoryCounters, sizeof(PROCESS_MEMORY_COUNTERS_EX));
1252         return memoryCounters.PrivateUsage;
1253 #else
1254         throw "Cannot call this function in a non-debug build!";
1255 #endif //_DEBUG
1256 }