src/Global_Utils.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2014 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, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Global.h"
  24
  25 //Qt includes
  26 #include <QApplication>
  27 #include <QDate>
  28 #include <QDir>
  29 #include <QFileInfo>
  30 #include <QIcon>
  31 #include <QMutex>
  32 #include <QProcessEnvironment>
  33 #include <QReadWriteLock>
  34 #include <QTextCodec>
  35 #include <QUuid>
  36 #include <QWidget>
  37
  38 //Natural sort
  39 #include "strnatcmp.h"
  40
  41 //CRT includes
  42 #include <time.h>
  43 #include <process.h>
  44
  45 ///////////////////////////////////////////////////////////////////////////////
  46 // GLOBAL VARS
  47 ///////////////////////////////////////////////////////////////////////////////
  48
  49 //%TEMP% folder
  50 static struct
  51 {
  52         QString *path;
  53         QReadWriteLock lock;
  54 }
  55 g_lamexp_temp_folder;
  56
  57 static struct
  58 {
  59         QIcon *appIcon;
  60         QReadWriteLock lock;
  61 }
  62 g_lamexp_app_icon;
  63
  64 ///////////////////////////////////////////////////////////////////////////////
  65 // GLOBAL FUNCTIONS
  66 ///////////////////////////////////////////////////////////////////////////////
  67
  68 /*
  69  * Get a random string
  70  */
  71 QString lamexp_rand_str(const bool bLong)
  72 {
  73         const QUuid uuid = QUuid::createUuid().toString();
  74
  75         const unsigned int u1 = uuid.data1;
  76         const unsigned int u2 = (((unsigned int)(uuid.data2)) << 16) | ((unsigned int)(uuid.data3));
  77         const unsigned int u3 = (((unsigned int)(uuid.data4[0])) << 24) | (((unsigned int)(uuid.data4[1])) << 16) | (((unsigned int)(uuid.data4[2])) << 8) | ((unsigned int)(uuid.data4[3]));
  78         const unsigned int u4 = (((unsigned int)(uuid.data4[4])) << 24) | (((unsigned int)(uuid.data4[5])) << 16) | (((unsigned int)(uuid.data4[6])) << 8) | ((unsigned int)(uuid.data4[7]));
  79
  80         return bLong ? QString().sprintf("%08x%08x%08x%08x", u1, u2, u3, u4) : QString().sprintf("%08x%08x", (u1 ^ u2), (u3 ^ u4));
  81 }
  82
  83 /*
  84  * Try to initialize the folder (with *write* access)
  85  */
  86 static QString lamexp_try_init_folder(const QString &folderPath)
  87 {
  88         static const char *TEST_DATA = "Lorem ipsum dolor sit amet, consectetur, adipisci velit!";
  89
  90         bool success = false;
  91
  92         const QFileInfo folderInfo(folderPath);
  93         const QDir folderDir(folderInfo.absoluteFilePath());
  94
  95         //Create folder, if it does *not* exist yet
  96         for(int i = 0; (i < 16) && (!folderDir.exists()); i++)
  97         {
  98                 folderDir.mkpath(".");
  99         }
 100
 101         //Make sure folder exists now *and* is writable
 102         if(folderDir.exists())
 103         {
 104                 const QByteArray testData = QByteArray(TEST_DATA);
 105                 for(int i = 0; (i < 32) && (!success); i++)
 106                 {
 107                         QFile testFile(folderDir.absoluteFilePath(QString("~%1.tmp").arg(lamexp_rand_str())));
 108                         if(testFile.open(QIODevice::ReadWrite | QIODevice::Truncate))
 109                         {
 110                                 if(testFile.write(testData) >= testData.size())
 111                                 {
 112                                         success = true;
 113                                 }
 114                                 testFile.remove();
 115                         }
 116                 }
 117         }
 118
 119         return (success ? folderDir.canonicalPath() : QString());
 120 }
 121
 122 /*
 123  * Initialize LameXP temp folder
 124  */
 125 #define INIT_TEMP_FOLDER_RAND(OUT_PTR, BASE_DIR) do \
 126 { \
 127         for(int _i = 0; _i < 128; _i++) \
 128         { \
 129                 const QString _randDir =  QString("%1/%2").arg((BASE_DIR), lamexp_rand_str()); \
 130                 if(!QDir(_randDir).exists()) \
 131                 { \
 132                         *(OUT_PTR) = lamexp_try_init_folder(_randDir); \
 133                         if(!(OUT_PTR)->isEmpty()) break; \
 134                 } \
 135         } \
 136 } \
 137 while(0)
 138
 139 /*
 140  * Get LameXP temp folder
 141  */
 142 const QString &lamexp_temp_folder2(void)
 143 {
 144         QReadLocker readLock(&g_lamexp_temp_folder.lock);
 145
 146         //Already initialized?
 147         if(g_lamexp_temp_folder.path && (!g_lamexp_temp_folder.path->isEmpty()))
 148         {
 149                 if(QDir(*g_lamexp_temp_folder.path).exists())
 150                 {
 151                         return *g_lamexp_temp_folder.path;
 152                 }
 153         }
 154
 155         //Obtain the write lock to initilaize
 156         readLock.unlock();
 157         QWriteLocker writeLock(&g_lamexp_temp_folder.lock);
 158
 159         //Still uninitilaized?
 160         if(g_lamexp_temp_folder.path && (!g_lamexp_temp_folder.path->isEmpty()))
 161         {
 162                 if(QDir(*g_lamexp_temp_folder.path).exists())
 163                 {
 164                         return *g_lamexp_temp_folder.path;
 165                 }
 166         }
 167
 168         //Create the string, if not done yet
 169         if(!g_lamexp_temp_folder.path)
 170         {
 171                 g_lamexp_temp_folder.path = new QString();
 172         }
 173
 174         g_lamexp_temp_folder.path->clear();
 175
 176         //Try the %TMP% or %TEMP% directory first
 177         QString tempPath = lamexp_try_init_folder(QDir::temp().absolutePath());
 178         if(!tempPath.isEmpty())
 179         {
 180                 INIT_TEMP_FOLDER_RAND(g_lamexp_temp_folder.path, tempPath);
 181         }
 182
 183         //Otherwise create TEMP folder in %LOCALAPPDATA% or %SYSTEMROOT%
 184         if(g_lamexp_temp_folder.path->isEmpty())
 185         {
 186                 qWarning("%%TEMP%% directory not found -> trying fallback mode now!");
 187                 static const lamexp_known_folder_t folderId[2] = { lamexp_folder_localappdata, lamexp_folder_systroot_dir };
 188                 for(size_t id = 0; (g_lamexp_temp_folder.path->isEmpty() && (id < 2)); id++)
 189                 {
 190                         const QString &knownFolder = lamexp_known_folder(folderId[id]);
 191                         if(!knownFolder.isEmpty())
 192                         {
 193                                 tempPath = lamexp_try_init_folder(QString("%1/Temp").arg(knownFolder));
 194                                 if(!tempPath.isEmpty())
 195                                 {
 196                                         INIT_TEMP_FOLDER_RAND(g_lamexp_temp_folder.path, tempPath);
 197                                 }
 198                         }
 199                 }
 200         }
 201
 202         //Failed to create TEMP folder?
 203         if(g_lamexp_temp_folder.path->isEmpty())
 204         {
 205                 qFatal("Temporary directory could not be initialized !!!");
 206         }
 207
 208         return *g_lamexp_temp_folder.path;
 209 }
 210
 211 /*
 212  * Setup QPorcess object
 213  */
 214 void lamexp_init_process(QProcess &process, const QString &wokringDir, const bool bReplaceTempDir)
 215 {
 216         //Environment variable names
 217         static const char *const s_envvar_names_temp[] =
 218         {
 219                 "TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE", "HOMEPATH", NULL
 220         };
 221         static const char *const s_envvar_names_remove[] =
 222         {
 223                 "WGETRC", "SYSTEM_WGETRC", "HTTP_PROXY", "FTP_PROXY", "NO_PROXY", "GNUPGHOME", "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME", "LANG", NULL
 224         };
 225
 226         //Initialize environment
 227         QProcessEnvironment env = process.processEnvironment();
 228         if(env.isEmpty()) env = QProcessEnvironment::systemEnvironment();
 229
 230         //Clean a number of enviroment variables that might affect our tools
 231         for(size_t i = 0; s_envvar_names_remove[i]; i++)
 232         {
 233                 env.remove(QString::fromLatin1(s_envvar_names_remove[i]));
 234                 env.remove(QString::fromLatin1(s_envvar_names_remove[i]).toLower());
 235         }
 236
 237         const QString tempDir = QDir::toNativeSeparators(lamexp_temp_folder2());
 238
 239         //Replace TEMP directory in environment
 240         if(bReplaceTempDir)
 241         {
 242                 for(size_t i = 0; s_envvar_names_temp[i]; i++)
 243                 {
 244                         env.insert(s_envvar_names_temp[i], tempDir);
 245                 }
 246         }
 247
 248         //Setup PATH variable
 249         const QString path = env.value("PATH", QString()).trimmed();
 250         env.insert("PATH", path.isEmpty() ? tempDir : QString("%1;%2").arg(tempDir, path));
 251
 252         //Setup QPorcess object
 253         process.setWorkingDirectory(wokringDir);
 254         process.setProcessChannelMode(QProcess::MergedChannels);
 255         process.setReadChannel(QProcess::StandardOutput);
 256         process.setProcessEnvironment(env);
 257 }
 258
 259 /*
 260  * Natural Order String Comparison - the 'lessThan' helper function
 261  */
 262 static bool lamexp_natural_string_sort_helper(const QString &str1, const QString &str2)
 263 {
 264         return (strnatcmp(QWCHAR(str1), QWCHAR(str2)) < 0);
 265 }
 266
 267 /*
 268  * Natural Order String Comparison - the 'lessThan' helper function *with* case folding
 269  */
 270 static bool lamexp_natural_string_sort_helper_fold_case(const QString &str1, const QString &str2)
 271 {
 272         return (strnatcasecmp(QWCHAR(str1), QWCHAR(str2)) < 0);
 273 }
 274
 275 /*
 276  * Natural Order String Comparison - the main sorting function
 277  */
 278 void lamexp_natural_string_sort(QStringList &list, const bool bIgnoreCase)
 279 {
 280         qSort(list.begin(), list.end(), bIgnoreCase ? lamexp_natural_string_sort_helper_fold_case : lamexp_natural_string_sort_helper);
 281 }
 282
 283 /*
 284  * Remove forbidden characters from a filename
 285  */
 286 const QString lamexp_clean_filename(const QString &str)
 287 {
 288         QString newStr(str);
 289         QRegExp rx("\"(.+)\"");
 290         rx.setMinimal(true);
 291
 292         newStr.replace("\\", "-");
 293         newStr.replace(" / ", ", ");
 294         newStr.replace("/", ",");
 295         newStr.replace(":", "-");
 296         newStr.replace("*", "x");
 297         newStr.replace("?", "");
 298         newStr.replace("<", "[");
 299         newStr.replace(">", "]");
 300         newStr.replace("|", "!");
 301         newStr.replace(rx, "`\\1´");
 302         newStr.replace("\"", "'");
 303
 304         return newStr.simplified();
 305 }
 306
 307 /*
 308  * Remove forbidden characters from a file path
 309  */
 310 const QString lamexp_clean_filepath(const QString &str)
 311 {
 312         QStringList parts = QString(str).replace("\\", "/").split("/");
 313
 314         for(int i = 0; i < parts.count(); i++)
 315         {
 316                 parts[i] = lamexp_clean_filename(parts[i]);
 317         }
 318
 319         return parts.join("/");
 320 }
 321
 322 /*
 323  * Get a list of all available Qt Text Codecs
 324  */
 325 QStringList lamexp_available_codepages(bool noAliases)
 326 {
 327         QStringList codecList;
 328
 329         QList<QByteArray> availableCodecs = QTextCodec::availableCodecs();
 330         while(!availableCodecs.isEmpty())
 331         {
 332                 QByteArray current = availableCodecs.takeFirst();
 333                 if(!(current.startsWith("system") || current.startsWith("System")))
 334                 {
 335                         codecList << QString::fromLatin1(current.constData(), current.size());
 336                         if(noAliases)
 337                         {
 338                                 if(QTextCodec *currentCodec = QTextCodec::codecForName(current.constData()))
 339                                 {
 340
 341                                         QList<QByteArray> aliases = currentCodec->aliases();
 342                                         while(!aliases.isEmpty()) availableCodecs.removeAll(aliases.takeFirst());
 343                                 }
 344                         }
 345                 }
 346         }
 347
 348         return codecList;
 349 }
 350
 351 /*
 352  * Robert Jenkins' 96 bit Mix Function
 353  * Source: http://www.concentric.net/~Ttwang/tech/inthash.htm
 354  */
 355 static unsigned int lamexp_mix(const unsigned int x, const unsigned int y, const unsigned int z)
 356 {
 357         unsigned int a = x;
 358         unsigned int b = y;
 359         unsigned int c = z;
 360
 361         a=a-b;  a=a-c;  a=a^(c >> 13);
 362         b=b-c;  b=b-a;  b=b^(a << 8);
 363         c=c-a;  c=c-b;  c=c^(b >> 13);
 364         a=a-b;  a=a-c;  a=a^(c >> 12);
 365         b=b-c;  b=b-a;  b=b^(a << 16);
 366         c=c-a;  c=c-b;  c=c^(b >> 5);
 367         a=a-b;  a=a-c;  a=a^(c >> 3);
 368         b=b-c;  b=b-a;  b=b^(a << 10);
 369         c=c-a;  c=c-b;  c=c^(b >> 15);
 370
 371         return c;
 372 }
 373
 374 /*
 375  * Seeds the random number generator
 376  * Note: Altough rand_s() doesn't need a seed, this must be called pripr to lamexp_rand(), just to to be sure!
 377  */
 378 void lamexp_seed_rand(void)
 379 {
 380         qsrand(lamexp_mix(clock(), time(NULL), _getpid()));
 381 }
 382
 383 /*
 384  * Returns a randum number
 385  * Note: This function uses rand_s() if available, but falls back to qrand() otherwise
 386  */
 387 unsigned int lamexp_rand(void)
 388 {
 389         quint32 rnd = 0;
 390
 391         if(rand_s(&rnd) == 0)
 392         {
 393                 return rnd;
 394         }
 395
 396         for(size_t i = 0; i < sizeof(unsigned int); i++)
 397         {
 398                 rnd = (rnd << 8) ^ qrand();
 399         }
 400
 401         return rnd;
 402 }
 403
 404 /*
 405  * Make a window blink (to draw user's attention)
 406  */
 407 void lamexp_blink_window(QWidget *poWindow, unsigned int count, unsigned int delay)
 408 {
 409         static QMutex blinkMutex;
 410
 411         const double maxOpac = 1.0;
 412         const double minOpac = 0.3;
 413         const double delOpac = 0.1;
 414
 415         if(!blinkMutex.tryLock())
 416         {
 417                 qWarning("Blinking is already in progress, skipping!");
 418                 return;
 419         }
 420
 421         try
 422         {
 423                 const int steps = static_cast<int>(ceil(maxOpac - minOpac) / delOpac);
 424                 const int sleep = static_cast<int>(floor(static_cast<double>(delay) / static_cast<double>(steps)));
 425                 const double opacity = poWindow->windowOpacity();
 426
 427                 for(unsigned int i = 0; i < count; i++)
 428                 {
 429                         for(double x = maxOpac; x >= minOpac; x -= delOpac)
 430                         {
 431                                 poWindow->setWindowOpacity(x);
 432                                 QApplication::processEvents();
 433                                 lamexp_sleep(sleep);
 434                         }
 435
 436                         for(double x = minOpac; x <= maxOpac; x += delOpac)
 437                         {
 438                                 poWindow->setWindowOpacity(x);
 439                                 QApplication::processEvents();
 440                                 lamexp_sleep(sleep);
 441                         }
 442                 }
 443
 444                 poWindow->setWindowOpacity(opacity);
 445                 QApplication::processEvents();
 446                 blinkMutex.unlock();
 447         }
 448         catch(...)
 449         {
 450                 blinkMutex.unlock();
 451                 qWarning("Exception error while blinking!");
 452         }
 453 }
 454
 455 /*
 456  * Clean folder
 457  */
 458 bool lamexp_clean_folder(const QString &folderPath)
 459 {
 460         QDir tempFolder(folderPath);
 461         if(tempFolder.exists())
 462         {
 463                 QFileInfoList entryList = tempFolder.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot | QDir::Hidden);
 464
 465                 for(int i = 0; i < entryList.count(); i++)
 466                 {
 467                         if(entryList.at(i).isDir())
 468                         {
 469                                 lamexp_clean_folder(entryList.at(i).canonicalFilePath());
 470                         }
 471                         else
 472                         {
 473                                 for(int j = 0; j < 3; j++)
 474                                 {
 475                                         if(lamexp_remove_file(entryList.at(i).canonicalFilePath()))
 476                                         {
 477                                                 break;
 478                                         }
 479                                 }
 480                         }
 481                 }
 482                 return tempFolder.rmdir(".");
 483         }
 484         return true;
 485 }
 486
 487 /*
 488  * Computus according to H. Lichtenberg
 489  */
 490 static bool lamexp_computus(const QDate &date)
 491 {
 492         int X = date.year();
 493         int A = X % 19;
 494         int K = X / 100;
 495         int M = 15 + (3*K + 3) / 4 - (8*K + 13) / 25;
 496         int D = (19*A + M) % 30;
 497         int S = 2 - (3*K + 3) / 4;
 498         int R = D / 29 + (D / 28 - D / 29) * (A / 11);
 499         int OG = 21 + D - R;
 500         int SZ = 7 - (X + X / 4 + S) % 7;
 501         int OE = 7 - (OG - SZ) % 7;
 502         int OS = (OG + OE);
 503
 504         if(OS > 31)
 505         {
 506                 return (date.month() == 4) && (date.day() == (OS - 31));
 507         }
 508         else
 509         {
 510                 return (date.month() == 3) && (date.day() == OS);
 511         }
 512 }
 513
 514 /*
 515  * Check for Thanksgiving
 516  */
 517 static bool lamexp_thanksgiving(const QDate &date)
 518 {
 519         int day = 0;
 520
 521         switch(QDate(date.year(), 11, 1).dayOfWeek())
 522         {
 523                 case 1: day = 25; break;
 524                 case 2: day = 24; break;
 525                 case 3: day = 23; break;
 526                 case 4: day = 22; break;
 527                 case 5: day = 28; break;
 528                 case 6: day = 27; break;
 529                 case 7: day = 26; break;
 530         }
 531
 532         return (date.month() == 11) && (date.day() == day);
 533 }
 534
 535 /*
 536  * Initialize app icon
 537  */
 538 const QIcon &lamexp_app_icon(void)
 539 {
 540         QReadLocker readLock(&g_lamexp_app_icon.lock);
 541
 542         //Already initialized?
 543         if(g_lamexp_app_icon.appIcon)
 544         {
 545                 return *g_lamexp_app_icon.appIcon;
 546         }
 547
 548         readLock.unlock();
 549         QWriteLocker writeLock(&g_lamexp_app_icon.lock);
 550
 551         while(!g_lamexp_app_icon.appIcon)
 552         {
 553                 QDate currentDate = QDate::currentDate();
 554                 QTime currentTime = QTime::currentTime();
 555
 556                 if(lamexp_thanksgiving(currentDate))
 557                 {
 558                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon6.png");
 559                 }
 560                 else if(((currentDate.month() == 12) && (currentDate.day() == 31) && (currentTime.hour() >= 20)) || ((currentDate.month() == 1) && (currentDate.day() == 1)  && (currentTime.hour() <= 19)))
 561                 {
 562                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon5.png");
 563                 }
 564                 else if(((currentDate.month() == 10) && (currentDate.day() == 31) && (currentTime.hour() >= 12)) || ((currentDate.month() == 11) && (currentDate.day() == 1)  && (currentTime.hour() <= 11)))
 565                 {
 566                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon4.png");
 567                 }
 568                 else if((currentDate.month() == 12) && (currentDate.day() >= 24) && (currentDate.day() <= 26))
 569                 {
 570                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon3.png");
 571                 }
 572                 else if(lamexp_computus(currentDate))
 573                 {
 574                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon2.png");
 575                 }
 576                 else
 577                 {
 578                         g_lamexp_app_icon.appIcon = new QIcon(":/MainIcon1.png");
 579                 }
 580         }
 581
 582         return *g_lamexp_app_icon.appIcon;
 583 }
 584
 585 /*
 586  * Broadcast event to all windows
 587  */
 588 bool lamexp_broadcast(int eventType, bool onlyToVisible)
 589 {
 590         if(QApplication *app = dynamic_cast<QApplication*>(QApplication::instance()))
 591         {
 592                 qDebug("Broadcasting %d", eventType);
 593
 594                 bool allOk = true;
 595                 QEvent poEvent(static_cast<QEvent::Type>(eventType));
 596                 QWidgetList list = app->topLevelWidgets();
 597
 598                 while(!list.isEmpty())
 599                 {
 600                         QWidget *widget = list.takeFirst();
 601                         if(!onlyToVisible || widget->isVisible())
 602                         {
 603                                 if(!app->sendEvent(widget, &poEvent))
 604                                 {
 605                                         allOk = false;
 606                                 }
 607                         }
 608                 }
 609
 610                 qDebug("Broadcast %d done (%s)", eventType, (allOk ? "OK" : "Stopped"));
 611                 return allOk;
 612         }
 613         else
 614         {
 615                 qWarning("Broadcast failed, could not get QApplication instance!");
 616                 return false;
 617         }
 618 }
 619
 620 ///////////////////////////////////////////////////////////////////////////////
 621 // INITIALIZATION
 622 ///////////////////////////////////////////////////////////////////////////////
 623
 624 extern "C" void _lamexp_global_init_utils(void)
 625 {
 626         LAMEXP_ZERO_MEMORY(g_lamexp_temp_folder);
 627         LAMEXP_ZERO_MEMORY(g_lamexp_app_icon);
 628 }
 629
 630 ///////////////////////////////////////////////////////////////////////////////
 631 // FINALIZATION
 632 ///////////////////////////////////////////////////////////////////////////////
 633
 634 extern "C" void _lamexp_global_free_utils(void)
 635 {
 636         //Delete temporary files
 637         const QString &tempFolder = lamexp_temp_folder2();
 638         if(!tempFolder.isEmpty())
 639         {
 640                 bool success = false;
 641                 for(int i = 0; i < 100; i++)
 642                 {
 643                         if(lamexp_clean_folder(tempFolder))
 644                         {
 645                                 success = true;
 646                                 break;
 647                         }
 648                         lamexp_sleep(100);
 649                 }
 650                 if(!success)
 651                 {
 652                         lamexp_system_message(L"Sorry, LameXP was unable to clean up all temporary files. Some residual files in your TEMP directory may require manual deletion!", lamexp_beep_warning);
 653                         lamexp_exec_shell(NULL, tempFolder, QString(), QString(), true);
 654                 }
 655         }
 656
 657         //Free memory
 658         LAMEXP_DELETE(g_lamexp_temp_folder.path);
 659         LAMEXP_DELETE(g_lamexp_app_icon.appIcon);
 660 }