No OneTemporary
Actions

Authored By

Unknown

Size

68 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/dialogs/historydialog.cpp b/dialogs/historydialog.cpp
	index 830073b..edfe4ef 100644
	--- a/dialogs/historydialog.cpp
	+++ b/dialogs/historydialog.cpp
	@@ -1,286 +1,277 @@
	#include "historydialog.h"
	#include "ui_historydialog.h"

	#include "../tools/os.h"
	#include "../tools/uploader/uploader.h"
	#include "../tools/screenshotmanager.h"

	#include <QClipboard>
	#include <QDesktopServices>
	#include <QDir>
	#include <QFile>
	#include <QFileInfo>
	#include <QFileSystemWatcher>
	#include <QMenu>
	#include <QMessageBox>
	#include <QSettings>
	#include <QSortFilterProxyModel>
	#include <QtSql/QSqlDatabase>
	#include <QtSql/QSqlTableModel>
	#include <QUrl>

	HistoryDialog::HistoryDialog(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::HistoryDialog)
	{
	ui->setupUi(this);

	ui->filterEdit->setText(tr("Filter.."));
	ui->filterEdit->installEventFilter(this);

	if (QSqlDatabase::database().isOpen())
	{
	mModel = new QSqlTableModel(this);
	mModel->setTable("history");
	mModel->setHeaderData(0, Qt::Horizontal, tr("Screenshot"));
	mModel->setHeaderData(1, Qt::Horizontal, tr("URL"));
	mModel->select();

	mFilterModel = new QSortFilterProxyModel(mModel);
	mFilterModel->setSourceModel(mModel);
	mFilterModel->setDynamicSortFilter(true);
	mFilterModel->setSortCaseSensitivity(Qt::CaseInsensitive);
	mFilterModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
	mFilterModel->setFilterKeyColumn(-1);

	while (mModel->canFetchMore()) {
	mModel->fetchMore();
	}

	ui->tableView->setWordWrap(false);
	ui->tableView->setModel(mFilterModel);

	ui->tableView->hideColumn(2); // No delete hash.
	ui->tableView->hideColumn(3); // No timestamp.

	ui->tableView->horizontalHeader()->setSectionsClickable(false);
	ui->tableView->horizontalHeader()->setSectionsMovable(false);

	ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
	ui->tableView->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);

	ui->tableView->verticalHeader()->hide();

	ui->tableView->setTextElideMode(Qt::ElideLeft);
	ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
	ui->tableView->setAlternatingRowColors(true);
	ui->tableView->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
	ui->tableView->setSortingEnabled(true);

	if (ui->tableView->model()->rowCount() > 0)
	{
	ui->clearButton->setEnabled(true);
	ui->filterEdit->setEnabled(true);
	}

	connect(ui->tableView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
	connect(ui->tableView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(open(QModelIndex)));
	connect(ui->tableView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenu(QPoint)));
	}
	else {
	ui->tableView->setEnabled(false);
	ui->clearButton->setEnabled(false);
	}

	- ui->uploadProgressBar->setValue (Uploader::instance()->progressSent());
	+ ui->uploadProgressBar->setValue(Uploader::instance()->progress());

	- if (Uploader::instance()->progressTotal() == 0) {
	- ui->uploadProgressBar->setMaximum(1);
	- }
	- else {
	- ui->uploadProgressBar->setMaximum(Uploader::instance()->progressTotal());
	- }
	-
	- connect(Uploader::instance(), SIGNAL(progress(qint64,qint64)), this, SLOT(uploadProgress(qint64, qint64)));
	+ connect(Uploader::instance(), SIGNAL(progress(int)), this, SLOT(uploadProgress(int)));
	connect(Uploader::instance(), SIGNAL(done(QString,QString,QString)), this, SLOT(refresh()));
	connect(ui->uploadButton, SIGNAL(clicked()), this, SLOT(upload()));
	connect(ui->clearButton , SIGNAL(clicked()), this, SLOT(clear()));
	}

	HistoryDialog::~HistoryDialog()
	{
	delete ui;
	}

	void HistoryDialog::clear()
	{
	if (QMessageBox::question(this,
	tr("Clearing the screenshot history"),
	tr("Are you sure you want to clear your entire screenshot history?\nThis cannot be undone."),
	tr("Clear History"),
	tr("Don't Clear")) == 1) {
	return;
	}

	ScreenshotManager::instance()->clearHistory();
	close();
	}

	void HistoryDialog::contextMenu(QPoint point)
	{
	mContextIndex = ui->tableView->indexAt(point);;

	QMenu contextMenu(ui->tableView);

	QAction copyAction((mContextIndex.column() == 0) ? tr("Copy Path") : tr("Copy URL"), &contextMenu);
	connect(&copyAction, SIGNAL(triggered()), this, SLOT(copy()));
	contextMenu.addAction(&copyAction);

	QAction deleteAction(tr("Delete from imgur.com"), &contextMenu);
	QAction locationAction(tr("Open Location"), &contextMenu);

	QAction removeAction(tr("Remove history entry"), &contextMenu);

	if (mContextIndex.data().toString().isEmpty()) {
	copyAction.setEnabled(false);
	deleteAction.setEnabled(false);
	}

	if (mContextIndex.column() == 0) {
	connect(&locationAction, SIGNAL(triggered()), this, SLOT(location()));

	contextMenu.addAction(&locationAction);
	}
	else {
	connect(&deleteAction, SIGNAL(triggered()), this, SLOT(deleteImage()));
	contextMenu.addAction(&deleteAction);
	}

	connect(&removeAction, SIGNAL(triggered()), this, SLOT(removeHistoryEntry()));
	contextMenu.addAction(&removeAction);
	contextMenu.exec(QCursor::pos());
	}

	void HistoryDialog::copy()
	{
	qApp->clipboard()->setText(mContextIndex.data().toString());
	}

	void HistoryDialog::deleteImage()
	{
	QDesktopServices::openUrl(mContextIndex.sibling(mContextIndex.row(), 2).data().toString());
	}

	void HistoryDialog::location()
	{
	QDesktopServices::openUrl("file:///" + QFileInfo(mContextIndex.data().toString()).absolutePath());
	}

	void HistoryDialog::removeHistoryEntry()
	{
	if (mContextIndex.column() == 0) {
	// File got right clicked:
	ScreenshotManager::instance()->removeHistory(mContextIndex.data().toString(), mContextIndex.sibling(mContextIndex.row(), 3).data().toLongLong());
	}
	else {
	// Screenshot URL got right clicked:
	ScreenshotManager::instance()->removeHistory(mContextIndex.sibling(mContextIndex.row(), 0).data().toString(), mContextIndex.sibling(mContextIndex.row(), 3).data().toLongLong());
	}

	refresh();
	}

	void HistoryDialog::refresh()
	{
	mModel->select();
	}

	void HistoryDialog::open(QModelIndex index)
	{
	if (index.column() == 0) {
	QDesktopServices::openUrl(QUrl("file:///" + index.data().toString()));
	}
	else {
	QDesktopServices::openUrl(index.data().toUrl());
	}
	}

	void HistoryDialog::selectionChanged(QItemSelection selected, QItemSelection deselected)
	{
	Q_UNUSED(deselected);

	if (selected.indexes().count() == 0){
	return;
	}

	QModelIndex index = selected.indexes().at(0);

	QString screenshot;

	if (index.column() == 0) {
	screenshot = index.data().toString();
	}
	else {
	screenshot = ui->tableView->model()->index(index.row(), 0).data().toString();
	}

	mSelectedScreenshot = screenshot;

	ui->uploadButton->setEnabled(QFile::exists(screenshot));
	}

	void HistoryDialog::upload()
	{
	Uploader::instance()->upload(mSelectedScreenshot);
	ui->uploadButton->setEnabled(false);
	}

	-void HistoryDialog::uploadProgress(qint64 sent, qint64 total)
	+void HistoryDialog::uploadProgress(int progress)
	{
	ui->uploadProgressBar->setEnabled(true);
	-
	- ui->uploadProgressBar->setMaximum(total);
	- ui->uploadProgressBar->setValue(sent);
	+ ui->uploadProgressBar->setValue(progress);
	}

	bool HistoryDialog::eventFilter(QObject object, QEvent event)
	{
	if (object == ui->filterEdit) {
	if (event->type() == QEvent::FocusIn)
	{
	if (ui->filterEdit->text() == tr("Filter..")) {
	ui->filterEdit->setStyleSheet("");
	ui->filterEdit->setText("");
	mFilterModel->setFilterWildcard("");
	mFilterModel->sort(3, Qt::DescendingOrder);
	}
	}
	else if (event->type() == QEvent::FocusOut)
	{
	if (ui->filterEdit->text() == "") {
	ui->filterEdit->setStyleSheet("color: palette(mid);");
	ui->filterEdit->setText(tr("Filter.."));
	mFilterModel->sort(3, Qt::DescendingOrder);
	}
	}
	else if (event->type() == QEvent::KeyRelease)
	{
	if (ui->filterEdit->text() != tr("Filter..") && !ui->filterEdit->text().isEmpty()) {
	mFilterModel->setFilterWildcard(ui->filterEdit->text());
	mFilterModel->sort(3, Qt::DescendingOrder);
	}
	else {
	mFilterModel->setFilterWildcard("");
	mFilterModel->sort(3, Qt::DescendingOrder);
	}
	}
	}

	return QDialog::eventFilter(object, event);
	}

	bool HistoryDialog::event(QEvent *event)
	{
	if (event->type() == QEvent::Show)
	{
	restoreGeometry(ScreenshotManager::instance()->settings()->value("geometry/historyDialog").toByteArray());
	}
	else if (event->type() == QEvent::Close)
	{
	ScreenshotManager::instance()->settings()->setValue("geometry/historyDialog", saveGeometry());
	}


	return QDialog::event(event);
	}
	diff --git a/dialogs/historydialog.h b/dialogs/historydialog.h
	index 3106f25..ba6eb20 100644
	--- a/dialogs/historydialog.h
	+++ b/dialogs/historydialog.h
	@@ -1,46 +1,46 @@
	#ifndef UPLOADDIALOG_H
	#define UPLOADDIALOG_H

	#include <QDialog>
	#include <QItemSelection>

	namespace Ui {
	class HistoryDialog;
	}

	class QSqlTableModel;
	class QSortFilterProxyModel;
	class HistoryDialog : public QDialog
	{
	Q_OBJECT

	public:
	explicit HistoryDialog(QWidget *parent = 0);
	~HistoryDialog();

	private slots:
	void clear();
	void contextMenu(QPoint point);
	void copy();
	void deleteImage();
	void location();
	void removeHistoryEntry();
	void refresh();
	void open(QModelIndex index);
	void selectionChanged(QItemSelection selected, QItemSelection deselected);
	void upload();
	- void uploadProgress(qint64 sent, qint64 total);
	+ void uploadProgress(int progress);

	protected:
	bool eventFilter(QObject object, QEvent event);
	bool event(QEvent *event);

	private:
	Ui::HistoryDialog *ui;
	QSqlTableModel *mModel;
	QSortFilterProxyModel *mFilterModel;
	QString mSelectedScreenshot;
	QModelIndex mContextIndex;
	};

	#endif // UPLOADDIALOG_H
	diff --git a/lightscreenwindow.cpp b/lightscreenwindow.cpp
	index 8db5a28..2318d57 100644
	--- a/lightscreenwindow.cpp
	+++ b/lightscreenwindow.cpp
	@@ -1,1013 +1,1012 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#include <QDate>
	#include <QDesktopServices>
	#include <QDesktopWidget>
	#include <QFileInfo>
	#include <QKeyEvent>
	#include <QMainWindow>
	#include <QMenu>
	#include <QMessageBox>
	#include <QPointer>
	#include <QProcess>
	#include <QSettings>
	#include <QSystemTrayIcon>
	#include <QTimer>
	#include <QToolTip>
	#include <QUrl>
	#include <QSound>

	#ifdef Q_OS_WIN
	#include <windows.h>
	#include <QtWinExtras>
	#endif

	/*
	* Lightscreen includes
	*/
	#include "lightscreenwindow.h"
	#include "dialogs/optionsdialog.h"
	#include "dialogs/previewdialog.h"
	#include "dialogs/historydialog.h"

	#include "tools/globalshortcut/globalshortcutmanager.h"
	#include "tools/os.h"
	#include "tools/screenshot.h"
	#include "tools/screenshotmanager.h"

	#include "tools/uploader/uploader.h"

	#include "updater/updater.h"

	LightscreenWindow::LightscreenWindow(QWidget *parent) :
	QMainWindow(parent),
	mDoCache(false),
	mHideTrigger(false),
	mReviveMain(false),
	mWasVisible(true),
	mLastMessage(0),
	mLastMode(-1),
	mLastScreenshot()
	{
	ui.setupUi(this);

	if (QtWin::isCompositionEnabled()) {
	setAttribute(Qt::WA_NoSystemBackground);
	QtWin::enableBlurBehindWindow(this);
	QtWin::extendFrameIntoClientArea(this, QMargins(-1, -1, -1, -1));
	}

	ui.screenPushButton->setIcon(os::icon("screen.big"));
	ui.areaPushButton->setIcon(os::icon("area.big"));
	ui.windowPushButton->setIcon(os::icon("pickWindow.big"));

	ui.optionsPushButton->setIcon(os::icon("configure"));
	ui.folderPushButton->setIcon(os::icon("folder"));
	ui.imgurPushButton->setIcon(os::icon("imgur"));

	setMaximumSize(size());
	setMinimumSize(size());

	- setWindowFlags(Qt::Window);
	+ setWindowFlags(windowFlags() ^ Qt::WindowMaximizeButtonHint);

	#ifdef Q_OS_WIN
	if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS7) {
	mTaskbarButton = new QWinTaskbarButton(this);
	}

	if (QSysInfo::windowsVersion() < QSysInfo::WV_WINDOWS7) {
	ui.centralWidget->setStyleSheet("QPushButton { padding: 2px; border: 1px solid #acacac; background: qlineargradient(spread:pad, x1:0, y1:0, x2:0, y2:1, stop:0 #eaeaea, stop:1 #e5e5e5);} QPushButton:hover { border: 1px solid #7eb4ea; background-color: #e4f0fc; }");
	}
	#endif

	// Actions
	connect(ui.screenPushButton, SIGNAL(clicked()), this, SLOT(screenshotAction()));
	connect(ui.areaPushButton , SIGNAL(clicked()), this, SLOT(areaHotkey()));
	connect(ui.windowPushButton, SIGNAL(clicked()), this, SLOT(windowPickerHotkey()));

	connect(ui.optionsPushButton, SIGNAL(clicked()), this, SLOT(showOptions()));
	connect(ui.folderPushButton , SIGNAL(clicked()), this, SLOT(goToFolder()));

	connect(ui.imgurPushButton, SIGNAL(clicked()), this, SLOT(createUploadMenu()));

	// Uploader
	- connect(Uploader::instance(), SIGNAL(progress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
	+ connect(Uploader::instance(), SIGNAL(progress(int)), this, SLOT(uploadProgress(int)));
	connect(Uploader::instance(), SIGNAL(done(QString, QString, QString)), this, SLOT(showUploaderMessage(QString, QString)));
	connect(Uploader::instance(), SIGNAL(error(QString)), this, SLOT(showUploaderError(QString)));

	// Manager
	connect(ScreenshotManager::instance(), SIGNAL(confirm(Screenshot)), this, SLOT(preview(Screenshot)));
	connect(ScreenshotManager::instance(), SIGNAL(windowCleanup(Screenshot::Options&)), this, SLOT(cleanup(Screenshot::Options&)));

	if (!settings()->contains("file/format")) {
	showOptions(); // There are no options (or the options config is invalid or incomplete)
	}
	else {
	QTimer::singleShot(0 , this, SLOT(applySettings()));
	QTimer::singleShot(5000, this, SLOT(checkForUpdates()));
	}
	}

	LightscreenWindow::~LightscreenWindow()
	{
	settings()->setValue("lastScreenshot", mLastScreenshot);
	settings()->sync();

	GlobalShortcutManager::instance()->clear();
	delete mTrayIcon;
	}

	void LightscreenWindow::action(int mode)
	{
	if (mode == 4) {
	goToFolder();
	}
	else {
	show();
	}
	}

	void LightscreenWindow::areaHotkey()
	{
	screenshotAction(2);
	}

	void LightscreenWindow::checkForUpdates()
	{
	if (settings()->value("options/disableUpdater", false).toBool())
	return;

	if (settings()->value("lastUpdateCheck").toInt() + 7
	> QDate::currentDate().dayOfYear())
	return; // If 7 days have not passed since the last update check.

	mUpdater = new Updater(this);

	connect(mUpdater, SIGNAL(done(bool)), this, SLOT(updaterDone(bool)));
	mUpdater->check();
	}

	void LightscreenWindow::cleanup(Screenshot::Options &options)
	{
	// Reversing settings
	if (settings()->value("options/hide").toBool()) {
	#ifndef Q_WS_X11 // X is not quick enough and the notification ends up everywhere but in the icon
	if (settings()->value("options/tray").toBool() && mTrayIcon) {
	mTrayIcon->show();
	}
	#endif

	if (mPreviewDialog) {
	if (mPreviewDialog->count() <= 1 && mWasVisible) {
	show();
	}

	mPreviewDialog->show();
	}
	else if (mWasVisible) {
	show();
	}

	mHideTrigger = false;
	}

	if (settings()->value("options/tray").toBool() && mTrayIcon) {
	notify(options.result);

	if (settings()->value("options/message").toBool() && options.file && !options.upload) {
	// This message wll get shown only when messages are enabled and the file won't get another upload pop-up soon.
	showScreenshotMessage(options.result, options.fileName);
	}
	}

	if (settings()->value("options/playSound", false).toBool()) {
	if (options.result == Screenshot::Success) {
	QSound::play("sounds/ls.screenshot.wav");
	}
	else {
	#ifdef Q_OS_WIN
	QSound::play("afakepathtomakewindowsplaythedefaultsoundtheresprobablyabetterwaybuticantbebothered");
	#else
	QSound::play("sound/ls.error.wav");
	#endif
	}

	}

	updateUploadStatus();

	if (options.result != Screenshot::Success)
	return;

	mLastScreenshot = options.fileName;
	}

	void LightscreenWindow::closeToTrayWarning()
	{
	if (!settings()->value("options/closeToTrayWarning", true).toBool())
	return;

	mLastMessage = 3;
	mTrayIcon->showMessage(tr("Closed to tray"), tr("Lightscreen will keep running, you can disable this in the options menu."));
	settings()->setValue("options/closeToTrayWarning", false);
	}

	bool LightscreenWindow::closingWithoutTray()
	{
	if (settings()->value("options/disableHideAlert", false).toBool())
	return false;

	QMessageBox msgBox;
	msgBox.setWindowTitle(tr("Lightscreen"));
	msgBox.setText(tr("You have chosen to hide Lightscreen when there's no system tray icon, so you will not be able to access the program <b>unless you have selected a hotkey to do so</b>.<br>What do you want to do?"));
	msgBox.setIcon(QMessageBox::Warning);

	msgBox.setStyleSheet("QPushButton { padding: 4px 8px; }");

	QPushButton *enableButton = msgBox.addButton(tr("Hide but enable tray"),
	QMessageBox::ActionRole);
	QPushButton *enableAndDenotifyButton = msgBox.addButton(tr("Hide and don't warn"),
	QMessageBox::ActionRole);
	QPushButton *hideButton = msgBox.addButton(tr("Just hide"),
	QMessageBox::ActionRole);
	QPushButton *abortButton = msgBox.addButton(QMessageBox::Cancel);

	Q_UNUSED(abortButton);

	msgBox.exec();

	if (msgBox.clickedButton() == hideButton) {
	return true;
	}
	else if (msgBox.clickedButton() == enableAndDenotifyButton) {
	settings()->setValue("options/disableHideAlert", true);
	applySettings();
	return true;
	}
	else if (msgBox.clickedButton() == enableButton) {
	settings()->setValue("options/tray", true);
	applySettings();
	return true;
	}

	return false; // Cancel.
	}

	void LightscreenWindow::createUploadMenu()
	{
	QMenu* imgurMenu = new QMenu(tr("Upload"));

	QAction *uploadAction = new QAction(os::icon("imgur"), tr("&Upload last"), imgurMenu);
	uploadAction->setToolTip(tr("Upload the last screenshot you took to imgur.com"));
	connect(uploadAction, SIGNAL(triggered()), this, SLOT(uploadLast()));

	QAction *cancelAction = new QAction(os::icon("no"), tr("&Cancel upload"), imgurMenu);
	cancelAction->setToolTip(tr("Cancel the currently uploading screenshots"));
	cancelAction->setEnabled(false);

	connect(this, SIGNAL(uploading(bool)), cancelAction, SLOT(setEnabled(bool)));
	connect(cancelAction, SIGNAL(triggered()), this, SLOT(uploadCancel()));

	QAction *historyAction = new QAction(os::icon("view-history"), tr("View &History"), imgurMenu);
	connect(historyAction, SIGNAL(triggered()), this, SLOT(showHistoryDialog()));

	imgurMenu->addAction(uploadAction);
	imgurMenu->addAction(cancelAction);
	imgurMenu->addAction(historyAction);
	imgurMenu->addSeparator();

	connect(imgurMenu, SIGNAL(aboutToShow()), this, SLOT(uploadMenuShown()));

	ui.imgurPushButton->setMenu(imgurMenu);
	ui.imgurPushButton->showMenu();
	}

	void LightscreenWindow::goToFolder()
	{
	#ifdef Q_OS_WIN
	if (!mLastScreenshot.isEmpty() && QFile::exists(mLastScreenshot)) {
	QProcess::startDetached("explorer /select, \"" + mLastScreenshot +"\"");
	}
	else {
	#endif
	QString folder = settings()->value("file/target").toString();

	if (folder.isEmpty())
	folder = qApp->applicationDirPath();

	if (QDir::toNativeSeparators(folder.at(folder.size()-1)) != QDir::separator())
	folder.append(QDir::separator());

	QDesktopServices::openUrl("file:///"+folder);
	#ifdef Q_OS_WIN
	}
	#endif
	}

	void LightscreenWindow::messageClicked()
	{
	if (mLastMessage == 1) {
	goToFolder();
	}
	else if (mLastMessage == 3) {
	QTimer::singleShot(0, this, SLOT(showOptions()));
	}
	else {
	QDesktopServices::openUrl(QUrl(Uploader::instance()->lastUrl()));
	}
	}

	void LightscreenWindow::messageReceived(const QString &message)
	{
	if (message.contains(' ')) {
	foreach (QString argument, message.split(' ')) {
	messageReceived(argument);
	}
	}

	if (message == "--wake") {
	show();
	qApp->alert(this, 500);
	return;
	}

	if (message == "--screen")
	screenshotAction();
	else if (message == "--area")
	screenshotAction(2);
	else if (message == "--activewindow")
	screenshotAction(1);
	else if (message == "--pickwindow")
	screenshotAction(3);
	else if (message == "--folder")
	action(4);
	else if (message == "--uploadlast")
	uploadLast();
	else if (message == "--viewhistory")
	showHistoryDialog();
	}

	void LightscreenWindow::notify(const Screenshot::Result &result)
	{
	switch (result)
	{
	case Screenshot::Success:
	mTrayIcon->setIcon(QIcon(":/icons/lightscreen.yes"));

	#ifdef Q_OS_WIN
	if (mTaskbarButton)
	mTaskbarButton->setOverlayIcon(os::icon("yes"));
	#endif

	setWindowTitle(tr("Success!"));
	break;
	case Screenshot::Fail:
	mTrayIcon->setIcon(QIcon(":/icons/lightscreen.no"));
	setWindowTitle(tr("Failed!"));
	#ifdef Q_OS_WIN
	if (mTaskbarButton) {
	mTaskbarButton->setOverlayIcon(os::icon("no"));
	}
	#endif
	break;
	case Screenshot::Cancel:
	setWindowTitle(tr("Cancelled!"));
	break;
	}

	QTimer::singleShot(2000, this, SLOT(restoreNotification()));
	}

	void LightscreenWindow::preview(Screenshot* screenshot)
	{
	if (screenshot->options().preview) {
	if (!mPreviewDialog) {
	mPreviewDialog = new PreviewDialog(this);
	}

	mPreviewDialog->add(screenshot);
	}
	else {
	screenshot->confirm(true);
	}
	}

	void LightscreenWindow::quit()
	{
	settings()->setValue("position", pos());

	int answer = 0;
	QString doing;

	if (ScreenshotManager::instance()->activeCount() > 0) {
	doing = tr("processing");
	}

	if (Uploader::instance()->uploading() > 0) {
	if (doing.isEmpty()) {
	doing = tr("uploading");
	}
	else {
	doing = tr("processing and uploading");
	}
	}

	if (!doing.isEmpty()) {
	answer = QMessageBox::question(this,
	tr("Are you sure you want to quit?"),
	tr("Lightscreen is currently %1 screenshots. Are you sure you want to quit?").arg(doing),
	tr("Quit"),
	tr("Don't Quit"));
	}

	if (answer == 0)
	emit finished();
	}

	void LightscreenWindow::restoreNotification()
	{
	if (mTrayIcon)
	mTrayIcon->setIcon(QIcon(":/icons/lightscreen.small"));

	#ifdef Q_OS_WIN
	if (mTaskbarButton)
	mTaskbarButton->clearOverlayIcon();
	#endif

	updateUploadStatus();
	}

	void LightscreenWindow::screenshotAction(int mode)
	{
	int delayms = -1;

	bool optionsHide = settings()->value("options/hide").toBool(); // Option cache, used a couple of times.

	if (!mHideTrigger) {
	mWasVisible = isVisible();
	mHideTrigger = true;
	}

	// Applying pre-screenshot settings
	if (optionsHide) {
	hide();

	#ifndef Q_WS_X11 // X is not quick enough and the notification ends up everywhere but in the icon
	if (mTrayIcon)
	mTrayIcon->hide();
	#endif
	}

	// Screenshot delay
	delayms = settings()->value("options/delay", 0).toInt();
	delayms = delayms * 1000; // Converting the delay to milliseconds.

	delayms += 400;

	if (optionsHide && mPreviewDialog) {
	if (mPreviewDialog->count() >= 1) {
	mPreviewDialog->hide();
	}
	}

	// The delayed functions works using the static variable lastMode
	// which keeps the argument so a QTimer can call this function again.
	if (delayms > 0) {
	if (mLastMode < 0) {
	mLastMode = mode;

	QTimer::singleShot(delayms, this, SLOT(screenshotAction()));
	return;
	}
	else {
	mode = mLastMode;
	mLastMode = -1;
	}
	}

	static Screenshot::Options options;

	if (!mDoCache) {
	// Populating the option object that will then be passed to the screenshot engine (sounds fancy huh?)
	options.file = settings()->value("file/enabled").toBool();
	options.format = (Screenshot::Format) settings()->value("file/format").toInt();
	options.prefix = settings()->value("file/prefix").toString();

	QDir dir(settings()->value("file/target").toString());
	dir.makeAbsolute();

	options.directory = dir;

	options.quality = settings()->value("options/quality", 100).toInt();
	options.currentMonitor = settings()->value("options/currentMonitor", false).toBool();
	options.clipboard = settings()->value("options/clipboard", true).toBool();
	options.imgurClipboard = settings()->value("options/imgurClipboard", false).toBool();
	options.preview = settings()->value("options/preview", false).toBool();
	options.magnify = settings()->value("options/magnify", false).toBool();
	options.cursor = settings()->value("options/cursor", true).toBool();
	options.saveAs = settings()->value("options/saveAs", false).toBool();
	options.animations = settings()->value("options/animations", true).toBool();
	options.replace = settings()->value("options/replace", false).toBool();
	options.upload = settings()->value("options/uploadAuto", false).toBool();
	options.optimize = settings()->value("options/optipng", false).toBool();

	Screenshot::NamingOptions namingOptions;
	namingOptions.naming = (Screenshot::Naming) settings()->value("file/naming").toInt();
	namingOptions.leadingZeros = settings()->value("options/naming/leadingZeros", 0).toInt();
	namingOptions.flip = settings()->value("options/flip", false).toBool();
	namingOptions.dateFormat = settings()->value("options/naming/dateFormat", "yyyy-MM-dd").toString();

	options.namingOptions = namingOptions;

	mDoCache = true;
	}

	options.mode = mode;

	ScreenshotManager::instance()->take(options);
	}

	void LightscreenWindow::screenshotActionTriggered(QAction* action)
	{
	screenshotAction(action->data().toInt());
	}

	void LightscreenWindow::showHotkeyError(const QStringList &hotkeys)
	{
	static bool dontShow = false;

	if (dontShow)
	return;

	QString messageText;

	messageText = tr("Some hotkeys could not be registered, they might already be in use");

	if (hotkeys.count() > 1) {
	messageText += tr("<br>The failed hotkeys are the following:") + "<ul>";

	foreach(const QString &hotkey, hotkeys) {
	messageText += QString("%1%2%3").arg("<li><b>").arg(hotkey).arg("</b></li>");
	}

	messageText += "</ul>";
	}
	else {
	messageText += tr("<br>The failed hotkey is <b>%1</b>").arg(hotkeys[0]);
	}

	messageText += tr("<br><i>What do you want to do?</i>");

	QMessageBox msgBox(this);
	msgBox.setWindowTitle(tr("Lightscreen"));
	msgBox.setText(messageText);

	QPushButton *changeButton = msgBox.addButton(tr("Change") , QMessageBox::ActionRole);
	QPushButton *disableButton = msgBox.addButton(tr("Disable"), QMessageBox::ActionRole);
	QPushButton *exitButton = msgBox.addButton(tr("Quit") , QMessageBox::ActionRole);

	msgBox.exec();

	if (msgBox.clickedButton() == exitButton) {
	dontShow = true;
	QTimer::singleShot(10, this, SLOT(quit()));
	}
	else if (msgBox.clickedButton() == changeButton) {
	showOptions();
	}
	else if (msgBox.clickedButton() == disableButton) {
	foreach(const QString &hotkey, hotkeys) {
	settings()->setValue(QString("actions/%1/enabled").arg(hotkey), false);
	}
	}
	}

	void LightscreenWindow::showHistoryDialog()
	{
	HistoryDialog historyDialog(this);
	historyDialog.exec();

	updateUploadStatus();
	}

	void LightscreenWindow::showOptions()
	{
	GlobalShortcutManager::clear();

	QPointer<OptionsDialog> optionsDialog = new OptionsDialog(this);

	optionsDialog->exec();
	optionsDialog->deleteLater();

	applySettings();
	}

	void LightscreenWindow::showScreenshotMessage(const Screenshot::Result &result, const QString &fileName)
	{
	if (result == Screenshot::Cancel)
	return;

	// Showing message.
	QString title;
	QString message;

	if (result == Screenshot::Success) {
	title = QFileInfo(fileName).fileName();

	if (settings()->value("file/target").toString().isEmpty()) {
	message = QDir::toNativeSeparators(QCoreApplication::applicationDirPath());
	}
	else {
	message = tr("Saved to \"%1\"").arg(settings()->value("file/target").toString());
	}
	}
	else {
	title = tr("The screenshot was not taken");
	message = tr("An error occurred.");
	}

	mLastMessage = 1;
	mTrayIcon->showMessage(title, message);
	}

	void LightscreenWindow::showUploaderError(const QString &error)
	{
	mLastMessage = -1;

	if (mTrayIcon && !error.isEmpty() && settings()->value("options/message").toBool()) {
	mTrayIcon->showMessage(tr("Upload error"), error);
	}

	updateUploadStatus();
	}

	void LightscreenWindow::showUploaderMessage(QString fileName, QString url)
	{
	if (mTrayIcon && settings()->value("options/message").toBool() && !url.isEmpty()) {
	QString screenshot = QFileInfo(fileName).fileName();

	if (screenshot.startsWith(".lstemp."))
	screenshot = tr("Screenshot");

	mLastMessage = 2;
	mTrayIcon->showMessage(tr("%1 uploaded").arg(screenshot), tr("Click here to go to %1").arg(url));
	}

	updateUploadStatus();
	}

	void LightscreenWindow::toggleVisibility(QSystemTrayIcon::ActivationReason reason)
	{
	if (reason != QSystemTrayIcon::DoubleClick)
	return;

	if (isVisible()) {
	hide();
	}
	else {
	show();
	os::setForegroundWindow(this);
	}
	}

	void LightscreenWindow::updateUploadStatus()
	{
	int uploadCount = Uploader::instance()->uploading();
	QString statusString;

	if (uploadCount > 0) {
	statusString = tr("%1 uploading - Lightscreen").arg(uploadCount);
	emit uploading(true);
	}
	else {
	statusString = tr("Lightscreen");
	emit uploading(false);

	#ifdef Q_OS_WIN
	if (mTaskbarButton) {
	mTaskbarButton->progress()->setVisible(false);
	}
	#endif
	}

	if (mTrayIcon) {
	mTrayIcon->setToolTip(statusString);
	}

	setWindowTitle(statusString);
	}

	void LightscreenWindow::updaterDone(bool result)
	{
	settings()->setValue("lastUpdateCheck", QDate::currentDate().dayOfYear());

	if (!result)
	return;

	QMessageBox msgBox;
	msgBox.setWindowTitle(tr("Lightscreen"));
	msgBox.setText(tr("There's a new version of Lightscreen available.<br>Would you like to see more information?<br>(<em>You can turn this notification off</em>)"));
	msgBox.setIcon(QMessageBox::Information);

	QPushButton *yesButton = msgBox.addButton(QMessageBox::Yes);
	QPushButton *turnOffButton = msgBox.addButton(tr("Turn Off"), QMessageBox::ActionRole);
	QPushButton *remindButton = msgBox.addButton(tr("Remind Me Later"), QMessageBox::RejectRole);

	Q_UNUSED(remindButton);

	msgBox.exec();

	if (msgBox.clickedButton() == yesButton) {
	QDesktopServices::openUrl(QUrl("http://lightscreen.com.ar/whatsnew?from=" + qApp->applicationVersion()));
	}
	else if (msgBox.clickedButton() == turnOffButton) {
	settings()->setValue("options/disableUpdater", true);
	}

	mUpdater->deleteLater();
	}

	void LightscreenWindow::upload(const QString &fileName)
	{
	Uploader::instance()->upload(fileName);
	}

	void LightscreenWindow::uploadCancel()
	{
	if (Uploader::instance()->uploading() <= 0) {
	return;
	}

	int confirm = QMessageBox::question(this, tr("Upload cancel"), tr("Do you want to cancel all screenshot uploads?"), tr("Cancel"), tr("Don't Cancel"));

	if (confirm == 0) {
	Uploader::instance()->cancel();
	updateUploadStatus();
	}
	}

	void LightscreenWindow::uploadLast()
	{
	upload(mLastScreenshot);
	updateUploadStatus();
	}

	-void LightscreenWindow::uploadProgress(qint64 sent, qint64 total)
	+void LightscreenWindow::uploadProgress(int progress)
	{
	#ifdef Q_OS_WIN
	if (mTaskbarButton) {
	- mTaskbarButton->progress()->setRange(0, total);
	- mTaskbarButton->progress()->setValue(sent);
	+ mTaskbarButton->progress()->setRange(0, 100);
	+ mTaskbarButton->progress()->setValue(progress);
	}

	- if (isVisible() && total > 0) {
	+ if (isVisible() && progress > 0) {
	int uploadCount = Uploader::instance()->uploading();
	- int progress = (sent*100)/total;

	if (uploadCount > 1) {
	setWindowTitle(tr("%1% of %2 uploads - Lightscreen").arg(progress).arg(uploadCount));
	}
	else {
	setWindowTitle(tr("%1% - Lightscreen").arg(progress));
	}
	}
	#endif
	}

	void LightscreenWindow::uploadMenuShown()
	{
	QMenu imgurMenu = qobject_cast<QMenu>(sender());
	imgurMenu->actions().at(0)->setEnabled(!mLastScreenshot.isEmpty());
	}

	void LightscreenWindow::windowHotkey()
	{
	screenshotAction(1);
	}

	void LightscreenWindow::windowPickerHotkey()
	{
	screenshotAction(3);
	}

	void LightscreenWindow::applySettings()
	{
	bool tray = settings()->value("options/tray").toBool();

	if (tray && !mTrayIcon) {
	createTrayIcon();
	mTrayIcon->show();
	}
	else if (!tray && mTrayIcon) {
	mTrayIcon->deleteLater();
	}

	connectHotkeys();

	mDoCache = false;

	if (settings()->value("lastScreenshot").isValid() && mLastScreenshot.isEmpty())
	mLastScreenshot = settings()->value("lastScreenshot").toString();

	os::setStartup(settings()->value("options/startup").toBool(), settings()->value("options/startupHide").toBool());
	}

	void LightscreenWindow::connectHotkeys()
	{
	// Set to true because if the hotkey is disabled it will show an error.
	bool screen = true, area = true, window = true, windowPicker = true, open = true, directory = true;

	if (settings()->value("actions/screen/enabled").toBool())
	screen = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/screen/hotkey").value<QKeySequence> (), this, SLOT(screenshotAction()));

	if (settings()->value("actions/area/enabled").toBool())
	area = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/area/hotkey").value<QKeySequence> (), this, SLOT(areaHotkey()));

	if (settings()->value("actions/window/enabled").toBool())
	window = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/window/hotkey").value<QKeySequence> (), this, SLOT(windowHotkey()));

	if (settings()->value("actions/windowPicker/enabled").toBool())
	windowPicker = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/windowPicker/hotkey").value<QKeySequence> (), this, SLOT(windowPickerHotkey()));

	if (settings()->value("actions/open/enabled").toBool())
	open = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/open/hotkey").value<QKeySequence> (), this, SLOT(show()));

	if (settings()->value("actions/directory/enabled").toBool())
	directory = GlobalShortcutManager::instance()->connect(settings()->value(
	"actions/directory/hotkey").value<QKeySequence> (), this, SLOT(goToFolder()));

	QStringList failed;
	if (!screen) failed << "screen";
	if (!area) failed << "area";
	if (!window) failed << "window";
	if (!windowPicker) failed << "window picker";
	if (!open) failed << "open";
	if (!directory) failed << "directory";

	if (!failed.isEmpty())
	showHotkeyError(failed);
	}

	void LightscreenWindow::createTrayIcon()
	{
	mTrayIcon = new QSystemTrayIcon(QIcon(":/icons/lightscreen.small"), this);
	updateUploadStatus();

	connect(mTrayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(toggleVisibility(QSystemTrayIcon::ActivationReason)));
	connect(mTrayIcon, SIGNAL(messageClicked()), this, SLOT(messageClicked()));

	QAction *hideAction = new QAction(QIcon(":/icons/lightscreen.small"), tr("Show&/Hide"), mTrayIcon);
	connect(hideAction, SIGNAL(triggered()), this, SLOT(toggleVisibility()));

	QAction *screenAction = new QAction(os::icon("screen"), tr("&Screen"), mTrayIcon);
	screenAction->setData(QVariant(0));

	QAction *windowAction = new QAction(os::icon("window"), tr("Active &Window"), this);
	windowAction->setData(QVariant(1));

	QAction *windowPickerAction = new QAction(os::icon("pickWindow"), tr("&Pick Window"), this);
	windowPickerAction->setData(QVariant(3));

	QAction *areaAction = new QAction(os::icon("area"), tr("&Area"), mTrayIcon);
	areaAction->setData(QVariant(2));

	QActionGroup *screenshotGroup = new QActionGroup(mTrayIcon);
	screenshotGroup->addAction(screenAction);
	screenshotGroup->addAction(areaAction);
	screenshotGroup->addAction(windowAction);
	screenshotGroup->addAction(windowPickerAction);

	connect(screenshotGroup, SIGNAL(triggered(QAction)), this, SLOT(screenshotActionTriggered(QAction)));

	// Duplicated for the screenshot button :(
	QAction *uploadAction = new QAction(os::icon("imgur"), tr("&Upload last"), mTrayIcon);
	uploadAction->setToolTip(tr("Upload the last screenshot you took to imgur.com"));
	connect(uploadAction, SIGNAL(triggered()), this, SLOT(uploadLast()));

	QAction *cancelAction = new QAction(os::icon("no"), tr("&Cancel upload"), mTrayIcon);
	cancelAction->setToolTip(tr("Cancel the currently uploading screenshots"));
	cancelAction->setEnabled(false);
	connect(this, SIGNAL(uploading(bool)), cancelAction, SLOT(setEnabled(bool)));
	connect(cancelAction, SIGNAL(triggered()), this, SLOT(uploadCancel()));

	QAction *historyAction = new QAction(os::icon("view-history"), tr("View History"), mTrayIcon);
	connect(historyAction, SIGNAL(triggered()), this, SLOT(showHistoryDialog()));
	//

	QAction *optionsAction = new QAction(os::icon("configure"), tr("View &Options"), mTrayIcon);
	connect(optionsAction, SIGNAL(triggered()), this, SLOT(showOptions()));

	QAction *goAction = new QAction(os::icon("folder"), tr("&Go to Folder"), mTrayIcon);
	connect(goAction, SIGNAL(triggered()), this, SLOT(goToFolder()));

	QAction *quitAction = new QAction(tr("&Quit"), mTrayIcon);
	connect(quitAction, SIGNAL(triggered()), this, SLOT(quit()));

	QMenu* screenshotMenu = new QMenu(tr("Screenshot"));
	screenshotMenu->addAction(screenAction);
	screenshotMenu->addAction(areaAction);
	screenshotMenu->addAction(windowAction);
	screenshotMenu->addAction(windowPickerAction);

	// Duplicated for the screenshot button :(
	QMenu* imgurMenu = new QMenu(tr("Upload"));
	imgurMenu->addAction(uploadAction);
	imgurMenu->addAction(cancelAction);
	imgurMenu->addAction(historyAction);
	imgurMenu->addSeparator();

	QMenu* trayIconMenu = new QMenu;
	trayIconMenu->addAction(hideAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addMenu(imgurMenu);
	trayIconMenu->addSeparator();
	trayIconMenu->addMenu(screenshotMenu);
	trayIconMenu->addAction(optionsAction);
	trayIconMenu->addAction(goAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(quitAction);

	mTrayIcon->setContextMenu(trayIconMenu);
	}

	QSettings *LightscreenWindow::settings() const
	{
	return ScreenshotManager::instance()->settings();
	}

	// Event handling
	bool LightscreenWindow::event(QEvent *event)
	{
	if (event->type() == QEvent::Hide) {
	settings()->setValue("position", pos());
	}
	else if (event->type() == QEvent::Close) {
	if (settings()->value("options/tray").toBool() && settings()->value("options/closeHide").toBool()) {
	closeToTrayWarning();
	hide();
	}
	else if (settings()->value("options/closeHide").toBool()) {
	if (closingWithoutTray())
	hide();
	}
	else {
	quit();
	}
	}
	else if (event->type() == QEvent::Show) {
	QPoint savedPosition = settings()->value("position").toPoint();

	if (!savedPosition.isNull() && qApp->desktop()->availableGeometry().contains(QRect(savedPosition, size())))
	move(savedPosition);
	}
	else if (event->type() == QEvent::KeyPress) {
	QKeyEvent keyEvent = static_cast<QKeyEvent>(event);
	#ifdef Q_WS_MAC
	if (keyEvent->modifiers() == Qt::ControlModifier && e->key() == Qt::Key_Period) {
	keyEvent->ignore();

	if(isVisible())
	toggleVisibility();

	return false;
	}
	else
	#endif
	if (!keyEvent->modifiers() && keyEvent->key() == Qt::Key_Escape) {
	keyEvent->ignore();

	if(isVisible())
	toggleVisibility();

	return false;
	}
	}
	else if (event->type() == QEvent::LanguageChange) {
	ui.retranslateUi(this);
	resize(minimumSizeHint());
	}


	return QMainWindow::event(event);
	}
	diff --git a/lightscreenwindow.h b/lightscreenwindow.h
	index fbab939..4bf12ca 100644
	--- a/lightscreenwindow.h
	+++ b/lightscreenwindow.h
	@@ -1,117 +1,117 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#ifndef LIGHTSCREENWINDOW_H
	#define LIGHTSCREENWINDOW_H

	#include <QMainWindow>
	#include <QPointer>
	#include <QSystemTrayIcon>

	#include "updater/updater.h"
	#include "tools/screenshot.h"
	#include "dialogs/previewdialog.h"

	#include "ui_lightscreenwindow.h"

	class QHttp;
	class Updater;
	class QSettings;
	class QWinTaskbarButton;
	class LightscreenWindow : public QMainWindow
	{
	Q_OBJECT

	public:
	LightscreenWindow(QWidget *parent = 0);
	~LightscreenWindow();

	public slots:
	void action(int mode = 3);
	void areaHotkey();
	void checkForUpdates();
	void cleanup(Screenshot::Options &options);
	void closeToTrayWarning();
	bool closingWithoutTray();
	void createUploadMenu();
	void goToFolder();
	void messageClicked();
	void messageReceived(const QString &message);
	void notify(const Screenshot::Result &result);
	void preview(Screenshot* screenshot);
	void quit();
	void restoreNotification();
	void screenshotAction(int mode = 0);
	void screenshotActionTriggered(QAction* action);
	void showHotkeyError(const QStringList &hotkeys);
	void showHistoryDialog();
	void showOptions();
	void showScreenshotMessage(const Screenshot::Result &result, const QString &fileName);
	void showUploaderError(const QString &error);
	void showUploaderMessage(QString fileName, QString url);
	void toggleVisibility(QSystemTrayIcon::ActivationReason reason = QSystemTrayIcon::DoubleClick);
	void updateUploadStatus();
	void updaterDone(bool result);
	void upload(const QString &fileName);
	void uploadCancel();
	void uploadLast();
	- void uploadProgress(qint64 sent, qint64 total);
	+ void uploadProgress(int progress);
	void uploadMenuShown();
	void windowHotkey();
	void windowPickerHotkey();

	private slots:
	void applySettings();

	signals:
	void uploading(bool uploading);
	void finished();

	private:
	void connectHotkeys();
	void createTrayIcon();

	#ifdef Q_OS_WIN
	bool winEvent(MSG message, long result);
	#endif
	// Convenience function
	QSettings *settings() const;

	protected:
	bool event(QEvent *event);

	private:
	bool mDoCache;
	bool mHideTrigger;
	bool mReviveMain;
	bool mWasVisible;
	int mLastMessage;
	int mLastMode;
	QString mLastScreenshot;
	QPointer<QSystemTrayIcon> mTrayIcon;
	QPointer<PreviewDialog> mPreviewDialog;
	QPointer<Updater> mUpdater;
	Ui::LightscreenWindowClass ui;

	#ifdef Q_OS_WIN
	QWinTaskbarButton *mTaskbarButton;
	#endif
	};

	#endif // LIGHTSCREENWINDOW_H

	diff --git a/tools/screenshotmanager.cpp b/tools/screenshotmanager.cpp
	index cf88b86..d38429d 100644
	--- a/tools/screenshotmanager.cpp
	+++ b/tools/screenshotmanager.cpp
	@@ -1,211 +1,216 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#include "screenshotmanager.h"
	#include "screenshot.h"
	#include "uploader/uploader.h"

	#include <QApplication>
	#include <QDateTime>
	#include <QStandardPaths>
	#include <QFile>
	#include <QSettings>
	#include <QtSql/QSqlDatabase>
	#include <QtSql/QSqlError>
	#include <QtSql/QSqlQuery>
	#include <QtSql/QSqlRecord>

	#include <QDebug>

	ScreenshotManager::ScreenshotManager(QObject *parent = 0) : QObject(parent)
	{
	- QString historyPath;
	-
	if (QFile::exists(qApp->applicationDirPath() + QDir::separator() + "config.ini")) {
	mSettings = new QSettings(qApp->applicationDirPath() + QDir::separator() + "config.ini", QSettings::IniFormat);
	mPortableMode = true;
	- historyPath = qApp->applicationDirPath() + QDir::separator();
	+ mHistoryPath = qApp->applicationDirPath() + QDir::separator();
	}
	else {
	mSettings = new QSettings();
	mPortableMode = false;
	- historyPath = QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QDir::separator();
	+ mHistoryPath = QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QDir::separator();
	}

	+ initHistory();
	+
	+ connect(Uploader::instance(), SIGNAL(done(QString, QString, QString)), this, SLOT(uploadDone(QString, QString, QString)));
	+}
	+
	+ScreenshotManager::~ScreenshotManager()
	+{
	+ delete mSettings;
	+}
	+
	+void ScreenshotManager::initHistory()
	+{
	// Creating the SQLite database.
	QSqlDatabase history = QSqlDatabase::addDatabase("QSQLITE");

	- QDir hp(historyPath);
	+ QDir hp(mHistoryPath);

	if (!hp.exists())
	- hp.mkpath(historyPath);
	+ hp.mkpath(mHistoryPath);

	history.setHostName("localhost");
	- history.setDatabaseName(historyPath + "history.sqlite");
	+ history.setDatabaseName(mHistoryPath + "history.sqlite");

	if (history.open()) {
	history.exec("CREATE TABLE IF NOT EXISTS history (fileName text, URL text, deleteURL text, time integer)");
	}
	else {
	qCritical() << "Could not open SQLite DB.";
	}
	-
	- connect(Uploader::instance(), SIGNAL(done(QString, QString, QString)), this, SLOT(uploadDone(QString, QString, QString)));
	-}
	-
	-ScreenshotManager::~ScreenshotManager()
	-{
	- delete mSettings;
	}

	int ScreenshotManager::activeCount() const
	{
	return mScreenshots.count();
	}

	bool ScreenshotManager::portableMode()
	{
	return mPortableMode;
	}

	void ScreenshotManager::saveHistory(QString fileName, QString url, QString deleteHash)
	{
	if (!mSettings->value("/options/history", true).toBool())
	return;

	QString deleteUrl;

	if (!deleteHash.isEmpty())
	deleteUrl = "http://imgur.com/delete/" + deleteHash;

	QSqlQuery query;
	query.prepare("INSERT INTO history (fileName, URL, deleteURL, time) VALUES(?, ?, ?, ?)");
	query.addBindValue(fileName);
	query.addBindValue(url);
	query.addBindValue(deleteUrl);
	query.addBindValue(QDateTime::currentMSecsSinceEpoch());
	query.exec();
	}

	void ScreenshotManager::updateHistory(QString fileName, QString url, QString deleteHash)
	{
	if (!mSettings->value("/options/history", true).toBool())
	return;

	QSqlQuery query;
	query.prepare("SELECT fileName FROM history WHERE URL IS NOT EMPTY AND fileName = ?");
	query.addBindValue(fileName);
	query.exec();

	if (query.record().count() > 0 && !url.isEmpty()) {
	// Makes sure to only update the latest file, in case something weird happened with the files (deleted screenshots, etc). Though that might still happen in some edge cases that I'm too lazy to account for.
	QSqlQuery updateQuery;
	updateQuery.prepare("UPDATE history SET URL = ?, deleteURL = ?, time = ? WHERE fileName = ?");
	updateQuery.addBindValue(url);
	updateQuery.addBindValue("http://imgur.com/delete/" + deleteHash);
	updateQuery.addBindValue(QDateTime::currentMSecsSinceEpoch());
	updateQuery.addBindValue(fileName);

	updateQuery.exec();
	}
	else {
	saveHistory(fileName, url, deleteHash);
	}
	}

	void ScreenshotManager::removeHistory(QString fileName, qint64 time)
	{
	QSqlQuery removeQuery;
	removeQuery.prepare("DELETE FROM history WHERE fileName = ? AND time = ?");
	removeQuery.addBindValue(fileName);
	removeQuery.addBindValue(time);

	removeQuery.exec();
	}

	void ScreenshotManager::clearHistory()
	{
	QSqlQuery clearQuery("DROP TABLE history");
	clearQuery.exec();
	+
	+ initHistory();
	}

	//

	void ScreenshotManager::askConfirmation()
	{
	Screenshot* s = qobject_cast<Screenshot*>(sender());
	emit confirm(s);
	}

	void ScreenshotManager::cleanup()
	{
	Screenshot* screenshot = qobject_cast<Screenshot*>(sender());
	emit windowCleanup(screenshot->options());
	}

	void ScreenshotManager::finished()
	{
	Screenshot* screenshot = qobject_cast<Screenshot*>(sender());
	mScreenshots.removeOne(screenshot);
	screenshot->deleteLater();
	}

	void ScreenshotManager::take(Screenshot::Options &options)
	{
	Screenshot* newScreenshot = new Screenshot(this, options);
	mScreenshots.append(newScreenshot);

	connect(newScreenshot, SIGNAL(askConfirmation()), this, SLOT(askConfirmation()));
	connect(newScreenshot, SIGNAL(cleanup()) , this, SLOT(cleanup()));
	connect(newScreenshot, SIGNAL(finished()) , this, SLOT(finished()));

	newScreenshot->take();
	}

	void ScreenshotManager::uploadDone(QString fileName, QString url, QString deleteHash)
	{
	foreach (Screenshot* screenshot, mScreenshots) {
	if (screenshot->options().fileName == fileName
	\|\| screenshot->unloadedFileName() == fileName) {
	screenshot->uploadDone(url);

	if (screenshot->options().file) {
	updateHistory(fileName, url, deleteHash);
	}
	else {
	saveHistory("", url, deleteHash);
	}

	return;
	}
	}

	// If we get here, it's because the screenshot upload wasn't on the current screenshot list, which means it's a View History/Upload Later upload.
	updateHistory(fileName, url, deleteHash);
	}

	// Singleton
	ScreenshotManager* ScreenshotManager::mInstance = 0;

	ScreenshotManager *ScreenshotManager::instance()
	{
	if (!mInstance)
	mInstance = new ScreenshotManager();

	return mInstance;
	}
	diff --git a/tools/screenshotmanager.h b/tools/screenshotmanager.h
	index bd4bcc7..f505988 100644
	--- a/tools/screenshotmanager.h
	+++ b/tools/screenshotmanager.h
	@@ -1,71 +1,73 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#ifndef SCREENSHOTMANAGER_H
	#define SCREENSHOTMANAGER_H

	#include <QObject>
	#include <QList>

	#include "screenshot.h"

	class QSettings;
	class ScreenshotManager : public QObject
	{
	Q_OBJECT

	public:
	enum State
	{
	Idle = 0,
	Busy = 1,
	Disabled = 2
	};

	public:
	ScreenshotManager(QObject *parent);
	~ScreenshotManager();
	static ScreenshotManager *instance();

	+ void initHistory();
	int activeCount() const;
	bool portableMode();
	void saveHistory(QString fileName, QString url = "", QString deleteHash = "");
	void updateHistory(QString fileName, QString url, QString deleteHash);
	void removeHistory(QString fileName, qint64 time);
	void clearHistory();
	QSettings *settings() const { return mSettings; }

	public slots:
	void askConfirmation();
	void cleanup();
	void finished();
	void take(Screenshot::Options &options);
	void uploadDone(QString fileName, QString url, QString deleteHash);

	signals:
	void confirm(Screenshot* screenshot);
	void windowCleanup(Screenshot::Options &options);

	private:
	static ScreenshotManager* mInstance;
	QList<Screenshot*> mScreenshots;
	QSettings *mSettings;
	+ QString mHistoryPath;
	bool mPortableMode;
	};

	#endif // SCREENSHOTMANAGER_H
	diff --git a/tools/uploader/imageuploader.h b/tools/uploader/imageuploader.h
	index 68c9e0a..cde9ff8 100644
	--- a/tools/uploader/imageuploader.h
	+++ b/tools/uploader/imageuploader.h
	@@ -1,39 +1,43 @@
	#ifndef IMAGEUPLOADER_H
	#define IMAGEUPLOADER_H

	#include <QHash>
	#include <QVariant>

	class QNetworkReply;
	class ImageUploader : public QObject
	{
	Q_OBJECT

	public:
	static ImageUploader* getNewUploader(QString name, QVariantHash &options = QVariantHash());

	enum Error {
	FileError,
	NetworkError,
	HostError,
	CancelError,
	OtherError
	};

	public:
	ImageUploader(QVariantHash &options);

	public slots:
	virtual void upload(const QString &fileName) = 0;
	+ virtual void cancel() = 0;
	+ int progress() const { return mProgress; }
	+ void setProgress(int progress) { mProgress = progress; }

	signals:
	void uploaded(QString, QString, QString);
	void error(Error, QString);
	- void progress(int);
	+ void progressChange(int);

	protected:
	QVariantHash mOptions;
	+ int mProgress;

	};

	#endif // IMAGEUPLOADER_H
	diff --git a/tools/uploader/imguruploader.cpp b/tools/uploader/imguruploader.cpp
	index 1f9a0fc..595eda4 100644
	--- a/tools/uploader/imguruploader.cpp
	+++ b/tools/uploader/imguruploader.cpp
	@@ -1,99 +1,128 @@
	#include "imguruploader.h"
	#include <QNetworkAccessManager>
	#include <QtNetwork>

	-ImgurUploader::ImgurUploader(QVariantHash &options) : ImageUploader(options)
	+ImgurUploader::ImgurUploader(QVariantHash &options, QString fileName) : ImageUploader(options)
	{
	-
	+ upload(fileName);
	}

	void ImgurUploader::upload(const QString &fileName)
	{
	QFile file(fileName);

	if (!file.open(QIODevice::ReadOnly)) {
	emit error(ImageUploader::FileError, fileName);
	return;
	}

	QByteArray data;
	data.append(QString("key=").toUtf8());
	data.append(QUrl::toPercentEncoding(mOptions.value("APIKey", "6920a141451d125b3e1357ce0e432409").toString()));
	data.append(QString("&image=").toUtf8());
	data.append(QUrl::toPercentEncoding(file.readAll().toBase64()));
	file.close();

	QNetworkRequest request(QUrl("http://api.imgur.com/2/upload"));
	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

	QNetworkReply reply = mOptions.value("networkManager").value<QNetworkAccessManager>()->post(request, data);
	reply->setProperty("fileName", fileName);
	-// connect(reply, SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(progress(qint64, qint64)));
	+ this->setProperty("fileName", fileName);
	+
	+ connect(reply, SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
	+ connect(this , SIGNAL(cancelRequest()), reply, SLOT(abort()));
	+ connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(networkError(QNetworkReply::NetworkError)));
	connect(reply, SIGNAL(finished()), this, SLOT(finished()));
	}

	+void ImgurUploader::cancel()
	+{
	+ emit cancelRequest();
	+ deleteLater();
	+}
	+
	+void ImgurUploader::networkError(QNetworkReply::NetworkError code)
	+{
	+ QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
	+ QString fileName = reply->property("fileName").toString();
	+ reply->deleteLater();
	+
	+ switch (code)
	+ {
	+ case QNetworkReply::OperationCanceledError:
	+ emit error(ImageUploader::CancelError, fileName);
	+ break;
	+ default:
	+ emit error(ImageUploader::NetworkError, fileName);
	+ }
	+}
	+
	void ImgurUploader::finished()
	{
	QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
	QString fileName = reply->property("fileName").toString();
	reply->deleteLater();

	if (reply->error() != QNetworkReply::NoError) {
	- qDebug() << reply->errorString();
	-
	if (reply->error() == QNetworkReply::OperationCanceledError) {
	emit error(ImageUploader::CancelError, fileName);
	}
	else {
	emit error(ImageUploader::NetworkError, fileName);
	}

	return;
	}

	if (reply->rawHeader("X-RateLimit-Remaining") == "0") {
	- qDebug() << "Rate limit :(";
	emit error(ImageUploader::HostError, fileName);
	return;
	}

	QXmlStreamReader reader(reply->readAll());

	QString url_option = "imgur_page";

	if (mOptions.value("directUrl", false).toBool())
	url_option = "original";

	QString url;
	QString deleteHash;

	bool hasError = false;

	while (!reader.atEnd()) {
	reader.readNext();

	if (reader.isStartElement()) {
	if (reader.name() == "error") {
	hasError = true;
	}

	if (reader.name() == "deletehash") {
	deleteHash = reader.readElementText();
	}

	if (reader.name() == url_option) {
	url = reader.readElementText();
	}
	}
	}

	if (deleteHash.isEmpty() \|\| url.isEmpty() \|\| hasError) {
	- qDebug() << "ImgurUploader: SOME SORT OF ERROR IN THE IMGUR RESPONSE";
	emit error(ImageUploader::HostError, fileName);
	}
	else {
	- qDebug() << "Uploaded! " << url;
	emit uploaded(fileName, url, deleteHash);
	}
	}

	+void ImgurUploader::uploadProgress(qint64 bytesReceived, qint64 bytesTotal)
	+{
	+ float b = (float) bytesReceived/bytesTotal;
	+ int p = qRound(b*100);
	+ setProgress(p);
	+ emit progressChange(p);
	+}
	+
	diff --git a/tools/uploader/imguruploader.h b/tools/uploader/imguruploader.h
	index 099f07a..ac41628 100644
	--- a/tools/uploader/imguruploader.h
	+++ b/tools/uploader/imguruploader.h
	@@ -1,23 +1,30 @@
	#ifndef IMGURUPLOADER_H
	#define IMGURUPLOADER_H

	#include <QObject>
	#include <QNetworkAccessManager>
	+#include <QNetworkReply>
	#include "imageuploader.h"

	class ImgurUploader : public ImageUploader
	{
	Q_OBJECT

	public:
	- ImgurUploader(QVariantHash &options);
	+ ImgurUploader(QVariantHash &options, QString fileName = "");

	public slots:
	void upload(const QString &fileName);
	+ void cancel();

	private slots:
	void finished();
	+ void uploadProgress(qint64 bytesReceived, qint64 bytesTotal);
	+ void networkError(QNetworkReply::NetworkError code);
	+
	+signals:
	+ void cancelRequest();

	};

	#endif // IMGURUPLOADER_H
	diff --git a/tools/uploader/uploader.cpp b/tools/uploader/uploader.cpp
	index 1cdb745..025310a 100644
	--- a/tools/uploader/uploader.cpp
	+++ b/tools/uploader/uploader.cpp
	@@ -1,141 +1,117 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#include "uploader.h"
	#include "../screenshotmanager.h"
	#include "imguruploader.h"

	#include <QtNetwork>
	#include <QSettings>

	Uploader* Uploader::mInstance = 0;

	-Uploader::Uploader(QObject *parent) : QObject(parent), mProgressSent(0), mProgressTotal(0)
	+Uploader::Uploader(QObject *parent) : QObject(parent)
	{
	mNetworkAccessManager = new QNetworkAccessManager(this);
	}

	Uploader *Uploader::instance()
	{
	if (!mInstance)
	mInstance = new Uploader();

	return mInstance;
	}

	+int Uploader::progress() const
	+{
	+ return mProgress;
	+}
	+
	QString Uploader::lastUrl() const
	{
	return mLastUrl;
	}

	void Uploader::cancel()
	{
	- qDebug() << "TODO: Implement";
	- //mNetworkAccessManager->->cancelAll();
	+ mUploaders.clear();
	+ emit cancelAll();
	}
	-/*
	-void Uploader::imgurError(const QString &file, const QtImgur::Error e)
	-{
	-
	- // Removing the screenshot.
	- for (int i = 0; i < mScreenshots.size(); ++i) {
	- if (mScreenshots.at(i).first == file) {
	- mScreenshots.removeAt(i);
	- break;
	- }
	- }
	-
	- QString errorString;
	-
	- switch (e) {
	- case QtImgur::ErrorFile:
	- errorString = tr("Screenshot file not found.");
	- break;
	- case QtImgur::ErrorNetwork:
	- errorString = tr("Could not reach imgur.com");
	- break;
	- case QtImgur::ErrorCredits:
	- errorString = tr("You have exceeded your upload quota.");
	- break;
	- case QtImgur::ErrorUpload:
	- errorString = tr("Upload failed for %1.").arg(QFileInfo(file).fileName());
	- break;
	- }
	-
	- emit done(file, "", "");
	- emit error(errorString);
	-}
	-*/

	void Uploader::upload(const QString &fileName)
	{
	if (fileName.isEmpty()) {
	return;
	}

	QVariantHash options;
	options["networkManager"].setValue(mNetworkAccessManager);
	options["directUrl"] = ScreenshotManager::instance()->settings()->value("options/uploadDirectLink", false).toBool();

	- ImgurUploader *uploader = new ImgurUploader(options);
	- uploader->upload(fileName);
	-
	- connect(uploader, SIGNAL(uploaded(QString,QString,QString)), this, SLOT(uploaded(QString,QString,QString)));
	+ ImgurUploader *uploader = new ImgurUploader(options, fileName);

	- // Cancel on duplicate
	- for (int i = 0; i < mScreenshots.size(); ++i) {
	- if (mScreenshots.at(i).first == fileName) {
	- return;
	- }
	- }
	+ connect(uploader, &ImgurUploader::uploaded , this, &Uploader::uploaded);
	+ connect(uploader, &ImgurUploader::error , this, &Uploader::uploaderError);
	+ connect(uploader, &ImgurUploader::progressChange, this, &Uploader::progressChange);

	- QPair<QString, QString> screenshot;
	- screenshot.first = fileName;
	- screenshot.second = tr("Uploading...");
	+ connect(this , SIGNAL(cancelAll()), uploader, SLOT(cancel()));

	- mScreenshots.append(screenshot);
	+ mUploaders.append(uploader);
	}

	void Uploader::uploaded(const QString &file, const QString &url, const QString &deleteHash)
	{
	- // Removing the screenshot.
	- for (int i = 0; i < mScreenshots.size(); ++i) {
	- if (mScreenshots.at(i).first == file) {
	- mScreenshots.removeAt(i);
	- break;
	- }
	- }
	-
	mLastUrl = url;

	+ mUploaders.removeAll(qobject_cast<ImageUploader*>(sender()));
	sender()->deleteLater();
	emit done(file, url, deleteHash);
	}

	+void Uploader::uploaderError(ImageUploader::Error error, QString fileName)
	+{
	+ Q_UNUSED(error)
	+
	+ mUploaders.removeAll(qobject_cast<ImageUploader*>(sender()));
	+ sender()->deleteLater();
	+ emit done(fileName, "", "");
	+}
	+
	int Uploader::uploading()
	{
	- return mScreenshots.count();
	+ return mUploaders.count();
	}

	-void Uploader::reportProgress(qint64 sent, qint64 total)
	+void Uploader::progressChange(int p)
	{
	- mProgressSent = sent;
	- mProgressTotal = total;
	+ if (mUploaders.size() <= 0) {
	+ emit progress(p);
	+ return;
	+ }
	+
	+ int totalProgress = 0;

	- emit progress(sent, total);
	+ for (int i = 0; i < mUploaders.size(); ++i) {
	+ totalProgress += mUploaders[i]->progress();
	+ }
	+
	+ mProgress = totalProgress / mUploaders.size();
	+ emit progress(mProgress);
	}
	+
	diff --git a/tools/uploader/uploader.h b/tools/uploader/uploader.h
	index 9f97e92..5670ab6 100644
	--- a/tools/uploader/uploader.h
	+++ b/tools/uploader/uploader.h
	@@ -1,63 +1,60 @@
	/*
	* Copyright (C) 2014 Christian Kaiser
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#ifndef UPLOADER_H
	#define UPLOADER_H

	#include <QObject>
	-#include <QList>
	-#include <QPair>
	#include <QtNetwork>
	+#include "imageuploader.h"

	class Uploader : public QObject
	{
	Q_OBJECT

	public:
	Uploader(QObject *parent = 0);
	static Uploader* instance();
	QString lastUrl() const;
	- QList< QPair<QString, QString> > &screenshots() { return mScreenshots; }
	- qint64 progressSent() const { return mProgressSent; }
	- qint64 progressTotal() const { return mProgressTotal; }
	+ int progress() const;

	public slots:
	void cancel();
	//void error(const QString &file, const QtImgur::Error e);
	void upload(const QString &fileName);
	void uploaded(const QString &fileName, const QString &url, const QString &deleteHash);
	+ void uploaderError(ImageUploader::Error error, QString fileName);
	int uploading();
	- void reportProgress(qint64 sent, qint64 total);
	+ void progressChange(int p);

	signals:
	void done(QString, QString, QString);
	void error(QString);
	- void progress(qint64, qint64);
	+ void progress(int);
	+ void cancelAll();

	private:
	static Uploader* mInstance;
	-
	- QList< QPair<QString, QString> > mScreenshots;
	QNetworkAccessManager *mNetworkAccessManager;

	+ int mProgress;
	QString mLastUrl;
	- qint64 mProgressSent;
	- qint64 mProgressTotal;
	+ QList<ImageUploader*> mUploaders;
	};

	#endif // UPLOADER_H

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 15, 11:28 PM (2 w, 3 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70027
Default Alt Text: (68 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions