OSDN Git Service

Improved VapourSynth detection code.
[x264-launcher/x264-launcher.git] / src / win_main.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Simple x264 Launcher
3 // Copyright (C) 2004-2015 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 "win_main.h"
23 #include "UIC_win_main.h"
24
25 //Internal
26 #include "global.h"
27 #include "cli.h"
28 #include "ipc.h"
29 #include "model_status.h"
30 #include "model_sysinfo.h"
31 #include "model_jobList.h"
32 #include "model_options.h"
33 #include "model_preferences.h"
34 #include "model_recently.h"
35 #include "thread_avisynth.h"
36 #include "thread_vapoursynth.h"
37 #include "thread_encode.h"
38 #include "thread_ipc_recv.h"
39 #include "input_filter.h"
40 #include "win_addJob.h"
41 #include "win_about.h"
42 #include "win_preferences.h"
43 #include "win_updater.h"
44 #include "binaries.h"
45 #include "resource.h"
46
47 //MUtils
48 #include <MUtils/OSSupport.h>
49 #include <MUtils/CPUFeatures.h>
50 #include <MUtils/IPCChannel.h>
51 #include <MUtils/GUI.h>
52 #include <MUtils/Sound.h>
53 #include <MUtils/Exception.h>
54 #include <MUtils/Taskbar7.h>
55 #include <MUtils/Version.h>
56
57 //Qt
58 #include <QDate>
59 #include <QTimer>
60 #include <QCloseEvent>
61 #include <QMessageBox>
62 #include <QDesktopServices>
63 #include <QUrl>
64 #include <QDir>
65 #include <QLibrary>
66 #include <QProcess>
67 #include <QProgressDialog>
68 #include <QScrollBar>
69 #include <QTextStream>
70 #include <QSettings>
71 #include <QFileDialog>
72 #include <QSystemTrayIcon>
73
74 #include <ctime>
75
76 //Constants
77 static const char *tpl_last   = "<LAST_USED>";
78 static const char *home_url   = "http://muldersoft.com/";
79 static const char *update_url = "https://github.com/lordmulder/Simple-x264-Launcher/releases/latest";
80 static const char *avs_dl_url = "http://sourceforge.net/projects/avisynth2/files/AviSynth%202.5/";
81 static const char *python_url = "https://www.python.org/downloads/";
82 static const char *vsynth_url = "http://www.vapoursynth.com/";
83 static const int   vsynth_rev = 24;
84
85 //Macros
86 #define SET_FONT_BOLD(WIDGET,BOLD) do { QFont _font = WIDGET->font(); _font.setBold(BOLD); WIDGET->setFont(_font); } while(0)
87 #define SET_TEXT_COLOR(WIDGET,COLOR) do { QPalette _palette = WIDGET->palette(); _palette.setColor(QPalette::WindowText, (COLOR)); _palette.setColor(QPalette::Text, (COLOR)); WIDGET->setPalette(_palette); } while(0)
88 #define LINK(URL) (QString("<a href=\"%1\">%1</a>").arg((URL)))
89 #define INIT_ERROR_EXIT() do { close(); qApp->exit(-1); return; } while(0)
90 #define NEXT(X) ((*reinterpret_cast<int*>(&(X)))++)
91 #define SETUP_WEBLINK(OBJ, URL) do { (OBJ)->setData(QVariant(QUrl(URL))); connect((OBJ), SIGNAL(triggered()), this, SLOT(showWebLink())); } while(0)
92 #define APP_IS_READY (m_initialized && (!m_fileTimer->isActive()) && (QApplication::activeModalWidget() == NULL))
93 #define ENSURE_APP_IS_READY() do { if(!APP_IS_READY) {          MUtils::Sound::beep(MUtils::Sound::BEEP_WRN); qWarning("Cannot perfrom this action at this time!"); return; } } while(0)
94 #define X264_STRCMP(X,Y) ((X).compare((Y), Qt::CaseInsensitive) == 0)
95
96 ///////////////////////////////////////////////////////////////////////////////
97 // Constructor & Destructor
98 ///////////////////////////////////////////////////////////////////////////////
99
100 /*
101  * Constructor
102  */
103 MainWindow::MainWindow(const MUtils::CPUFetaures::cpu_info_t &cpuFeatures, MUtils::IPCChannel *const ipcChannel)
104 :
105         m_ipcChannel(ipcChannel),
106         m_sysinfo(NULL),
107         m_options(NULL),
108         m_jobList(NULL),
109         m_pendingFiles(new QStringList()),
110         m_preferences(NULL),
111         m_recentlyUsed(NULL),
112         m_initialized(false),
113         ui(new Ui::MainWindow())
114 {
115         //Init the dialog, from the .ui file
116         ui->setupUi(this);
117         setWindowFlags(windowFlags() & (~Qt::WindowMaximizeButtonHint));
118
119         //Register meta types
120         qRegisterMetaType<QUuid>("QUuid");
121         qRegisterMetaType<QUuid>("DWORD");
122         qRegisterMetaType<JobStatus>("JobStatus");
123
124         //Create and initialize the sysinfo object
125         m_sysinfo.reset(new SysinfoModel());
126         m_sysinfo->setAppPath(QApplication::applicationDirPath());
127         m_sysinfo->setMMXSupport(cpuFeatures.features && MUtils::CPUFetaures::FLAG_MMX);
128         m_sysinfo->setSSESupport(cpuFeatures.features && MUtils::CPUFetaures::FLAG_SSE); //SSE implies MMX2
129         m_sysinfo->setX64Support(cpuFeatures.x64 && (cpuFeatures.features && MUtils::CPUFetaures::FLAG_SSE2)); //X64 implies SSE2
130
131         //Load preferences
132         m_preferences.reset(new PreferencesModel());
133         PreferencesModel::loadPreferences(m_preferences.data());
134
135         //Load recently used
136         m_recentlyUsed.reset(new RecentlyUsed());
137         RecentlyUsed::loadRecentlyUsed(m_recentlyUsed.data());
138
139         //Create options object
140         m_options.reset(new OptionsModel(m_sysinfo.data()));
141         OptionsModel::loadTemplate(m_options.data(), QString::fromLatin1(tpl_last));
142
143         //Freeze minimum size
144         setMinimumSize(size());
145         ui->splitter->setSizes(QList<int>() << 16 << 196);
146
147         //Update title
148         ui->labelBuildDate->setText(tr("Built on %1 at %2").arg(MUtils::Version::app_build_date().toString(Qt::ISODate), MUtils::Version::app_build_time().toString(Qt::ISODate)));
149         
150         if(MUTILS_DEBUG)
151         {
152                 setWindowTitle(QString("%1 | !!! DEBUG VERSION !!!").arg(windowTitle()));
153                 setStyleSheet("QMenuBar, QMainWindow { background-color: yellow }");
154         }
155         else if(x264_is_prerelease())
156         {
157                 setWindowTitle(QString("%1 | PRE-RELEASE VERSION").arg(windowTitle()));
158         }
159         
160         //Create model
161         m_jobList.reset(new JobListModel(m_preferences.data()));
162         connect(m_jobList.data(), SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(jobChangedData(QModelIndex, QModelIndex)));
163         ui->jobsView->setModel(m_jobList.data());
164         
165         //Setup view
166         ui->jobsView->horizontalHeader()->setSectionHidden(3, true);
167         ui->jobsView->horizontalHeader()->setResizeMode(0, QHeaderView::Stretch);
168         ui->jobsView->horizontalHeader()->setResizeMode(1, QHeaderView::Fixed);
169         ui->jobsView->horizontalHeader()->setResizeMode(2, QHeaderView::Fixed);
170         ui->jobsView->horizontalHeader()->resizeSection(1, 150);
171         ui->jobsView->horizontalHeader()->resizeSection(2, 90);
172         ui->jobsView->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
173         connect(ui->jobsView->selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)), this, SLOT(jobSelected(QModelIndex, QModelIndex)));
174
175         //Setup key listener
176         m_inputFilter_jobList.reset(new InputEventFilter(ui->jobsView));
177         m_inputFilter_jobList->addKeyFilter(Qt::ControlModifier | Qt::Key_Up,   1);
178         m_inputFilter_jobList->addKeyFilter(Qt::ControlModifier | Qt::Key_Down, 2);
179         connect(m_inputFilter_jobList.data(), SIGNAL(keyPressed(int)), this, SLOT(jobListKeyPressed(int)));
180         
181         //Setup mouse listener
182         m_inputFilter_version.reset(new InputEventFilter(ui->labelBuildDate));
183         m_inputFilter_version->addMouseFilter(Qt::LeftButton,  0);
184         m_inputFilter_version->addMouseFilter(Qt::RightButton, 0);
185         connect(m_inputFilter_version.data(), SIGNAL(mouseClicked(int)), this, SLOT(versionLabelMouseClicked(int)));
186
187         //Create context menu
188         QAction *actionClipboard = new QAction(QIcon(":/buttons/page_paste.png"), tr("Copy to Clipboard"), ui->logView);
189         actionClipboard->setEnabled(false);
190         ui->logView->addAction(actionClipboard);
191         connect(actionClipboard, SIGNAL(triggered(bool)), this, SLOT(copyLogToClipboard(bool)));
192         ui->jobsView->addActions(ui->menuJob->actions());
193
194         //Enable buttons
195         connect(ui->buttonAddJob,       SIGNAL(clicked()),     this, SLOT(addButtonPressed()      ));
196         connect(ui->buttonStartJob,     SIGNAL(clicked()),     this, SLOT(startButtonPressed()    ));
197         connect(ui->buttonAbortJob,     SIGNAL(clicked()),     this, SLOT(abortButtonPressed()    ));
198         connect(ui->buttonPauseJob,     SIGNAL(toggled(bool)), this, SLOT(pauseButtonPressed(bool)));
199         connect(ui->actionJob_Delete,   SIGNAL(triggered()),   this, SLOT(deleteButtonPressed()   ));
200         connect(ui->actionJob_Restart,  SIGNAL(triggered()),   this, SLOT(restartButtonPressed()  ));
201         connect(ui->actionJob_Browse,   SIGNAL(triggered()),   this, SLOT(browseButtonPressed()   ));
202         connect(ui->actionJob_MoveUp,   SIGNAL(triggered()),   this, SLOT(moveButtonPressed()     ));
203         connect(ui->actionJob_MoveDown, SIGNAL(triggered()),   this, SLOT(moveButtonPressed()     ));
204
205         //Enable menu
206         connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(openActionTriggered()));
207         connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(showAbout()));
208         connect(ui->actionPreferences, SIGNAL(triggered()), this, SLOT(showPreferences()));
209         connect(ui->actionCheckForUpdates, SIGNAL(triggered()), this, SLOT(checkUpdates()));
210
211         //Setup web-links
212         SETUP_WEBLINK(ui->actionWebMulder,          home_url);
213         SETUP_WEBLINK(ui->actionWebX264,            "http://www.videolan.org/developers/x264.html");
214         SETUP_WEBLINK(ui->actionWebX265,            "http://www.videolan.org/developers/x265.html");
215         SETUP_WEBLINK(ui->actionWebKomisar,         "http://komisar.gin.by/");
216         SETUP_WEBLINK(ui->actionWebVideoLAN,        "http://download.videolan.org/pub/x264/binaries/");
217         SETUP_WEBLINK(ui->actionWebJEEB,            "http://x264.fushizen.eu/");
218         SETUP_WEBLINK(ui->actionWebFreeCodecs,      "http://www.free-codecs.com/x264_video_codec_download.htm");
219         SETUP_WEBLINK(ui->actionWebX265BinRU,       "http://x265.ru/en/builds/");
220         SETUP_WEBLINK(ui->actionWebX265BinEU,       "http://builds.x265.eu/");
221         SETUP_WEBLINK(ui->actionWebX265BinORG,      "http://chromashift.org/x265_builds/");
222         SETUP_WEBLINK(ui->actionWebX265BinFF,       "http://ffmpeg.zeranoe.com/builds/");
223         SETUP_WEBLINK(ui->actionWebAvisynth32,      "http://sourceforge.net/projects/avisynth2/files/AviSynth%202.5/");
224         SETUP_WEBLINK(ui->actionWebAvisynth64,      "http://code.google.com/p/avisynth64/downloads/list");
225         SETUP_WEBLINK(ui->actionWebAvisynthPlus,    "http://www.avs-plus.net/");
226         SETUP_WEBLINK(ui->actionWebVapourSynth,     "http://www.vapoursynth.com/");
227         SETUP_WEBLINK(ui->actionWebVapourSynthDocs, "http://www.vapoursynth.com/doc/");
228         SETUP_WEBLINK(ui->actionOnlineDocX264,      "http://mewiki.project357.com/wiki/X264_Settings");
229         SETUP_WEBLINK(ui->actionOnlineDocX265,      "http://x265.readthedocs.org/en/default/");
230         SETUP_WEBLINK(ui->actionWebBluRay,          "http://www.x264bluray.com/");
231         SETUP_WEBLINK(ui->actionWebAvsWiki,         "http://avisynth.nl/index.php/Main_Page#Usage");
232         SETUP_WEBLINK(ui->actionWebSupport,         "http://forum.doom9.org/showthread.php?t=144140");
233         SETUP_WEBLINK(ui->actionWebSecret,          "http://www.youtube.com/watch_popup?v=AXIeHY-OYNI");
234
235         //Create floating label
236         m_label.reset(new QLabel(ui->jobsView->viewport()));
237         m_label->setText(tr("No job created yet. Please click the 'Add New Job' button!"));
238         m_label->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
239         SET_TEXT_COLOR(m_label, Qt::darkGray);
240         SET_FONT_BOLD(m_label, true);
241         m_label->setVisible(true);
242         m_label->setContextMenuPolicy(Qt::ActionsContextMenu);
243         m_label->addActions(ui->jobsView->actions());
244         connect(ui->splitter, SIGNAL(splitterMoved(int, int)), this, SLOT(updateLabelPos()));
245         updateLabelPos();
246
247         //Init system tray icon
248         m_sysTray.reset(new QSystemTrayIcon(this));
249         m_sysTray->setToolTip(this->windowTitle());
250         m_sysTray->setIcon(this->windowIcon());
251         connect(m_sysTray.data(), SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(sysTrayActived()));
252
253         //Init taskbar progress
254         m_taskbar.reset(new MUtils::Taskbar7(this));
255
256         //Create corner widget
257         QLabel *checkUp = new QLabel(ui->menubar);
258         checkUp->setText(QString("<nobr><img src=\":/buttons/exclamation_small.png\">&nbsp;<b style=\"color:darkred\">%1</b>&nbsp;&nbsp;&nbsp;</nobr>").arg(tr("Check for Updates")));
259         checkUp->setFixedHeight(ui->menubar->height());
260         checkUp->setCursor(QCursor(Qt::PointingHandCursor));
261         m_inputFilter_checkUp.reset(new InputEventFilter(checkUp));
262         m_inputFilter_checkUp->addMouseFilter(Qt::LeftButton,  0);
263         m_inputFilter_checkUp->addMouseFilter(Qt::RightButton, 0);
264         connect(m_inputFilter_checkUp.data(), SIGNAL(mouseClicked(int)), this, SLOT(checkUpdates()));
265         checkUp->hide();
266         ui->menubar->setCornerWidget(checkUp);
267
268         //Create timer
269         m_fileTimer.reset(new QTimer(this));
270         connect(m_fileTimer.data(), SIGNAL(timeout()), this, SLOT(handlePendingFiles()));
271 }
272
273 /*
274  * Destructor
275  */
276 MainWindow::~MainWindow(void)
277 {
278         OptionsModel::saveTemplate(m_options.data(), QString::fromLatin1(tpl_last));
279         
280         while(!m_toolsList->isEmpty())
281         {
282                 QFile *temp = m_toolsList->takeFirst();
283                 MUTILS_DELETE(temp);
284         }
285
286         if(!m_ipcThread.isNull())
287         {
288                 m_ipcThread->stop();
289                 if(!m_ipcThread->wait(5000))
290                 {
291                         m_ipcThread->terminate();
292                         m_ipcThread->wait();
293                 }
294         }
295
296         delete ui;
297 }
298
299 ///////////////////////////////////////////////////////////////////////////////
300 // Slots
301 ///////////////////////////////////////////////////////////////////////////////
302
303 /*
304  * The "add" button was clicked
305  */
306 void MainWindow::addButtonPressed()
307 {
308         ENSURE_APP_IS_READY();
309
310         qDebug("MainWindow::addButtonPressed");
311         bool runImmediately = (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
312         QString sourceFileName, outputFileName;
313
314         if(createJob(sourceFileName, outputFileName, m_options.data(), runImmediately))
315         {
316                 appendJob(sourceFileName, outputFileName, m_options.data(), runImmediately);
317         }
318 }
319
320 /*
321  * The "open" action was triggered
322  */
323 void MainWindow::openActionTriggered()
324 {
325         ENSURE_APP_IS_READY();
326
327         QStringList fileList = QFileDialog::getOpenFileNames(this, tr("Open Source File(s)"), m_recentlyUsed->sourceDirectory(), AddJobDialog::getInputFilterLst(), NULL, QFileDialog::DontUseNativeDialog);
328         if(!fileList.empty())
329         {
330                 m_recentlyUsed->setSourceDirectory(QFileInfo(fileList.last()).absolutePath());
331                 if(fileList.count() > 1)
332                 {
333                         createJobMultiple(fileList);
334                 }
335                 else
336                 {
337                         bool runImmediately = (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
338                         QString sourceFileName(fileList.first()), outputFileName;
339                         if(createJob(sourceFileName, outputFileName, m_options.data(), runImmediately))
340                         {
341                                 appendJob(sourceFileName, outputFileName, m_options.data(), runImmediately);
342                         }
343                 }
344         }
345 }
346
347 /*
348  * The "start" button was clicked
349  */
350 void MainWindow::startButtonPressed(void)
351 {
352         ENSURE_APP_IS_READY();
353         m_jobList->startJob(ui->jobsView->currentIndex());
354 }
355
356 /*
357  * The "abort" button was clicked
358  */
359 void MainWindow::abortButtonPressed(void)
360 {
361         ENSURE_APP_IS_READY();
362
363         if(QMessageBox::question(this, tr("Abort Job?"), tr("<nobr>Do you really want to <b>abort</b> the selected job now?</nobr>"), tr("Back"), tr("Abort Job")) == 1)
364         {
365                 m_jobList->abortJob(ui->jobsView->currentIndex());
366         }
367 }
368
369 /*
370  * The "delete" button was clicked
371  */
372 void MainWindow::deleteButtonPressed(void)
373 {
374         ENSURE_APP_IS_READY();
375
376         m_jobList->deleteJob(ui->jobsView->currentIndex());
377         m_label->setVisible(m_jobList->rowCount(QModelIndex()) == 0);
378 }
379
380 /*
381  * The "browse" button was clicked
382  */
383 void MainWindow::browseButtonPressed(void)
384 {
385         ENSURE_APP_IS_READY();
386
387         QString outputFile = m_jobList->getJobOutputFile(ui->jobsView->currentIndex());
388         if((!outputFile.isEmpty()) && QFileInfo(outputFile).exists() && QFileInfo(outputFile).isFile())
389         {
390                 QProcess::startDetached(QString::fromLatin1("explorer.exe"), QStringList() << QString::fromLatin1("/select,") << QDir::toNativeSeparators(outputFile), QFileInfo(outputFile).path());
391         }
392         else
393         {
394                 QMessageBox::warning(this, tr("Not Found"), tr("Sorry, the output file could not be found!"));
395         }
396 }
397
398 /*
399  * The "browse" button was clicked
400  */
401 void MainWindow::moveButtonPressed(void)
402 {
403         ENSURE_APP_IS_READY();
404
405         if(sender() == ui->actionJob_MoveUp)
406         {
407                 qDebug("Move job %d (direction: UP)", ui->jobsView->currentIndex().row());
408                 if(!m_jobList->moveJob(ui->jobsView->currentIndex(), JobListModel::MOVE_UP))
409                 {
410                         MUtils::Sound::beep(MUtils::Sound::BEEP_ERR);
411                 }
412                 ui->jobsView->scrollTo(ui->jobsView->currentIndex(), QAbstractItemView::PositionAtCenter);
413         }
414         else if(sender() == ui->actionJob_MoveDown)
415         {
416                 qDebug("Move job %d (direction: DOWN)", ui->jobsView->currentIndex().row());
417                 if(!m_jobList->moveJob(ui->jobsView->currentIndex(), JobListModel::MOVE_DOWN))
418                 {
419                         MUtils::Sound::beep(MUtils::Sound::BEEP_ERR);
420                 }
421                 ui->jobsView->scrollTo(ui->jobsView->currentIndex(), QAbstractItemView::PositionAtCenter);
422         }
423         else
424         {
425                 qWarning("[moveButtonPressed] Error: Unknown sender!");
426         }
427 }
428
429 /*
430  * The "pause" button was clicked
431  */
432 void MainWindow::pauseButtonPressed(bool checked)
433 {
434         if(!APP_IS_READY)
435         {
436                 MUtils::Sound::beep(MUtils::Sound::BEEP_WRN);
437                 qWarning("Cannot perfrom this action at this time!");
438                 ui->buttonPauseJob->setChecked(!checked);
439         }
440
441         if(checked)
442         {
443                 m_jobList->pauseJob(ui->jobsView->currentIndex());
444         }
445         else
446         {
447                 m_jobList->resumeJob(ui->jobsView->currentIndex());
448         }
449 }
450
451 /*
452  * The "restart" button was clicked
453  */
454 void MainWindow::restartButtonPressed(void)
455 {
456         ENSURE_APP_IS_READY();
457
458         const QModelIndex index = ui->jobsView->currentIndex();
459         const OptionsModel *options = m_jobList->getJobOptions(index);
460         QString sourceFileName = m_jobList->getJobSourceFile(index);
461         QString outputFileName = m_jobList->getJobOutputFile(index);
462
463         if((options) && (!sourceFileName.isEmpty()) && (!outputFileName.isEmpty()))
464         {
465                 bool runImmediately = (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
466                 OptionsModel *tempOptions = new OptionsModel(*options);
467                 if(createJob(sourceFileName, outputFileName, tempOptions, runImmediately, true))
468                 {
469                         appendJob(sourceFileName, outputFileName, tempOptions, runImmediately);
470                 }
471                 MUTILS_DELETE(tempOptions);
472         }
473 }
474
475 /*
476  * Job item selected by user
477  */
478 void MainWindow::jobSelected(const QModelIndex & current, const QModelIndex & previous)
479 {
480         qDebug("Job selected: %d", current.row());
481         
482         if(ui->logView->model())
483         {
484                 disconnect(ui->logView->model(), SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(jobLogExtended(QModelIndex, int, int)));
485         }
486         
487         if(current.isValid())
488         {
489                 ui->logView->setModel(m_jobList->getLogFile(current));
490                 connect(ui->logView->model(), SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(jobLogExtended(QModelIndex, int, int)));
491                 ui->logView->actions().first()->setEnabled(true);
492                 QTimer::singleShot(0, ui->logView, SLOT(scrollToBottom()));
493
494                 ui->progressBar->setValue(m_jobList->getJobProgress(current));
495                 ui->editDetails->setText(m_jobList->data(m_jobList->index(current.row(), 3, QModelIndex()), Qt::DisplayRole).toString());
496                 updateButtons(m_jobList->getJobStatus(current));
497                 updateTaskbar(m_jobList->getJobStatus(current), m_jobList->data(m_jobList->index(current.row(), 0, QModelIndex()), Qt::DecorationRole).value<QIcon>());
498         }
499         else
500         {
501                 ui->logView->setModel(NULL);
502                 ui->logView->actions().first()->setEnabled(false);
503                 ui->progressBar->setValue(0);
504                 ui->editDetails->clear();
505                 updateButtons(JobStatus_Undefined);
506                 updateTaskbar(JobStatus_Undefined, QIcon());
507         }
508
509         ui->progressBar->repaint();
510 }
511
512 /*
513  * Handle update of job info (status, progress, details, etc)
514  */
515 void MainWindow::jobChangedData(const QModelIndex &topLeft, const  QModelIndex &bottomRight)
516 {
517         int selected = ui->jobsView->currentIndex().row();
518         
519         if(topLeft.column() <= 1 && bottomRight.column() >= 1) /*STATUS*/
520         {
521                 for(int i = topLeft.row(); i <= bottomRight.row(); i++)
522                 {
523                         JobStatus status = m_jobList->getJobStatus(m_jobList->index(i, 0, QModelIndex()));
524                         if(i == selected)
525                         {
526                                 qDebug("Current job changed status!");
527                                 updateButtons(status);
528                                 updateTaskbar(status, m_jobList->data(m_jobList->index(i, 0, QModelIndex()), Qt::DecorationRole).value<QIcon>());
529                         }
530                         if((status == JobStatus_Completed) || (status == JobStatus_Failed))
531                         {
532                                 if(m_preferences->getAutoRunNextJob()) QTimer::singleShot(0, this, SLOT(launchNextJob()));
533                                 if(m_preferences->getSaveLogFiles()) saveLogFile(m_jobList->index(i, 1, QModelIndex()));
534                         }
535                 }
536         }
537         if(topLeft.column() <= 2 && bottomRight.column() >= 2) /*PROGRESS*/
538         {
539                 for(int i = topLeft.row(); i <= bottomRight.row(); i++)
540                 {
541                         if(i == selected)
542                         {
543                                 ui->progressBar->setValue(m_jobList->getJobProgress(m_jobList->index(i, 0, QModelIndex())));
544                                 if(!m_taskbar.isNull())
545                                 {
546                                         m_taskbar->setTaskbarProgress(ui->progressBar->value(), ui->progressBar->maximum());
547                                 }
548                                 break;
549                         }
550                 }
551         }
552         if(topLeft.column() <= 3 && bottomRight.column() >= 3) /*DETAILS*/
553         {
554                 for(int i = topLeft.row(); i <= bottomRight.row(); i++)
555                 {
556                         if(i == selected)
557                         {
558                                 ui->editDetails->setText(m_jobList->data(m_jobList->index(i, 3, QModelIndex()), Qt::DisplayRole).toString());
559                                 break;
560                         }
561                 }
562         }
563 }
564
565 /*
566  * Handle new log file content
567  */
568 void MainWindow::jobLogExtended(const QModelIndex & parent, int start, int end)
569 {
570         QTimer::singleShot(0, ui->logView, SLOT(scrollToBottom()));
571 }
572
573 /*
574  * About screen
575  */
576 void MainWindow::showAbout(void)
577 {
578         ENSURE_APP_IS_READY();
579         
580         if(AboutDialog *aboutDialog = new AboutDialog(this))
581         {
582                 aboutDialog->exec();
583                 MUTILS_DELETE(aboutDialog);
584         }
585 }
586
587 /*
588  * Open web-link
589  */
590 void MainWindow::showWebLink(void)
591 {
592         ENSURE_APP_IS_READY();
593         
594         if(QObject *obj = QObject::sender())
595         {
596                 if(QAction *action = dynamic_cast<QAction*>(obj))
597                 {
598                         if(action->data().type() == QVariant::Url)
599                         {
600                                 QDesktopServices::openUrl(action->data().toUrl());
601                         }
602                 }
603         }
604 }
605
606 /*
607  * Pereferences dialog
608  */
609 void MainWindow::showPreferences(void)
610 {
611         ENSURE_APP_IS_READY();
612
613         PreferencesDialog *preferences = new PreferencesDialog(this, m_preferences.data(), m_sysinfo.data());
614         preferences->exec();
615
616         MUTILS_DELETE(preferences);
617 }
618
619 /*
620  * Launch next job, after running job has finished
621  */
622 void MainWindow::launchNextJob(void)
623 {
624         qDebug("Launching next job...");
625
626         if(countRunningJobs() >= m_preferences->getMaxRunningJobCount())
627         {
628                 qDebug("Still have too many jobs running, won't launch next one yet!");
629                 return;
630         }
631
632         const int rows = m_jobList->rowCount(QModelIndex());
633
634         for(int i = 0; i < rows; i++)
635         {
636                 const QModelIndex currentIndex = m_jobList->index(i, 0, QModelIndex());
637                 if(m_jobList->getJobStatus(currentIndex) == JobStatus_Enqueued)
638                 {
639                         if(m_jobList->startJob(currentIndex))
640                         {
641                                 ui->jobsView->selectRow(currentIndex.row());
642                                 return;
643                         }
644                 }
645         }
646                 
647         qWarning("No enqueued jobs left to be started!");
648
649         if(m_preferences->getShutdownComputer())
650         {
651                 QTimer::singleShot(0, this, SLOT(shutdownComputer()));
652         }
653 }
654
655 /*
656  * Save log to text file
657  */
658 void MainWindow::saveLogFile(const QModelIndex &index)
659 {
660         if(index.isValid())
661         {
662                 if(LogFileModel *log = m_jobList->getLogFile(index))
663                 {
664                         QDir(QString("%1/logs").arg(x264_data_path())).mkpath(".");
665                         QString logFilePath = QString("%1/logs/LOG.%2.%3.txt").arg(x264_data_path(), QDate::currentDate().toString(Qt::ISODate), QTime::currentTime().toString(Qt::ISODate).replace(':', "-"));
666                         QFile outFile(logFilePath);
667                         if(outFile.open(QIODevice::WriteOnly))
668                         {
669                                 QTextStream outStream(&outFile);
670                                 outStream.setCodec("UTF-8");
671                                 outStream.setGenerateByteOrderMark(true);
672                                 
673                                 const int rows = log->rowCount(QModelIndex());
674                                 for(int i = 0; i < rows; i++)
675                                 {
676                                         outStream << log->data(log->index(i, 0, QModelIndex()), Qt::DisplayRole).toString() << QLatin1String("\r\n");
677                                 }
678                                 outFile.close();
679                         }
680                         else
681                         {
682                                 qWarning("Failed to open log file for writing:\n%s", logFilePath.toUtf8().constData());
683                         }
684                 }
685         }
686 }
687
688 /*
689  * Shut down the computer (with countdown)
690  */
691 void MainWindow::shutdownComputer(void)
692 {
693         ENSURE_APP_IS_READY();
694
695         if(countPendingJobs() > 0)
696         {
697                 qDebug("Still have pending jobs, won't shutdown yet!");
698                 return;
699         }
700
701         const int iTimeout = 30;
702         const Qt::WindowFlags flags = Qt::WindowStaysOnTopHint | Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowSystemMenuHint;
703         const QString text = QString("%1%2%1").arg(QString().fill(' ', 18), tr("Warning: Computer will shutdown in %1 seconds..."));
704         
705         qWarning("Initiating shutdown sequence!");
706         
707         QProgressDialog progressDialog(text.arg(iTimeout), tr("Cancel Shutdown"), 0, iTimeout + 1, this, flags);
708         QPushButton *cancelButton = new QPushButton(tr("Cancel Shutdown"), &progressDialog);
709         cancelButton->setIcon(QIcon(":/buttons/power_on.png"));
710         progressDialog.setModal(true);
711         progressDialog.setAutoClose(false);
712         progressDialog.setAutoReset(false);
713         progressDialog.setWindowIcon(QIcon(":/buttons/power_off.png"));
714         progressDialog.setWindowTitle(windowTitle());
715         progressDialog.setCancelButton(cancelButton);
716         progressDialog.show();
717         
718         QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
719         QApplication::setOverrideCursor(Qt::WaitCursor);
720         MUtils::Sound::play_sound("shutdown", false);
721         QApplication::restoreOverrideCursor();
722         
723         QTimer timer;
724         timer.setInterval(1000);
725         timer.start();
726
727         QEventLoop eventLoop(this);
728         connect(&timer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
729         connect(&progressDialog, SIGNAL(canceled()), &eventLoop, SLOT(quit()));
730
731         for(int i = 1; i <= iTimeout; i++)
732         {
733                 eventLoop.exec();
734                 if(progressDialog.wasCanceled())
735                 {
736                         progressDialog.close();
737                         return;
738                 }
739                 progressDialog.setValue(i+1);
740                 progressDialog.setLabelText(text.arg(iTimeout-i));
741                 if(iTimeout-i == 3) progressDialog.setCancelButton(NULL);
742                 QApplication::processEvents();
743                 MUtils::Sound::play_sound(((i < iTimeout) ? "beep" : "beep2"), false);
744         }
745         
746         qWarning("Shutting down !!!");
747
748         if(MUtils::OS::shutdown_computer("Simple x264 Launcher: All jobs completed, shutting down!", 10, true, false))
749         {
750                 qApp->closeAllWindows();
751         }
752
753 }
754
755 /*
756  * Main initialization function (called only once!)
757  */
758 void MainWindow::init(void)
759 {
760         if(m_initialized)
761         {
762                 qWarning("Already initialized -> skipping!");
763                 return;
764         }
765
766         updateLabelPos();
767         const MUtils::OS::ArgumentMap &arguments = MUtils::OS::arguments();
768
769         //---------------------------------------
770         // Check required binaries
771         //---------------------------------------
772
773         QStringList binFiles;
774         for(OptionsModel::EncArch arch = OptionsModel::EncArch_x32; arch <= OptionsModel::EncArch_x64; NEXT(arch))
775         {
776                 for(OptionsModel::EncType encdr = OptionsModel::EncType_X264; encdr <= OptionsModel::EncType_X265; NEXT(encdr))
777                 {
778                         for(OptionsModel::EncVariant varnt = OptionsModel::EncVariant_LoBit; varnt <= OptionsModel::EncVariant_HiBit; NEXT(varnt))
779                         {
780                                 binFiles << ENC_BINARY(m_sysinfo.data(), encdr, arch, varnt);
781                         }
782                 }
783                 binFiles << AVS_BINARY(m_sysinfo.data(), arch == OptionsModel::EncArch_x64);
784         }
785         for(size_t i = 0; UpdaterDialog::BINARIES[i].name; i++)
786         {
787                 if(UpdaterDialog::BINARIES[i].exec)
788                 {
789                         binFiles << QString("%1/toolset/common/%2").arg(m_sysinfo->getAppPath(), QString::fromLatin1(UpdaterDialog::BINARIES[i].name));
790                 }
791         }
792                 
793         qDebug("[Validating binaries]");
794         for(QStringList::ConstIterator iter = binFiles.constBegin(); iter != binFiles.constEnd(); iter++)
795         {
796                 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
797                 QFile *file = new QFile(*iter);
798                 qDebug("%s", file->fileName().toLatin1().constData());
799                 if(file->open(QIODevice::ReadOnly))
800                 {
801                         if(!MUtils::OS::is_executable_file(file->fileName()))
802                         {
803                                 QMessageBox::critical(this, tr("Invalid File!"), tr("<nobr>At least on required tool is not a valid Win32 or Win64 binary:<br><tt style=\"whitespace:nowrap\">%1</tt><br><br>Please re-install the program in order to fix the problem!</nobr>").arg(QDir::toNativeSeparators(file->fileName())).replace("-", "&minus;"));
804                                 qFatal(QString("Binary is invalid: %1").arg(file->fileName()).toLatin1().constData());
805                                 MUTILS_DELETE(file);
806                                 INIT_ERROR_EXIT();
807                         }
808                         if(m_toolsList.isNull())
809                         {
810                                 m_toolsList.reset(new QFileList());
811                         }
812                         m_toolsList->append(file);
813                 }
814                 else
815                 {
816                         QMessageBox::critical(this, tr("File Not Found!"), tr("<nobr>At least on required tool could not be found:<br><tt style=\"whitespace:nowrap\">%1</tt><br><br>Please re-install the program in order to fix the problem!</nobr>").arg(QDir::toNativeSeparators(file->fileName())).replace("-", "&minus;"));
817                         qFatal(QString("Binary not found: %1/toolset/%2").arg(m_sysinfo->getAppPath(), file->fileName()).toLatin1().constData());
818                         MUTILS_DELETE(file);
819                         INIT_ERROR_EXIT();
820                 }
821         }
822         qDebug(" ");
823         
824         //---------------------------------------
825         // Check for portable mode
826         //---------------------------------------
827
828         if(x264_is_portable())
829         {
830                 bool ok = false;
831                 static const char *data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
832                 QFile writeTest(QString("%1/%2").arg(x264_data_path(), QUuid::createUuid().toString()));
833                 if(writeTest.open(QIODevice::WriteOnly))
834                 {
835                         ok = (writeTest.write(data) == strlen(data));
836                         writeTest.remove();
837                 }
838                 if(!ok)
839                 {
840                         int val = QMessageBox::warning(this, tr("Write Test Failed"), tr("<nobr>The application was launched in portable mode, but the program path is <b>not</b> writable!</nobr>"), tr("Quit"), tr("Ignore"));
841                         if(val != 1) INIT_ERROR_EXIT();
842                 }
843         }
844
845         //Pre-release popup
846         if(x264_is_prerelease())
847         {
848                 qsrand(time(NULL)); int rnd = qrand() % 3;
849                 int val = QMessageBox::information(this, tr("Pre-Release Version"), tr("Note: This is a pre-release version. Please do NOT use for production!<br>Click the button #%1 in order to continue...<br><br>(There will be no such message box in the final version of this application)").arg(QString::number(rnd + 1)), tr("(1)"), tr("(2)"), tr("(3)"), qrand() % 3);
850                 if(rnd != val) INIT_ERROR_EXIT();
851         }
852
853         //---------------------------------------
854         // Check CPU capabilities
855         //---------------------------------------
856
857         //Make sure this CPU can run x264 (requires MMX + MMXEXT/iSSE to run x264 with ASM enabled, additionally requires SSE1 for most x264 builds)
858         if(!m_sysinfo->hasMMXSupport())
859         {
860                 QMessageBox::critical(this, tr("Unsupported CPU"), tr("<nobr>Sorry, but this machine is <b>not</b> physically capable of running x264 (with assembly).<br>Please get a CPU that supports at least the MMX and MMXEXT instruction sets!</nobr>"), tr("Quit"));
861                 qFatal("System does not support MMX and MMXEXT, x264 will not work !!!");
862                 INIT_ERROR_EXIT();
863         }
864         else if(!m_sysinfo->hasSSESupport())
865         {
866                 qWarning("WARNING: System does not support SSE1, most x264 builds will not work !!!\n");
867                 int val = QMessageBox::warning(this, tr("Unsupported CPU"), tr("<nobr>It appears that this machine does <b>not</b> support the SSE1 instruction set.<br>Thus most builds of x264 will <b>not</b> run on this computer at all.<br><br>Please get a CPU that supports the MMX and SSE1 instruction sets!</nobr>"), tr("Quit"), tr("Ignore"));
868                 if(val != 1) INIT_ERROR_EXIT();
869         }
870
871         //Skip version check (not recommended!)
872         if(arguments.contains(CLI_PARAM_SKIP_VERSION_CHECK))
873         {
874                 qWarning("Version checks are disabled now, you have been warned!\n");
875                 m_preferences->setSkipVersionTest(true);
876         }
877         
878         //Don't abort encoding process on timeout (not recommended!)
879         if(arguments.contains(CLI_PARAM_NO_DEADLOCK))
880         {
881                 qWarning("Deadlock detection disabled, you have been warned!\n");
882                 m_preferences->setAbortOnTimeout(false);
883         }
884
885         //---------------------------------------
886         // Check Avisynth support
887         //---------------------------------------
888
889         if(!arguments.contains(CLI_PARAM_SKIP_AVS_CHECK))
890         {
891                 qDebug("[Check for Avisynth support]");
892                 volatile double avisynthVersion = 0.0;
893                 const int result = AvisynthCheckThread::detect(&avisynthVersion);
894                 if(result < 0)
895                 {
896                         QString text = tr("A critical error was encountered while checking your Avisynth version.").append("<br>");
897                         text += tr("This is most likely caused by an erroneous Avisynth Plugin, please try to clean your Plugins folder!").append("<br>");
898                         text += tr("We suggest to move all .dll and .avsi files out of your Avisynth Plugins folder and try again.");
899                         int val = QMessageBox::critical(this, tr("Avisynth Error"), QString("<nobr>%1</nobr>").arg(text).replace("-", "&minus;"), tr("Quit"), tr("Ignore"));
900                         if(val != 1) INIT_ERROR_EXIT();
901                 }
902                 if(result && (avisynthVersion >= 2.5))
903                 {
904                         qDebug("Avisynth support is officially enabled now!");
905                         m_sysinfo->setAVSSupport(true);
906                 }
907                 else
908                 {
909                         if(!m_preferences->getDisableWarnings())
910                         {
911                                 QString text = tr("It appears that Avisynth is <b>not</b> currently installed on your computer.<br>Therefore Avisynth (.avs) input will <b>not</b> be working at all!").append("<br><br>");
912                                 text += tr("Please download and install Avisynth:").append("<br>").append(LINK(avs_dl_url));
913                                 int val = QMessageBox::warning(this, tr("Avisynth Missing"), QString("<nobr>%1</nobr>").arg(text).replace("-", "&minus;"), tr("Close"), tr("Disable this Warning"));
914                                 if(val == 1)
915                                 {
916                                         m_preferences->setDisableWarnings(true);
917                                         PreferencesModel::savePreferences(m_preferences.data());
918                                 }
919
920                         }
921                 }
922                 qDebug(" ");
923         }
924
925         //---------------------------------------
926         // Check VapurSynth support
927         //---------------------------------------
928
929         if(!arguments.contains(CLI_PARAM_SKIP_VPS_CHECK))
930         {
931                 qDebug("[Check for VapourSynth support]");
932                 QString vapoursynthPath;
933                 int vapoursynthType;
934                 const int result = VapourSynthCheckThread::detect(vapoursynthPath, vapoursynthType);
935                 if(result < 0)
936                 {
937                         QString text = tr("A critical error was encountered while checking your VapourSynth installation.").append("<br>");
938                         text += tr("This is most likely caused by an erroneous VapourSynth Plugin, please try to clean your Filters folder!").append("<br>");
939                         text += tr("We suggest to move all .dll files out of your VapourSynth Filters folder and try again.");
940                         const int val = QMessageBox::critical(this, tr("VapourSynth Error"), QString("<nobr>%1</nobr>").arg(text).replace("-", "&minus;"), tr("Quit"), tr("Ignore"));
941                         if(val != 1) INIT_ERROR_EXIT();
942                 }
943                 if(result && vapoursynthType && (!vapoursynthPath.isEmpty()))
944                 {
945                         qDebug("VapourSynth support is officially enabled now!");
946                         m_sysinfo->setVPS32Support(vapoursynthType & VapourSynthCheckThread::VAPOURSYNTH_X86);
947                         m_sysinfo->setVPS64Support(vapoursynthType & VapourSynthCheckThread::VAPOURSYNTH_X64);
948                         m_sysinfo->setVPSPath(vapoursynthPath);
949                 }
950                 else
951                 {
952                         if(!m_preferences->getDisableWarnings())
953                         {
954                                 QString text = tr("It appears that VapourSynth is <b>not</b> currently installed on your computer.<br>Therefore VapourSynth (.vpy) input will <b>not</b> be working at all!").append("<br><br>");
955                                 text += tr("Please download and install VapourSynth (<b>r%1</b> or later) for Windows:").arg(QString::number(vsynth_rev)).append("<br>").append(LINK(vsynth_url)).append("<br><br>");
956                                 text += tr("Note that Python v3.4 is a prerequisite for installing VapourSynth:").append("<br>").append(LINK(python_url)).append("<br>");
957                                 const int val = QMessageBox::warning(this, tr("VapourSynth Missing"), QString("<nobr>%1</nobr>").arg(text).replace("-", "&minus;"), tr("Close"), tr("Disable this Warning"));
958                                 if(val == 1)
959                                 {
960                                         m_preferences->setDisableWarnings(true);
961                                         PreferencesModel::savePreferences(m_preferences.data());
962                                 }
963                         }
964                 }
965                 qDebug(" ");
966         }
967         
968         //---------------------------------------
969         // Finish initialization
970         //---------------------------------------
971
972         //Set Window title
973         setWindowTitle(QString("%1 (%2)").arg(windowTitle(), m_sysinfo->hasX64Support() ? "64-Bit" : "32-Bit"));
974
975         //Enable drag&drop support for this window, required for Qt v4.8.4+
976         setAcceptDrops(true);
977
978         //Update flag
979         m_initialized = true;
980
981         //---------------------------------------
982         // Check for Expiration
983         //---------------------------------------
984
985         if(MUtils::Version::app_build_date().addMonths(6) < MUtils::OS::current_date())
986         {
987                 if(QWidget *cornerWidget = ui->menubar->cornerWidget()) cornerWidget->show();
988                 QString text;
989                 text += QString("<nobr><tt>%1</tt></nobr><br><br>").arg(tr("Your version of Simple x264 Launcher is more than 6 months old!").replace('-', "&minus;"));
990                 text += QString("<nobr><tt>%1<br><a href=\"%2\">%3</a><br><br>").arg(tr("You can download the most recent version from the official web-site now:").replace('-', "&minus;"), QString::fromLatin1(update_url), QString::fromLatin1(update_url).replace("-", "&minus;"));
991                 text += QString("<nobr><tt>%1</tt></nobr><br>").arg(tr("Alternatively, click 'Check for Updates' to run the auto-update utility.").replace('-', "&minus;"));
992                 QMessageBox msgBox(this);
993                 msgBox.setIconPixmap(QIcon(":/images/update.png").pixmap(56,56));
994                 msgBox.setWindowTitle(tr("Update Notification"));
995                 msgBox.setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint);
996                 msgBox.setText(text);
997                 QPushButton *btn1 = msgBox.addButton(tr("Check for Updates"), QMessageBox::AcceptRole);
998                 QPushButton *btn2 = msgBox.addButton(tr("Discard"), QMessageBox::NoRole);
999                 QPushButton *btn3 = msgBox.addButton(btn2->text(), QMessageBox::RejectRole);
1000                 btn2->setEnabled(false);
1001                 btn3->setVisible(false);
1002                 QTimer::singleShot(7500, btn2, SLOT(hide()));
1003                 QTimer::singleShot(7500, btn3, SLOT(show()));
1004                 if(msgBox.exec() == 0)
1005                 {
1006                         QTimer::singleShot(0, this, SLOT(checkUpdates()));
1007                         return;
1008                 }
1009         }
1010         else if(!parseCommandLineArgs())
1011         {
1012                 //Update reminder
1013                 if(arguments.contains(CLI_PARAM_FIRST_RUN))
1014                 {
1015                         qWarning("First run -> resetting update check now!");
1016                         m_recentlyUsed->setLastUpdateCheck(0);
1017                         RecentlyUsed::saveRecentlyUsed(m_recentlyUsed.data());
1018                 }
1019                 else if(m_recentlyUsed->lastUpdateCheck() + 14 < MUtils::OS::current_date().toJulianDay())
1020                 {
1021                         if(QWidget *cornerWidget = ui->menubar->cornerWidget()) cornerWidget->show();
1022                         if(!m_preferences->getNoUpdateReminder())
1023                         {
1024                                 if(QMessageBox::warning(this, tr("Update Notification"), QString("<nobr>%1</nobr>").arg(tr("Your last update check was more than 14 days ago. Check for updates now?")), tr("Check for Updates"), tr("Discard")) == 0)
1025                                 {
1026                                         QTimer::singleShot(0, this, SLOT(checkUpdates()));
1027                                         return;
1028                                 }
1029                         }
1030                 }
1031         }
1032
1033         //---------------------------------------
1034         // Create the IPC listener thread
1035         //---------------------------------------
1036
1037         if(m_ipcChannel)
1038         {
1039                 m_ipcThread.reset(new IPCThread_Recv(m_ipcChannel));
1040                 connect(m_ipcThread.data(), SIGNAL(receivedCommand(int,QStringList,quint32)), this, SLOT(handleCommand(int,QStringList,quint32)), Qt::QueuedConnection);
1041                 m_ipcThread->start();
1042         }
1043
1044         //Load queued jobs
1045         if(m_jobList->loadQueuedJobs(m_sysinfo.data()) > 0)
1046         {
1047                 m_label->setVisible(m_jobList->rowCount(QModelIndex()) == 0);
1048                 m_jobList->clearQueuedJobs();
1049         }
1050 }
1051
1052 /*
1053  * Update the label position
1054  */
1055 void MainWindow::updateLabelPos(void)
1056 {
1057         const QWidget *const viewPort = ui->jobsView->viewport();
1058         m_label->setGeometry(0, 0, viewPort->width(), viewPort->height());
1059 }
1060
1061 /*
1062  * Copy the complete log to the clipboard
1063  */
1064 void MainWindow::copyLogToClipboard(bool checked)
1065 {
1066         qDebug("Coyping logfile to clipboard...");
1067         
1068         if(LogFileModel *log = dynamic_cast<LogFileModel*>(ui->logView->model()))
1069         {
1070                 log->copyToClipboard();
1071                 MUtils::Sound::beep(MUtils::Sound::BEEP_NFO);
1072         }
1073 }
1074
1075 /*
1076  * Process the dropped files
1077  */
1078 void MainWindow::handlePendingFiles(void)
1079 {
1080         qDebug("MainWindow::handlePendingFiles");
1081
1082         if(!m_pendingFiles->isEmpty())
1083         {
1084                 QStringList pendingFiles(*m_pendingFiles);
1085                 m_pendingFiles->clear();
1086                 createJobMultiple(pendingFiles);
1087         }
1088
1089         qDebug("Leave from MainWindow::handlePendingFiles!");
1090 }
1091
1092 /*
1093  * Handle incoming IPC command
1094  */
1095 void MainWindow::handleCommand(const int &command, const QStringList &args, const quint32 &flags)
1096 {
1097         if(!(m_initialized && (QApplication::activeModalWidget() == NULL)))
1098         {
1099                 qWarning("Cannot accapt commands at this time -> discarding!");
1100                 return;
1101         }
1102         
1103         if((!isVisible()) || m_sysTray->isVisible())
1104         {
1105                 sysTrayActived();
1106         }
1107
1108         MUtils::GUI::bring_to_front(this);
1109         
1110 #ifdef IPC_LOGGING
1111         qDebug("\n---------- IPC ----------");
1112         qDebug("CommandId: %d", command);
1113         for(QStringList::ConstIterator iter = args.constBegin(); iter != args.constEnd(); iter++)
1114         {
1115                 qDebug("Arguments: %s", iter->toUtf8().constData());
1116         }
1117         qDebug("The Flags: 0x%08X", flags);
1118         qDebug("---------- IPC ----------\n");
1119 #endif //IPC_LOGGING
1120
1121         switch(command)
1122         {
1123         case IPC_OPCODE_PING:
1124                 qDebug("Received a PING request from another instance!");
1125                 MUtils::GUI::blink_window(this, 5, 125);
1126                 break;
1127         case IPC_OPCODE_ADD_FILE:
1128                 if(!args.isEmpty())
1129                 {
1130                         if(QFileInfo(args[0]).exists() && QFileInfo(args[0]).isFile())
1131                         {
1132                                 *m_pendingFiles << QFileInfo(args[0]).canonicalFilePath();
1133                                 if(!m_fileTimer->isActive())
1134                                 {
1135                                         m_fileTimer->setSingleShot(true);
1136                                         m_fileTimer->start(5000);
1137                                 }
1138                         }
1139                         else
1140                         {
1141                                 qWarning("File '%s' not found!", args[0].toUtf8().constData());
1142                         }
1143                 }
1144                 break;
1145         case IPC_OPCODE_ADD_JOB:
1146                 if(args.size() >= 3)
1147                 {
1148                         if(QFileInfo(args[0]).exists() && QFileInfo(args[0]).isFile())
1149                         {
1150                                 OptionsModel options(m_sysinfo.data());
1151                                 bool runImmediately = (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
1152                                 if(!(args[2].isEmpty() || X264_STRCMP(args[2], "-")))
1153                                 {
1154                                         if(!OptionsModel::loadTemplate(&options, args[2].trimmed()))
1155                                         {
1156                                                 qWarning("Template '%s' could not be found -> using defaults!", args[2].trimmed().toUtf8().constData());
1157                                         }
1158                                 }
1159                                 if((flags & IPC_FLAG_FORCE_START) && (!(flags & IPC_FLAG_FORCE_ENQUEUE))) runImmediately = true;
1160                                 if((flags & IPC_FLAG_FORCE_ENQUEUE) && (!(flags & IPC_FLAG_FORCE_START))) runImmediately = false;
1161                                 appendJob(args[0], args[1], &options, runImmediately);
1162                         }
1163                         else
1164                         {
1165                                 qWarning("Source file '%s' not found!", args[0].toUtf8().constData());
1166                         }
1167                 }
1168                 break;
1169         default:
1170                 MUTILS_THROW("Unknown command received!");
1171         }
1172 }
1173
1174 /*
1175  * Check for new updates
1176  */
1177 void MainWindow::checkUpdates(void)
1178 {
1179         ENSURE_APP_IS_READY();
1180
1181         if(countRunningJobs() > 0)
1182         {
1183                 QMessageBox::warning(this, tr("Jobs Are Running"), tr("Sorry, can not update while there still are running jobs!"));
1184                 return;
1185         }
1186
1187         UpdaterDialog *updater = new UpdaterDialog(this, m_sysinfo.data(), update_url);
1188         const int ret = updater->exec();
1189
1190         if(updater->getSuccess())
1191         {
1192                 m_recentlyUsed->setLastUpdateCheck(MUtils::OS::current_date().toJulianDay());
1193                 RecentlyUsed::saveRecentlyUsed(m_recentlyUsed.data());
1194                 if(QWidget *cornerWidget = ui->menubar->cornerWidget()) cornerWidget->hide();
1195         }
1196
1197         if(ret == UpdaterDialog::READY_TO_INSTALL_UPDATE)
1198         {
1199                 qWarning("Exitting program to install update...");
1200                 close();
1201                 QApplication::quit();
1202         }
1203
1204         MUTILS_DELETE(updater);
1205 }
1206
1207 /*
1208  * Handle mouse event for version label
1209  */
1210 void MainWindow::versionLabelMouseClicked(const int &tag)
1211 {
1212         if(tag == 0)
1213         {
1214                 QTimer::singleShot(0, this, SLOT(showAbout()));
1215         }
1216 }
1217
1218 /*
1219  * Handle key event for job list
1220  */
1221 void MainWindow::jobListKeyPressed(const int &tag)
1222 {
1223         switch(tag)
1224         {
1225         case 1:
1226                 ui->actionJob_MoveUp->trigger();
1227                 break;
1228         case 2:
1229                 ui->actionJob_MoveDown->trigger();
1230                 break;
1231         }
1232 }
1233
1234 /*
1235  * System tray was activated
1236  */
1237 void MainWindow::sysTrayActived(void)
1238 {
1239         m_sysTray->hide();
1240         showNormal();
1241         MUtils::GUI::bring_to_front(this);
1242 }
1243
1244 ///////////////////////////////////////////////////////////////////////////////
1245 // Event functions
1246 ///////////////////////////////////////////////////////////////////////////////
1247
1248 /*
1249  * Window shown event
1250  */
1251 void MainWindow::showEvent(QShowEvent *e)
1252 {
1253         QMainWindow::showEvent(e);
1254
1255         if(!m_initialized)
1256         {
1257                 QTimer::singleShot(0, this, SLOT(init()));
1258         }
1259 }
1260
1261 /*
1262  * Window close event
1263  */
1264 void MainWindow::closeEvent(QCloseEvent *e)
1265 {
1266         if(!APP_IS_READY)
1267         {
1268                 e->ignore();
1269                 qWarning("Cannot close window at this time!");
1270                 return;
1271         }
1272
1273         //Make sure we have no running jobs left!
1274         if(countRunningJobs() > 0)
1275         {
1276                 e->ignore();
1277                 if(!m_preferences->getNoSystrayWarning())
1278                 {
1279                         if(QMessageBox::warning(this, tr("Jobs Are Running"), tr("<nobr>You still have running jobs, application will be minimized to notification area!<nobr>"), tr("OK"), tr("Don't Show Again")) == 1)
1280                         {
1281                                 m_preferences->setNoSystrayWarning(true);
1282                                 PreferencesModel::savePreferences(m_preferences.data());
1283                         }
1284                 }
1285                 hide();
1286                 m_sysTray->show();
1287                 return;
1288         }
1289
1290         //Save pending jobs for next time, if desired by user
1291         if(countPendingJobs() > 0)
1292         {
1293                 int ret = QMessageBox::question(this, tr("Jobs Are Pending"), tr("You still have pending jobs. How do you want to proceed?"), tr("Save Pending Jobs"), tr("Discard"));
1294                 if(ret == 0)
1295                 {
1296                         m_jobList->saveQueuedJobs();
1297                 }
1298                 else
1299                 {
1300                         if(QMessageBox::warning(this, tr("Jobs Are Pending"), tr("Do you really want to discard all pending jobs?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes)
1301                         {
1302                                 e->ignore();
1303                                 return;
1304                         }
1305                 }
1306         }
1307         
1308         //Delete remaining jobs
1309         while(m_jobList->rowCount(QModelIndex()) > 0)
1310         {
1311                 if((m_jobList->rowCount(QModelIndex()) % 10) == 0)
1312                 {
1313                         qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
1314                 }
1315                 if(!m_jobList->deleteJob(m_jobList->index(0, 0, QModelIndex())))
1316                 {
1317                         e->ignore();
1318                         QMessageBox::warning(this, tr("Failed To Exit"), tr("Warning: At least one job could not be deleted!"));
1319                 }
1320         }
1321         
1322         qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
1323         QMainWindow::closeEvent(e);
1324 }
1325
1326 /*
1327  * Window resize event
1328  */
1329 void MainWindow::resizeEvent(QResizeEvent *e)
1330 {
1331         QMainWindow::resizeEvent(e);
1332         updateLabelPos();
1333 }
1334
1335 /*
1336  * File dragged over window
1337  */
1338 void MainWindow::dragEnterEvent(QDragEnterEvent *event)
1339 {
1340         bool accept[2] = {false, false};
1341
1342         foreach(const QString &fmt, event->mimeData()->formats())
1343         {
1344                 accept[0] = accept[0] || fmt.contains("text/uri-list", Qt::CaseInsensitive);
1345                 accept[1] = accept[1] || fmt.contains("FileNameW", Qt::CaseInsensitive);
1346         }
1347
1348         if(accept[0] && accept[1])
1349         {
1350                 event->acceptProposedAction();
1351         }
1352 }
1353
1354 /*
1355  * File dropped onto window
1356  */
1357 void MainWindow::dropEvent(QDropEvent *event)
1358 {
1359         if(!(m_initialized && (QApplication::activeModalWidget() == NULL)))
1360         {
1361                 qWarning("Cannot accept dropped files at this time -> discarding!");
1362                 return;
1363         }
1364
1365         QStringList droppedFiles;
1366         QList<QUrl> urls = event->mimeData()->urls();
1367
1368         while(!urls.isEmpty())
1369         {
1370                 QUrl currentUrl = urls.takeFirst();
1371                 QFileInfo file(currentUrl.toLocalFile());
1372                 if(file.exists() && file.isFile())
1373                 {
1374                         qDebug("MainWindow::dropEvent: %s", file.canonicalFilePath().toUtf8().constData());
1375                         droppedFiles << file.canonicalFilePath();
1376                 }
1377         }
1378         
1379         if(droppedFiles.count() > 0)
1380         {
1381                 m_pendingFiles->append(droppedFiles);
1382                 m_pendingFiles->sort();
1383                 if(!m_fileTimer->isActive())
1384                 {
1385                         m_fileTimer->setSingleShot(true);
1386                         m_fileTimer->start(5000);
1387                 }
1388         }
1389 }
1390
1391 ///////////////////////////////////////////////////////////////////////////////
1392 // Private functions
1393 ///////////////////////////////////////////////////////////////////////////////
1394
1395 /*
1396  * Creates a new job
1397  */
1398 bool MainWindow::createJob(QString &sourceFileName, QString &outputFileName, OptionsModel *options, bool &runImmediately, const bool restart, int fileNo, int fileTotal, bool *applyToAll)
1399 {
1400         bool okay = false;
1401         AddJobDialog *addDialog = new AddJobDialog(this, options, m_recentlyUsed.data(), m_sysinfo.data(), m_preferences.data());
1402
1403         addDialog->setRunImmediately(runImmediately);
1404         if(!sourceFileName.isEmpty()) addDialog->setSourceFile(sourceFileName);
1405         if(!outputFileName.isEmpty()) addDialog->setOutputFile(outputFileName);
1406         if(restart) addDialog->setWindowTitle(tr("Restart Job"));
1407
1408         const bool multiFile = (fileNo >= 0) && (fileTotal > 1);
1409         if(multiFile)
1410         {
1411                 addDialog->setSourceEditable(false);
1412                 addDialog->setWindowTitle(addDialog->windowTitle().append(tr(" (File %1 of %2)").arg(QString::number(fileNo+1), QString::number(fileTotal))));
1413                 addDialog->setApplyToAllVisible(applyToAll);
1414         }
1415
1416         if(addDialog->exec() == QDialog::Accepted)
1417         {
1418                 sourceFileName = addDialog->sourceFile();
1419                 outputFileName = addDialog->outputFile();
1420                 runImmediately = addDialog->runImmediately();
1421                 if(applyToAll)
1422                 {
1423                         *applyToAll = addDialog->applyToAll();
1424                 }
1425                 okay = true;
1426         }
1427
1428         MUTILS_DELETE(addDialog);
1429         return okay;
1430 }
1431
1432 /*
1433  * Creates a new job from *multiple* files
1434  */
1435 bool MainWindow::createJobMultiple(const QStringList &filePathIn)
1436 {
1437         QStringList::ConstIterator iter;
1438         bool applyToAll = false, runImmediately = false;
1439         int counter = 0;
1440
1441         //Add files individually
1442         for(iter = filePathIn.constBegin(); (iter != filePathIn.constEnd()) && (!applyToAll); iter++)
1443         {
1444                 runImmediately = (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
1445                 QString sourceFileName(*iter), outputFileName;
1446                 if(createJob(sourceFileName, outputFileName, m_options.data(), runImmediately, false, counter++, filePathIn.count(), &applyToAll))
1447                 {
1448                         if(appendJob(sourceFileName, outputFileName, m_options.data(), runImmediately))
1449                         {
1450                                 continue;
1451                         }
1452                 }
1453                 return false;
1454         }
1455
1456         //Add remaining files
1457         while(applyToAll && (iter != filePathIn.constEnd()))
1458         {
1459                 const bool runImmediatelyTmp = runImmediately && (countRunningJobs() < (m_preferences->getAutoRunNextJob() ? m_preferences->getMaxRunningJobCount() : 1));
1460                 const QString sourceFileName = *iter;
1461                 const QString outputFileName = AddJobDialog::generateOutputFileName(sourceFileName, m_recentlyUsed->outputDirectory(), m_recentlyUsed->filterIndex(), m_preferences->getSaveToSourcePath());
1462                 if(!appendJob(sourceFileName, outputFileName, m_options.data(), runImmediatelyTmp))
1463                 {
1464                         return false;
1465                 }
1466                 iter++;
1467         }
1468
1469         return true;
1470 }
1471
1472 /*
1473  * Append a new job
1474  */
1475 bool MainWindow::appendJob(const QString &sourceFileName, const QString &outputFileName, OptionsModel *options, const bool runImmediately)
1476 {
1477         bool okay = false;
1478         EncodeThread *thrd = new EncodeThread(sourceFileName, outputFileName, options, m_sysinfo.data(), m_preferences.data());
1479         QModelIndex newIndex = m_jobList->insertJob(thrd);
1480
1481         if(newIndex.isValid())
1482         {
1483                 if(runImmediately)
1484                 {
1485                         ui->jobsView->selectRow(newIndex.row());
1486                         QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
1487                         m_jobList->startJob(newIndex);
1488                 }
1489
1490                 okay = true;
1491         }
1492
1493         m_label->setVisible(m_jobList->rowCount(QModelIndex()) == 0);
1494         return okay;
1495 }
1496
1497 /*
1498  * Jobs that are not completed (or failed, or aborted) yet
1499  */
1500 unsigned int MainWindow::countPendingJobs(void)
1501 {
1502         unsigned int count = 0;
1503         const int rows = m_jobList->rowCount(QModelIndex());
1504
1505         for(int i = 0; i < rows; i++)
1506         {
1507                 JobStatus status = m_jobList->getJobStatus(m_jobList->index(i, 0, QModelIndex()));
1508                 if(status != JobStatus_Completed && status != JobStatus_Aborted && status != JobStatus_Failed)
1509                 {
1510                         count++;
1511                 }
1512         }
1513
1514         return count;
1515 }
1516
1517 /*
1518  * Jobs that are still active, i.e. not terminated or enqueued
1519  */
1520 unsigned int MainWindow::countRunningJobs(void)
1521 {
1522         unsigned int count = 0;
1523         const int rows = m_jobList->rowCount(QModelIndex());
1524
1525         for(int i = 0; i < rows; i++)
1526         {
1527                 JobStatus status = m_jobList->getJobStatus(m_jobList->index(i, 0, QModelIndex()));
1528                 if(status != JobStatus_Completed && status != JobStatus_Aborted && status != JobStatus_Failed && status != JobStatus_Enqueued)
1529                 {
1530                         count++;
1531                 }
1532         }
1533
1534         return count;
1535 }
1536
1537 /*
1538  * Update all buttons with respect to current job status
1539  */
1540 void MainWindow::updateButtons(JobStatus status)
1541 {
1542         qDebug("MainWindow::updateButtons(void)");
1543
1544         ui->buttonStartJob->setEnabled(status == JobStatus_Enqueued);
1545         ui->buttonAbortJob->setEnabled(status == JobStatus_Indexing || status == JobStatus_Running || status == JobStatus_Running_Pass1 || status == JobStatus_Running_Pass2 || status == JobStatus_Paused);
1546         ui->buttonPauseJob->setEnabled(status == JobStatus_Indexing || status == JobStatus_Running || status == JobStatus_Paused || status == JobStatus_Running_Pass1 || status == JobStatus_Running_Pass2);
1547         ui->buttonPauseJob->setChecked(status == JobStatus_Paused || status == JobStatus_Pausing);
1548
1549         ui->actionJob_Delete->setEnabled(status == JobStatus_Completed || status == JobStatus_Aborted || status == JobStatus_Failed || status == JobStatus_Enqueued);
1550         ui->actionJob_Restart->setEnabled(status == JobStatus_Completed || status == JobStatus_Aborted || status == JobStatus_Failed || status == JobStatus_Enqueued);
1551         ui->actionJob_Browse->setEnabled(status == JobStatus_Completed);
1552         ui->actionJob_MoveUp->setEnabled(status != JobStatus_Undefined);
1553         ui->actionJob_MoveDown->setEnabled(status != JobStatus_Undefined);
1554
1555         ui->actionJob_Start->setEnabled(ui->buttonStartJob->isEnabled());
1556         ui->actionJob_Abort->setEnabled(ui->buttonAbortJob->isEnabled());
1557         ui->actionJob_Pause->setEnabled(ui->buttonPauseJob->isEnabled());
1558         ui->actionJob_Pause->setChecked(ui->buttonPauseJob->isChecked());
1559
1560         ui->editDetails->setEnabled(status != JobStatus_Paused);
1561 }
1562
1563 /*
1564  * Update the taskbar with current job status
1565  */
1566 void MainWindow::updateTaskbar(JobStatus status, const QIcon &icon)
1567 {
1568         qDebug("MainWindow::updateTaskbar(void)");
1569
1570         if(m_taskbar.isNull())
1571         {
1572                 return; /*taskbar object not created yet*/
1573         }
1574
1575         switch(status)
1576         {
1577         case JobStatus_Undefined:
1578                 m_taskbar->setTaskbarState(MUtils::Taskbar7::TASKBAR_STATE_NONE);
1579                 break;
1580         case JobStatus_Aborting:
1581         case JobStatus_Starting:
1582         case JobStatus_Pausing:
1583         case JobStatus_Resuming:
1584                 m_taskbar->setTaskbarState(MUtils::Taskbar7::TASKBAR_STATE_INTERMEDIATE);
1585                 break;
1586         case JobStatus_Aborted:
1587         case JobStatus_Failed:
1588                 m_taskbar->setTaskbarState(MUtils::Taskbar7::TASKBAR_STATE_ERROR);
1589                 break;
1590         case JobStatus_Paused:
1591                 m_taskbar->setTaskbarState(MUtils::Taskbar7::TASKBAR_STATE_PAUSED);
1592                 break;
1593         default:
1594                 m_taskbar->setTaskbarState(MUtils::Taskbar7::TASKBAR_STATE_NORMAL);
1595                 break;
1596         }
1597
1598         switch(status)
1599         {
1600         case JobStatus_Aborting:
1601         case JobStatus_Starting:
1602         case JobStatus_Pausing:
1603         case JobStatus_Resuming:
1604                 break;
1605         default:
1606                 m_taskbar->setTaskbarProgress(ui->progressBar->value(), ui->progressBar->maximum());
1607                 break;
1608         }
1609
1610         m_taskbar->setOverlayIcon(icon.isNull() ? NULL : &icon);
1611 }
1612
1613 /*
1614  * Parse command-line arguments
1615  */
1616 bool MainWindow::parseCommandLineArgs(void)
1617 {
1618         const MUtils::OS::ArgumentMap &args = MUtils::OS::arguments();
1619
1620         quint32 flags = 0;
1621         bool commandSent = false;
1622
1623         //Handle flags
1624         if(args.contains(CLI_PARAM_FORCE_START))
1625         {
1626                 flags = ((flags | IPC_FLAG_FORCE_START) & (~IPC_FLAG_FORCE_ENQUEUE));
1627         }
1628         if(args.contains(CLI_PARAM_FORCE_ENQUEUE))
1629         {
1630                 flags = ((flags | IPC_FLAG_FORCE_ENQUEUE) & (~IPC_FLAG_FORCE_START));
1631         }
1632
1633         //Process all command-line arguments
1634         if(args.contains(CLI_PARAM_ADD_FILE))
1635         {
1636                 foreach(const QString &fileName, args.values(CLI_PARAM_ADD_FILE))
1637                 {
1638                         handleCommand(IPC_OPCODE_ADD_FILE, QStringList() << fileName, flags);
1639                 }
1640                 commandSent = true;
1641         }
1642         if(args.contains(CLI_PARAM_ADD_JOB))
1643         {
1644                 foreach(const QString &options, args.values(CLI_PARAM_ADD_JOB))
1645                 {
1646                         const QStringList optionValues = options.split('|', QString::SkipEmptyParts);
1647                         if(optionValues.count() == 3)
1648                         {
1649                                 handleCommand(IPC_OPCODE_ADD_JOB, optionValues, flags);
1650                         }
1651                         else
1652                         {
1653                                 qWarning("Invalid number of arguments for parameter \"--%s\" detected!", CLI_PARAM_ADD_JOB);
1654                         }
1655                 }
1656                 commandSent = true;
1657         }
1658
1659         return commandSent;
1660 }