No OneTemporary
Actions

Authored By

Unknown

Size

58 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/dialogs/previewdialog.cpp b/dialogs/previewdialog.cpp
	index f2f3c6c..420d43e 100644
	--- a/dialogs/previewdialog.cpp
	+++ b/dialogs/previewdialog.cpp
	@@ -1,398 +1,436 @@
	/*
	* Copyright (C) 2016 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 "previewdialog.h"
	#include "../tools/screenshot.h"
	#include "../tools/screenshotmanager.h"
	#include "../tools/os.h"

	#include <QApplication>
	#include <QDesktopServices>
	#include <QDesktopWidget>
	+#include <QDrag>
	#include <QGraphicsDropShadowEffect>
	#include <QHBoxLayout>
	#include <QIcon>
	#include <QLabel>
	#include <QList>
	#include <QMenu>
	+#include <QMimeData>
	+#include <QMouseEvent>
	#include <QObject>
	#include <QPalette>
	#include <QPushButton>
	#include <QSettings>
	#include <QStackedLayout>
	#include <QToolButton>
	#include <QUrl>

	-
	PreviewDialog::PreviewDialog(QWidget *parent) :
	QDialog(parent), mAutoclose(0), mAutocloseAction(0), mAutocloseReset(0), mPosition(0), mSize(0)
	{
	setWindowFlags(Qt::Tool \| Qt::WindowStaysOnTopHint);
	setWindowTitle(tr("Screenshot Preview"));

	QSettings *settings = ScreenshotManager::instance()->settings();

	mSize = settings->value("options/previewSize", 300).toInt();
	mPosition = settings->value("options/previewPosition", 3).toInt();

	if (settings->value("options/previewAutoclose", false).toBool()) {
	mAutoclose = settings->value("options/previewAutocloseTime").toInt();
	mAutocloseReset = mAutoclose;
	mAutocloseAction = settings->value("options/previewAutocloseAction").toInt();
	}

	QHBoxLayout *l = new QHBoxLayout;
	mStack = new QStackedLayout;
	connect(mStack, SIGNAL(currentChanged(int)), this, SLOT(indexChanged(int)));

	mPrevButton = new QPushButton(os::icon("arrow-left"), "", this);
	connect(mPrevButton, SIGNAL(clicked()), this, SLOT(previous()));

	mNextButton = new QPushButton(os::icon("arrow-right"), "", this);
	connect(mNextButton, SIGNAL(clicked()), this, SLOT(next()));

	mPrevButton->setCursor(Qt::PointingHandCursor);
	mPrevButton->setFlat(true);
	mPrevButton->setGraphicsEffect(os::shadow(Qt::white));
	mPrevButton->setIconSize(QSize(24, 24));
	mPrevButton->setVisible(false);

	mNextButton->setCursor(Qt::PointingHandCursor);
	mNextButton->setFlat(true);
	mNextButton->setGraphicsEffect(os::shadow(Qt::white));
	mNextButton->setIconSize(QSize(24, 24));
	mNextButton->setVisible(false);

	l->addWidget(mPrevButton);
	l->addLayout(mStack);
	l->addWidget(mNextButton);

	l->setMargin(0);
	l->setContentsMargins(6, 6, 6, 6);

	mStack->setMargin(0);

	setMaximumHeight(mSize);
	setLayout(l);

	if (mAutoclose) {
	startTimer(1000);
	}
	}

	void PreviewDialog::add(Screenshot *screenshot)
	{
	if (!isVisible()) {
	show();
	}

	if (mAutoclose) {
	mAutoclose = mAutocloseReset;
	}

	QLabel *label = new QLabel(this);
	label->setGraphicsEffect(os::shadow());

	bool small = false;

	QSize size = screenshot->pixmap().size();

	if (size.width() > mSize \|\| size.height() > mSize) {
	size.scale(mSize, mSize, Qt::KeepAspectRatio);
	} else {
	small = true;
	}

	QPixmap thumbnail = screenshot->pixmap().scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);

	label->setPixmap(thumbnail);

	thumbnail = QPixmap();

	label->setAlignment(Qt::AlignCenter);

	if (size.height() < 120) {
	label->setMinimumHeight(120);
	}

	if (size.width() < 140) {
	label->setMinimumWidth(140);
	}

	label->resize(size);

	QPushButton *discardPushButton = new QPushButton(os::icon("no") , "", label);
	QPushButton *enlargePushButton = new QPushButton(os::icon("preview"), "", label);
	QToolButton *confirmPushButton = new QToolButton(label);

	confirmPushButton->setIconSize(QSize(24, 24));
	confirmPushButton->setCursor(Qt::PointingHandCursor);
	confirmPushButton->setGraphicsEffect(os::shadow(Qt::white));

	if (ScreenshotManager::instance()->settings()->value("options/previewDefaultAction", 0).toInt() == 0
	\|\| ScreenshotManager::instance()->settings()->value("options/uploadAuto").toBool()) {
	// Default button, confirm & upload.
	confirmPushButton->setIcon(os::icon("yes"));

	if (!ScreenshotManager::instance()->settings()->value("options/uploadAuto").toBool()) {
	QMenu *confirmMenu = new QMenu(confirmPushButton);
	confirmMenu->setObjectName("confirmMenu");

	QAction *uploadAction = new QAction(os::icon("imgur"), tr("Upload"), confirmPushButton);
	connect(uploadAction, SIGNAL(triggered()), screenshot, SLOT(markUpload()));
	connect(uploadAction, SIGNAL(triggered()), screenshot, SLOT(confirm()));
	connect(uploadAction, SIGNAL(triggered()), this, SLOT(closePreview()));
	connect(this, SIGNAL(uploadAll()), uploadAction, SLOT(trigger()));

	confirmMenu->addAction(uploadAction);
	confirmPushButton->setMenu(confirmMenu);
	confirmPushButton->setPopupMode(QToolButton::MenuButtonPopup);
	}

	connect(this, SIGNAL(acceptAll()), confirmPushButton, SLOT(click()));
	connect(confirmPushButton, SIGNAL(clicked()), screenshot, SLOT(confirm()));
	connect(confirmPushButton, SIGNAL(clicked()), this, SLOT(closePreview()));
	} else {
	// Reversed button, upload & confirm.
	confirmPushButton->setIcon(os::icon("imgur"));

	QMenu *confirmMenu = new QMenu(confirmPushButton);
	confirmMenu->setObjectName("confirmMenu");

	QAction *confirmAction = new QAction(os::icon("yes"), tr("Save"), confirmPushButton);
	connect(this, SIGNAL(acceptAll()), confirmAction, SLOT(trigger()));
	connect(confirmAction, SIGNAL(triggered()), screenshot, SLOT(confirm()));
	connect(confirmAction, SIGNAL(triggered()), this, SLOT(closePreview()));

	connect(confirmPushButton, SIGNAL(clicked()), screenshot, SLOT(markUpload()));
	connect(confirmPushButton, SIGNAL(clicked()), screenshot, SLOT(confirm()));
	connect(confirmPushButton, SIGNAL(clicked()), this, SLOT(closePreview()));
	connect(this, SIGNAL(uploadAll()), confirmPushButton, SLOT(click()));

	confirmMenu->addAction(confirmAction);
	confirmPushButton->setMenu(confirmMenu);
	confirmPushButton->setPopupMode(QToolButton::MenuButtonPopup);
	}

	confirmPushButton->setAutoRaise(true);
	confirmPushButton->setVisible(false);

	discardPushButton->setIconSize(QSize(24, 24));
	discardPushButton->setCursor(Qt::PointingHandCursor);
	discardPushButton->setGraphicsEffect(os::shadow(Qt::white));
	discardPushButton->setFlat(true);
	discardPushButton->setVisible(false);

	enlargePushButton->setIconSize(QSize(22, 22));
	enlargePushButton->setCursor(Qt::PointingHandCursor);
	enlargePushButton->setGraphicsEffect(os::shadow(Qt::white));
	enlargePushButton->setFlat(true);
	enlargePushButton->setVisible(false);

	enlargePushButton->setDisabled(small);

	connect(this, SIGNAL(rejectAll()), discardPushButton, SLOT(click()));

	connect(discardPushButton, SIGNAL(clicked()), screenshot, SLOT(discard()));
	connect(discardPushButton, SIGNAL(clicked()), this, SLOT(closePreview()));

	connect(enlargePushButton, SIGNAL(clicked()), this, SLOT(enlargePreview()));

	QHBoxLayout *wlayout = new QHBoxLayout;
	wlayout->addWidget(confirmPushButton);
	wlayout->addStretch();
	wlayout->addWidget(enlargePushButton);
	wlayout->addStretch();
	wlayout->addWidget(discardPushButton);
	wlayout->setMargin(0);

	QVBoxLayout *wl = new QVBoxLayout;
	wl->addStretch();
	wl->addLayout(wlayout);
	wl->setMargin(0);

	label->setLayout(wl);
	+ label->setProperty("screenshotObject", QVariant::fromValue<Screenshot *>(screenshot));

	mStack->addWidget(label);
	mStack->setCurrentIndex(mStack->count() - 1);

	mNextButton->setEnabled(false);

	if (mStack->count() >= 2 && !mNextButton->isVisible()) {
	mNextButton->setVisible(true);
	mPrevButton->setVisible(true);
	}

	relocate();
	}

	int PreviewDialog::count() const
	{
	return mStack->count();
	}

	//

	void PreviewDialog::closePreview()
	{
	QWidget *widget = mStack->currentWidget();
	mStack->removeWidget(widget);
	widget->deleteLater();

	if (mStack->count() == 0) {
	close();
	} else {
	relocate();
	}
	}

	void PreviewDialog::enlargePreview()
	{
	- Screenshot screenshot = qobject_cast<Screenshot >(ScreenshotManager::instance()->children().at(mStack->currentIndex()));
	+ Screenshot screenshot = mStack->currentWidget()->property("screenshotObject").value<Screenshot >();

	if (screenshot) {
	QFileInfo info(screenshot->unloadedFileName());
	QDesktopServices::openUrl(QUrl(info.absoluteFilePath()));
	}
	}

	void PreviewDialog::indexChanged(int i)
	{
	if (i == mStack->count() - 1) {
	mNextButton->setEnabled(false);
	mPrevButton->setEnabled(true);
	}

	if (i == 0 && mStack->count() > 1) {
	mNextButton->setEnabled(true);
	mPrevButton->setEnabled(false);
	}

	if (i != 0 && i != mStack->count() - 1) {
	mNextButton->setEnabled(true);
	mPrevButton->setEnabled(true);
	}

	if (mStack->count() < 2) {
	mNextButton->setEnabled(false);
	mPrevButton->setEnabled(false);
	}

	if (mStack->widget(i)) {
	mStack->widget(i)->setFocus();
	}

	if (mStack->count() > 1) {
	setWindowTitle(tr("Screenshot Preview (%1 of %2)").arg(mStack->currentIndex() + 1).arg(mStack->count()));
	} else {
	setWindowTitle(tr("Screenshot Preview"));
	}
	}

	void PreviewDialog::next()
	{
	mStack->setCurrentIndex(mStack->currentIndex() + 1);
	relocate();
	}

	void PreviewDialog::previous()
	{
	mStack->setCurrentIndex(mStack->currentIndex() - 1);
	relocate();
	}


	void PreviewDialog::relocate()
	{
	updateGeometry();
	resize(minimumSizeHint());
	QApplication::sendEvent(this, new QEvent(QEvent::Enter)); // Ensures the buttons are visible.

	QPoint where;
	switch (mPosition) {
	- case 0:
	- where = QApplication::desktop()->availableGeometry(this).topLeft();
	- break;
	- case 1:
	- where = QApplication::desktop()->availableGeometry(this).topRight();
	- where.setX(where.x() - frameGeometry().width());
	- break;
	- case 2:
	- where = QApplication::desktop()->availableGeometry(this).bottomLeft();
	- where.setY(where.y() - frameGeometry().height());
	- break;
	- case 3:
	- default:
	- where = QApplication::desktop()->availableGeometry(this).bottomRight();
	- where.setX(where.x() - frameGeometry().width());
	- where.setY(where.y() - frameGeometry().height());
	- break;
	+ case 0:
	+ where = QApplication::desktop()->availableGeometry(this).topLeft();
	+ break;
	+ case 1:
	+ where = QApplication::desktop()->availableGeometry(this).topRight();
	+ where.setX(where.x() - frameGeometry().width());
	+ break;
	+ case 2:
	+ where = QApplication::desktop()->availableGeometry(this).bottomLeft();
	+ where.setY(where.y() - frameGeometry().height());
	+ break;
	+ case 3:
	+ default:
	+ where = QApplication::desktop()->availableGeometry(this).bottomRight();
	+ where.setX(where.x() - frameGeometry().width());
	+ where.setY(where.y() - frameGeometry().height());
	+ break;
	}

	move(where);
	}

	//

	bool PreviewDialog::event(QEvent *event)
	{
	if ((event->type() == QEvent::Enter \|\| event->type() == QEvent::Leave)
	&& mStack->currentWidget()) {
	for (QObject *child : mStack->currentWidget()->children()) {
	QWidget widget = qobject_cast<QWidget >(child);

	if (widget) {
	// Lets avoid disappearing buttons and bail if the menu is open.
	QMenu confirmMenu = widget->findChild<QMenu >("confirmMenu");
	if (confirmMenu && confirmMenu->isVisible()) {
	return false;
	}

	widget->setVisible((event->type() == QEvent::Enter));
	}
	}
	} else if (event->type() == QEvent::Close) {
	if (mStack->count() != 0) {
	emit rejectAll();
	}

	deleteLater();
	- } else if (event->type() == QEvent::MouseButtonDblClick) {
	- enlargePreview();
	}

	return QDialog::event(event);
	}

	+void PreviewDialog::mouseDoubleClickEvent(QMouseEvent *event)
	+{
	+ Q_UNUSED(event);
	+ enlargePreview();
	+}
	+
	+void PreviewDialog::mousePressEvent(QMouseEvent *event)
	+{
	+ if (!(event->buttons() & Qt::LeftButton))
	+ return;
	+
	+ if ((event->pos() - mDragStartPosition).manhattanLength()
	+ < QApplication::startDragDistance())
	+ return;
	+
	+ Screenshot screenshot = mStack->currentWidget()->property("screenshotObject").value<Screenshot >();
	+
	+ if (screenshot) {
	+ QFileInfo info(screenshot->unloadedFileName());
	+
	+ QDrag *drag = new QDrag(this);
	+ QMimeData *mimeData = new QMimeData;
	+
	+ mimeData->setUrls(QList<QUrl>() << QUrl::fromLocalFile(info.absoluteFilePath()));
	+ drag->setMimeData(mimeData);
	+
	+ drag->exec(Qt::CopyAction);
	+ }
	+}
	+
	+void PreviewDialog::mouseMoveEvent(QMouseEvent *event)
	+{
	+ if (event->button() == Qt::LeftButton) {
	+ mDragStartPosition = event->pos();
	+ }
	+}
	+
	void PreviewDialog::timerEvent(QTimerEvent *event)
	{
	if (mAutoclose == 0) {
	if (mAutocloseAction == 0) {
	emit acceptAll();
	} else if (mAutocloseAction == 1) {
	emit uploadAll();
	} else {
	emit rejectAll();
	}
	} else if (mAutoclose < 0) {
	killTimer(event->timerId());
	} else {
	setWindowTitle(tr("Preview: Closing in %1").arg(mAutoclose));
	mAutoclose--;
	}
	}
	diff --git a/dialogs/previewdialog.h b/dialogs/previewdialog.h
	index a9765f4..547df93 100644
	--- a/dialogs/previewdialog.h
	+++ b/dialogs/previewdialog.h
	@@ -1,69 +1,73 @@
	/*
	* Copyright (C) 2016 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 PREVIEWDIALOG_H
	#define PREVIEWDIALOG_H

	#include <QDialog>

	class Screenshot;
	class QStackedLayout;
	class QPushButton;
	class PreviewDialog : public QDialog
	{
	Q_OBJECT

	public:
	PreviewDialog(QWidget *parent);

	void add(Screenshot *screenshot);
	int count() const;

	public slots:
	void setWidth(int w) { resize(w, height()); }
	void setHeight(int h) { resize(width(), h); }

	signals:
	void acceptAll();
	void rejectAll();
	void uploadAll();

	private slots:
	void closePreview();
	void enlargePreview();
	void indexChanged(int i);
	void next();
	void previous();
	void relocate();

	protected:
	bool event(QEvent *event);
	+ void mouseDoubleClickEvent(QMouseEvent *event);
	+ void mousePressEvent(QMouseEvent *event);
	+ void mouseMoveEvent(QMouseEvent *event);
	void timerEvent(QTimerEvent *event);

	private:
	int mAutoclose;
	int mAutocloseAction;
	int mAutocloseReset;
	int mPosition; //0: top left, 1: top right, 2: bottom left, 3: bottom rigth (default)
	int mSize;
	QPushButton *mNextButton;
	QPushButton *mPrevButton;
	QStackedLayout *mStack;
	+ QPoint mDragStartPosition;
	};

	#endif // PREVIEWDIALOG_H
	diff --git a/lightscreenwindow.cpp b/lightscreenwindow.cpp
	index 1530d19..3cf524a 100644
	--- a/lightscreenwindow.cpp
	+++ b/lightscreenwindow.cpp
	@@ -1,1038 +1,1035 @@
	/*
	* Copyright (C) 2016 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>
	#include <QKeyEvent>

	#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/os.h"
	#include "tools/screenshot.h"
	#include "tools/screenshotmanager.h"
	#include "tools/UGlobalHotkey/uglobalhotkeys.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(),
	mHasTaskbarButton(false)
	{
	ui.setupUi(this);

	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"));

	createUploadMenu();

	#ifdef Q_OS_WIN
	if (QSysInfo::WindowsVersion >= QSysInfo::WV_WINDOWS7) {
	mTaskbarButton = new QWinTaskbarButton(this);
	mHasTaskbarButton = true;

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

	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

	- setMaximumSize(size());
	setMinimumSize(size());
	-
	setWindowFlags(windowFlags() ^ Qt::WindowMaximizeButtonHint);

	// 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()));

	// Shortcuts
	mGlobalHotkeys = new UGlobalHotkeys(this);

	connect(mGlobalHotkeys, &UGlobalHotkeys::activated, [&](size_t id) {
	if (id <= 3) {
	screenshotAction(id);
	} else if (id == 4) {
	show();
	} else if (id == 5) {
	goToFolder();
	} else {
	qWarning() << "Unknown hotkey ID: " << id;
	}
	});

	// Uploader
	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 &)));
	connect(ScreenshotManager::instance(), SIGNAL(activeCountChange()), this, SLOT(updateStatus()));

	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())); // TODO: Benchmark me
	QTimer::singleShot(5000, this, SLOT(checkForUpdates()));
	}
	}

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

	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_OS_LINUX // 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
	}

	}

	updateStatus();

	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);
	}

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

	// We might want to go to the folder without it having been created by taking a screenshot yet.
	if (!path.exists()) {
	path.mkpath(path.absolutePath());
	}

	QDesktopServices::openUrl(QUrl::fromLocalFile(path.absolutePath() + QDir::separator()));
	#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::executeArgument(const QString &message)
	{
	if (message == "--wake") {
	show();
	os::setForegroundWindow(this);
	qApp->alert(this, 2000);
	} else 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();
	} else if (message == "--options") {
	showOptions();
	} else if (message == "--quit") {
	qApp->quit();
	}
	}

	void LightscreenWindow::executeArguments(const QStringList &arguments)
	{
	// If we just have the default argument, call "--wake"
	if (arguments.count() == 1 && (arguments.at(0) == qApp->arguments().at(0) \|\| arguments.at(0).contains(QFileInfo(qApp->applicationFilePath()).fileName()))) {
	executeArgument("--wake");
	return;
	}

	for (auto argument : arguments) {
	executeArgument(argument);
	}
	}

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

	if (mHasTaskbarButton) {
	mTaskbarButton->setOverlayIcon(os::icon("yes"));
	}

	setWindowTitle(tr("Success!"));
	break;
	case Screenshot::Fail:
	mTrayIcon->setIcon(QIcon(":/icons/lightscreen.no"));
	setWindowTitle(tr("Failed!"));

	if (mHasTaskbarButton) {
	mTaskbarButton->setOverlayIcon(os::icon("no"));
	}

	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"));
	}

	if (mHasTaskbarButton) {
	mTaskbarButton->clearOverlayIcon();
	mTaskbarButton->progress()->setVisible(false);
	mTaskbarButton->progress()->stop();
	mTaskbarButton->progress()->reset();
	}

	updateStatus();
	}

	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_OS_LINUX // 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::screenHotkey()
	{
	screenshotAction(0);
	}

	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>";

	for (auto 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) {
	for (auto hotkey : hotkeys) {
	settings()->setValue(QString("actions/%1/enabled").arg(hotkey), false);
	}
	}
	}

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

	updateStatus();
	}

	void LightscreenWindow::showOptions()
	{
	mGlobalHotkeys->unregisterAllHotkeys();
	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;
	updateStatus();

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

	notify(Screenshot::Fail);
	}

	void LightscreenWindow::showUploaderMessage(const QString &fileName, const 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));
	}

	updateStatus();
	}

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

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

	void LightscreenWindow::updateStatus()
	{
	int uploadCount = Uploader::instance()->uploading();
	int activeCount = ScreenshotManager::instance()->activeCount();

	if (mHasTaskbarButton) {
	mTaskbarButton->progress()->setPaused(true);
	mTaskbarButton->progress()->setVisible(true);
	}

	if (uploadCount > 0) {
	setStatus(tr("%1 uploading").arg(uploadCount));

	if (mHasTaskbarButton) {
	mTaskbarButton->progress()->setRange(0, 100);
	mTaskbarButton->progress()->resume();
	}

	emit uploading(true);
	} else {
	if (activeCount > 1) {
	setStatus(tr("%1 processing").arg(activeCount));
	} else if (activeCount == 1) {
	setStatus(tr("processing"));
	} else {
	setStatus();

	if (mHasTaskbarButton) {
	mTaskbarButton->progress()->setVisible(false);
	}
	}

	emit uploading(false);
	}
	}

	void LightscreenWindow::updaterDone(bool result)
	{
	mUpdater->deleteLater();

	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("https://lightscreen.com.ar/whatsnew?from=" + qApp->applicationVersion()));
	} else if (msgBox.clickedButton() == turnOffButton) {
	settings()->setValue("options/disableUpdater", true);
	}
	}

	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();
	updateStatus();
	}
	}

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

	void LightscreenWindow::uploadProgress(int progress)
	{
	if (mHasTaskbarButton) {
	mTaskbarButton->progress()->setVisible(true);
	mTaskbarButton->progress()->setValue(progress);
	}

	if (isVisible() && progress > 0) {
	int uploadCount = Uploader::instance()->uploading();

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

	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", true).toBool();

	if (tray && !mTrayIcon) {
	createTrayIcon();
	mTrayIcon->setVisible(true);
	} else if (!tray && mTrayIcon) {
	mTrayIcon->setVisible(false);
	}

	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()
	{
	const QStringList actions = {"screen", "window", "area", "windowPicker", "open", "directory"};
	QStringList failed;
	size_t i = 0;

	for (auto action : actions) {
	if (settings()->value("actions/" + action + "/enabled").toBool()) {
	if (!mGlobalHotkeys->registerHotkey(settings()->value("actions/" + action + "/hotkey").toString(), i)) {
	failed << action;
	}
	}

	i++;
	}

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

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

	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);
	}

	void LightscreenWindow::setStatus(QString status)
	{
	if (status.isEmpty()) {
	status = tr("Lightscreen");
	} else {
	status += tr(" - Lightscreen");
	}

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

	setWindowTitle(status);
	}

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

	// Event handling
	bool LightscreenWindow::event(QEvent *event)
	{
	if (event->type() == QEvent::Show) {
	QPoint savedPosition = settings()->value("position").toPoint();

	if (!savedPosition.isNull() && qApp->desktop()->availableGeometry().contains(QRect(savedPosition, size()))) {
	move(savedPosition);
	}

	if (mHasTaskbarButton) {
	mTaskbarButton->setWindow(windowHandle());
	}
	} else 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::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.ui b/lightscreenwindow.ui
	index 40bab8a..57beeba 100644
	--- a/lightscreenwindow.ui
	+++ b/lightscreenwindow.ui
	@@ -1,201 +1,234 @@
	<?xml version="1.0" encoding="UTF-8"?>
	<ui version="4.0">
	<class>LightscreenWindowClass</class>
	<widget class="QMainWindow" name="LightscreenWindowClass">
	<property name="geometry">
	<rect>
	<x>0</x>
	<y>0</y>
	- <width>262</width>
	- <height>115</height>
	+ <width>260</width>
	+ <height>104</height>
	</rect>
	</property>
	<property name="sizePolicy">
	<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
	<horstretch>0</horstretch>
	<verstretch>0</verstretch>
	</sizepolicy>
	</property>
	+ <property name="minimumSize">
	+ <size>
	+ <width>260</width>
	+ <height>0</height>
	+ </size>
	+ </property>
	<property name="windowTitle">
	<string>Lightscreen</string>
	</property>
	<property name="windowIcon">
	<iconset resource="lightscreen.qrc">
	<normaloff>:/icons/lightscreen</normaloff>:/icons/lightscreen</iconset>
	</property>
	<property name="animated">
	<bool>false</bool>
	</property>
	<property name="unifiedTitleAndToolBarOnMac">
	<bool>true</bool>
	</property>
	<widget class="QWidget" name="centralWidget">
	<layout class="QGridLayout" name="gridLayout">
	- <property name="margin">
	+ <property name="leftMargin">
	+ <number>3</number>
	+ </property>
	+ <property name="topMargin">
	+ <number>3</number>
	+ </property>
	+ <property name="rightMargin">
	+ <number>3</number>
	+ </property>
	+ <property name="bottomMargin">
	<number>3</number>
	</property>
	<property name="spacing">
	<number>2</number>
	</property>
	<item row="0" column="1">
	<widget class="QPushButton" name="areaPushButton">
	+ <property name="sizePolicy">
	+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
	+ <horstretch>0</horstretch>
	+ <verstretch>0</verstretch>
	+ </sizepolicy>
	+ </property>
	<property name="minimumSize">
	<size>
	- <width>24</width>
	- <height>24</height>
	+ <width>70</width>
	+ <height>70</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Area capture</string>
	</property>
	<property name="whatsThis">
	<string>Capture a specific area of your desktop, resize and move it around!</string>
	</property>
	<property name="text">
	<string/>
	</property>
	<property name="iconSize">
	<size>
	<width>64</width>
	<height>64</height>
	</size>
	</property>
	<property name="shortcut">
	<string>Ctrl+A</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item row="0" column="2">
	<widget class="QPushButton" name="windowPushButton">
	+ <property name="sizePolicy">
	+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
	+ <horstretch>0</horstretch>
	+ <verstretch>0</verstretch>
	+ </sizepolicy>
	+ </property>
	<property name="minimumSize">
	<size>
	- <width>24</width>
	- <height>24</height>
	+ <width>70</width>
	+ <height>70</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Pick window</string>
	</property>
	<property name="whatsThis">
	<string>Drop the picker onto a window to capture it.</string>
	</property>
	<property name="iconSize">
	<size>
	<width>64</width>
	<height>64</height>
	</size>
	</property>
	<property name="shortcut">
	<string>Ctrl+P</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item row="1" column="0">
	<widget class="QPushButton" name="optionsPushButton">
	<property name="minimumSize">
	<size>
	<width>0</width>
	<height>26</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Configure Lightscreen</string>
	</property>
	<property name="text">
	<string>&Options</string>
	</property>
	<property name="shortcut">
	<string>Ctrl+O</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="QPushButton" name="folderPushButton">
	<property name="minimumSize">
	<size>
	<width>0</width>
	<height>26</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Open the current Screenshot folder</string>
	</property>
	<property name="text">
	<string>&Folder</string>
	</property>
	<property name="shortcut">
	<string>Ctrl+F</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item row="1" column="2">
	<widget class="QPushButton" name="imgurPushButton">
	<property name="minimumSize">
	<size>
	<width>0</width>
	<height>26</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Imgur upload controls</string>
	</property>
	<property name="text">
	<string>&Upload</string>
	</property>
	<property name="shortcut">
	<string>Ctrl+U</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item row="0" column="0">
	<widget class="QPushButton" name="screenPushButton">
	+ <property name="sizePolicy">
	+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
	+ <horstretch>0</horstretch>
	+ <verstretch>0</verstretch>
	+ </sizepolicy>
	+ </property>
	<property name="minimumSize">
	<size>
	- <width>24</width>
	- <height>24</height>
	+ <width>70</width>
	+ <height>70</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Fullscreen capture</string>
	</property>
	<property name="whatsThis">
	<string>Take a screenshot of your entire desktop.</string>
	</property>
	<property name="iconSize">
	<size>
	<width>64</width>
	<height>64</height>
	</size>
	</property>
	<property name="shortcut">
	<string>Ctrl+S</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	</layout>
	</widget>
	</widget>
	<layoutdefault spacing="6" margin="11"/>
	<resources>
	<include location="lightscreen.qrc"/>
	</resources>
	<connections/>
	</ui>

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 2:22 AM (2 w, 13 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70871
Default Alt Text: (58 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions