No OneTemporary
Actions

Authored By

Unknown

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/dialogs/historydialog.cpp b/dialogs/historydialog.cpp
	index d5fead6..0581fe4 100644
	--- a/dialogs/historydialog.cpp
	+++ b/dialogs/historydialog.cpp
	@@ -1,286 +1,286 @@
	#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);
	}

	if (Uploader::instance()->progress() > 0) {
	ui->uploadProgressBar->setValue(Uploader::instance()->progress());
	}
	else {
	ui->uploadProgressWidget->setVisible(false);
	}

	ui->cancelUploadButton->setIcon(os::icon("no"));

	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->cancelUploadButton, SIGNAL(clicked()), Uploader::instance() , SLOT(cancel()));
	connect(ui->cancelUploadButton, SIGNAL(clicked()), ui->uploadProgressWidget, SLOT(hide()));

	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)
	+void HistoryDialog::open(const 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)
	+void HistoryDialog::selectionChanged(const QItemSelection &selected, const 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->uploadProgressWidget->setVisible(true);
	}

	void HistoryDialog::uploadProgress(int progress)
	{
	ui->uploadProgressWidget->setVisible(true);
	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() == "") {
	+ if (ui->filterEdit->text().isEmpty()) {
	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 ba6eb20..2321d69 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 open(const QModelIndex &index);
	+ void selectionChanged(const QItemSelection &selected, const QItemSelection &deselected);
	void upload();
	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/tools/screenshot.cpp b/tools/screenshot.cpp
	index 00fa9ac..1d64837 100644
	--- a/tools/screenshot.cpp
	+++ b/tools/screenshot.cpp
	@@ -1,503 +1,503 @@
	/*
	* 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 <QApplication>
	#include <QClipboard>
	#include <QDateTime>
	#include <QDesktopWidget>
	#include <QFileDialog>
	#include <QPainter>
	#include <QPixmap>
	#include <QProcess>
	#include <QTextStream>
	#include <QScreen>

	#include "windowpicker.h"
	#include "../dialogs/areadialog.h"
	#include "uploader/uploader.h"
	#include "screenshot.h"
	#include "screenshotmanager.h"

	#include "os.h"

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

	#ifdef Q_OS_LINUX
	#include <QX11Info>
	#include <X11/X.h>
	#include <X11/Xlib.h>
	#endif

	Screenshot::Screenshot(QObject *parent, Screenshot::Options options):
	QObject(parent),
	mOptions(options),
	mPixmapDelay(false),
	mUnloaded(false),
	mUnloadFilename()
	{
	// Here be crickets
	}

	Screenshot::~Screenshot()
	{
	if (!mUnloadFilename.isEmpty()) {
	QFile::remove(mUnloadFilename);
	}
	}

	-QString Screenshot::getName(NamingOptions options, QString prefix, QDir directory)
	+QString Screenshot::getName(const NamingOptions &options, const QString &prefix, const QDir &directory)
	{
	QString naming;
	int naming_largest = 0;

	if (options.flip) {
	naming = "%1" + prefix;
	}
	else {
	naming = prefix + "%1";
	}

	switch (options.naming)
	{
	case Screenshot::Numeric: // Numeric
	// Iterating through the folder to find the largest numeric naming.
	foreach(QString file, directory.entryList(QDir::Files))
	{
	if (file.contains(prefix)) {
	file.chop(file.size() - file.lastIndexOf("."));
	file.remove(prefix);

	if (file.toInt()> naming_largest) {
	naming_largest = file.toInt();
	}
	}
	}

	if (options.leadingZeros > 0) {
	//Pretty, huh?
	QString format;
	QTextStream (&format) << "%0" << (options.leadingZeros+1) << "d";

	naming = naming.arg(QString().sprintf(format.toLatin1(), naming_largest + 1));
	}
	else {
	naming = naming.arg(naming_largest + 1);
	}
	break;
	case Screenshot::Date: // Date
	naming = naming.arg(QLocale().toString(QDateTime::currentDateTime(), options.dateFormat));
	break;
	case Screenshot::Timestamp: // Timestamp
	naming = naming.arg(QDateTime::currentDateTime().toTime_t());
	break;
	case Screenshot::Empty:
	naming = naming.arg("");
	break;
	}

	return naming;
	}

	QString& Screenshot::unloadedFileName()
	{
	return mUnloadFilename;
	}

	Screenshot::Options &Screenshot::options()
	{
	return mOptions;
	}

	QPixmap &Screenshot::pixmap()
	{
	return mPixmap;
	}

	//

	void Screenshot::confirm(bool result)
	{
	if (result) {
	save();
	}
	else {
	mOptions.result = Screenshot::Cancel;
	emit finished();
	}

	emit cleanup();

	mPixmap = QPixmap();
	}

	void Screenshot::confirmation()
	{
	emit askConfirmation();

	if (mOptions.file) {
	unloadPixmap();
	}
	}

	void Screenshot::discard()
	{
	confirm(false);
	}

	void Screenshot::markUpload()
	{
	mOptions.upload = true;
	}

	void Screenshot::optimize()
	{
	QProcess* process = new QProcess(this);

	// Delete the QProcess once it's done.
	connect(process, SIGNAL(finished(int, QProcess::ExitStatus)), this , SLOT(optimizationDone()));
	connect(process, SIGNAL(finished(int, QProcess::ExitStatus)), process, SLOT(deleteLater()));

	QString optiPNG;

	#ifdef Q_OS_UNIX
	optiPNG = "optipng";
	#else
	optiPNG = qApp->applicationDirPath() + QDir::separator() + "optipng.exe";
	#endif

	if (!QFile::exists(optiPNG)) {
	emit optimizationDone();
	}

	process->start(optiPNG, QStringList() << mOptions.fileName);

	if (process->state() == QProcess::NotRunning) {
	emit optimizationDone();
	process->deleteLater();
	}
	}

	void Screenshot::optimizationDone()
	{
	if (mOptions.upload) {
	upload();
	}
	else {
	emit finished();
	}
	}

	void Screenshot::save()
	{
	QString name = "";
	QString fileName = "";
	Screenshot::Result result = Screenshot::Fail;

	if (mOptions.file && !mOptions.saveAs) {
	name = newFileName();
	}
	else if (mOptions.file && mOptions.saveAs) {
	name = QFileDialog::getSaveFileName(0, tr("Save as.."), newFileName(), "*" + extension());
	}

	if (!mOptions.replace && QFile::exists(name+extension())) {
	// Ugly? You should see my wife!
	int count = 0;
	int cunt = 0;

	QString naming = QFileInfo(name).fileName();

	foreach(QString file, QFileInfo(name+extension()).dir().entryList(QDir::Files)) {
	if (file.contains(naming)) {
	file.remove(naming);
	file.remove(" (");
	file.remove(")");
	file.remove(extension());

	cunt = file.toInt();

	if (cunt > count) {
	count = cunt;
	}
	}
	}

	name = name + " (" + QString::number(count+1) + ")";
	}

	if (mOptions.clipboard && !(mOptions.upload && mOptions.imgurClipboard)) {
	if (mUnloaded) {
	mUnloaded = false;
	mPixmap = QPixmap(mUnloadFilename);
	}

	QApplication::clipboard()->setPixmap(mPixmap, QClipboard::Clipboard);

	if (!mOptions.file) {
	result = (Screenshot::Result)1;
	}
	}

	// In the following code I use (Screenshot::Result)1 instead of Screenshot::Success because of some weird issue with the X11 headers. //TODO
	if (mOptions.file) {
	fileName = name + extension();

	if (name.isEmpty()) {
	result = Screenshot::Cancel;
	}
	else if (mUnloaded) {
	result = (QFile::rename(mUnloadFilename, fileName)) ? (Screenshot::Result)1: Screenshot::Fail;
	}
	else if (mPixmap.save(fileName, 0, mOptions.quality)) {
	result = (Screenshot::Result)1;
	}
	else {
	result = Screenshot::Fail;
	}
	}

	mOptions.fileName = fileName;
	mOptions.result = result;

	if (!mOptions.result)
	emit finished();

	if (mOptions.format == Screenshot::PNG && mOptions.optimize && mOptions.file) {
	if (!mOptions.upload) {
	ScreenshotManager::instance()->saveHistory(mOptions.fileName);
	}

	optimize();
	}
	else if (mOptions.upload) {
	upload();
	}
	else if (mOptions.file) {
	ScreenshotManager::instance()->saveHistory(mOptions.fileName);
	emit finished();
	}
	else {
	emit finished();
	}
	}

	void Screenshot::setPixmap(QPixmap pixmap)
	{
	mPixmap = pixmap;

	if (mPixmap.isNull()) {
	emit confirm(false);
	}
	else {
	confirmation();
	}
	}

	void Screenshot::take()
	{
	switch (mOptions.mode)
	{
	case Screenshot::WholeScreen:
	wholeScreen();
	break;

	case Screenshot::SelectedArea:
	selectedArea();
	break;

	case Screenshot::ActiveWindow:
	activeWindow();
	break;

	case Screenshot::SelectedWindow:
	selectedWindow();
	break;
	}

	if (mPixmapDelay)
	return;

	if (mPixmap.isNull()) {
	confirm(false);
	}
	else {
	confirmation();
	}
	}

	void Screenshot::upload()
	{
	if (mOptions.file) {
	Uploader::instance()->upload(mOptions.fileName);
	}
	else if (unloadPixmap()) {
	Uploader::instance()->upload(mUnloadFilename);
	}
	else {
	emit finished();
	}
	}

	void Screenshot::uploadDone(QString url)
	{
	if (mOptions.imgurClipboard && !url.isEmpty())
	QApplication::clipboard()->setText(url, QClipboard::Clipboard);

	emit finished();
	}

	//

	void Screenshot::activeWindow()
	{
	#ifdef Q_OS_WIN
	HWND fWindow = GetForegroundWindow();

	if (fWindow == NULL)
	return;

	if (fWindow == GetDesktopWindow()) {
	wholeScreen();
	return;
	}

	mPixmap = os::grabWindow((WId)GetForegroundWindow());
	#endif

	#if defined(Q_OS_LINUX)
	Window focus;
	int revert;

	XGetInputFocus(QX11Info::display(), &focus, &revert);

	mPixmap = QPixmap::grabWindow(focus);
	#endif
	}

	QString Screenshot::extension() const
	{
	switch (mOptions.format) {
	case Screenshot::PNG:
	return ".png";
	break;
	case Screenshot::BMP:
	return ".bmp";
	break;
	case Screenshot::JPEG:
	default:
	return ".jpg";
	break;
	}
	}

	void Screenshot::grabDesktop()
	{
	if (mOptions.currentMonitor) {
	/*
	* TODO
	QRect geometry;

	foreach (QScreen *screen, QGuiApplication::screens()) {
	geometry.setWidth(geometry.width() + screen->geometry().width());
	geometry.setHeight(geometry.height() + screen->geometry().height());
	}

	mPixmap = QApplication::primaryScreen()->grabWindow(QApplication::desktop()->winId());
	*/
	}
	else {
	mPixmap = QApplication::primaryScreen()->grabWindow(QApplication::desktop()->winId());
	}

	if (mOptions.cursor && !mPixmap.isNull()) {
	QPainter painter(&mPixmap);
	painter.drawPixmap(QCursor::pos(), os::cursor());
	}
	}

	QString Screenshot::newFileName() const
	{
	if (!mOptions.directory.exists()) {
	mOptions.directory.mkpath(mOptions.directory.path());
	}

	QString naming = Screenshot::getName(mOptions.namingOptions, mOptions.prefix, mOptions.directory);
	QString path = QDir::toNativeSeparators(mOptions.directory.path());

	// Cleanup
	if (path.at(path.size()-1) != QDir::separator() && !path.isEmpty()) {
	path.append(QDir::separator());
	}

	QString fileName;
	fileName.append(path);
	fileName.append(naming);

	return fileName;
	}

	void Screenshot::selectedArea()
	{
	grabDesktop();

	if (mPixmap.isNull())
	return;

	AreaDialog selector(this);
	int result = selector.exec();

	if (result == QDialog::Accepted) {
	mPixmap = mPixmap.copy(selector.resultRect());
	}
	else {
	mPixmap = QPixmap();
	}
	}

	void Screenshot::selectedWindow()
	{
	WindowPicker* windowPicker = new WindowPicker;
	mPixmapDelay = true;

	connect(windowPicker, SIGNAL(pixmap(QPixmap)), this, SLOT(setPixmap(QPixmap)));
	}

	bool Screenshot::unloadPixmap()
	{
	if (mUnloaded)
	return true;

	// Unloading the pixmap to reduce memory usage during previews
	mUnloadFilename = mOptions.directory.path() + QDir::separator() + QString(".lstemp.%1%2").arg(qrand() * qrand() + QDateTime::currentDateTime().toTime_t()).arg(extension());
	mUnloaded = mPixmap.save(mUnloadFilename, 0, mOptions.quality);

	if (mUnloaded) {
	mPixmap = QPixmap();
	}

	return mUnloaded;
	}

	void Screenshot::wholeScreen()
	{
	grabDesktop();
	}


	diff --git a/tools/screenshot.h b/tools/screenshot.h
	index 0f560bf..587be9b 100644
	--- a/tools/screenshot.h
	+++ b/tools/screenshot.h
	@@ -1,142 +1,142 @@
	/*
	* 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 SCREENSHOT_H
	#define SCREENSHOT_H

	#include <QObject>
	#include <QDir>
	#include <QPixmap>

	class Screenshot : public QObject
	{
	Q_OBJECT

	public:
	enum Format
	{
	PNG = 0,
	JPEG = 1,
	BMP = 2,
	TIFF = 3
	};

	enum Naming
	{
	Numeric = 0,
	Date = 1,
	Timestamp = 2,
	Empty = 3
	};

	enum Mode
	{
	WholeScreen = 0,
	ActiveWindow = 1,
	SelectedArea = 2,
	SelectedWindow = 3
	};

	enum Result
	{
	Fail = 0,
	Success = 1,
	Cancel = 2
	};

	struct NamingOptions
	{
	Naming naming;
	bool flip;
	int leadingZeros;
	QString dateFormat;
	};

	struct Options
	{
	QString fileName;
	Result result;

	Format format;
	NamingOptions namingOptions;
	QDir directory;
	QString prefix;

	int mode;
	int quality;

	bool animations;
	bool clipboard;
	bool imgurClipboard;
	bool currentMonitor;
	bool cursor;
	bool file;
	bool magnify;
	bool optimize;
	bool preview;
	bool replace;
	bool saveAs;
	bool upload;
	};

	Screenshot(QObject *parent, Screenshot::Options options);
	~Screenshot();

	Screenshot::Options &options();
	QPixmap &pixmap();
	- static QString getName(NamingOptions options, QString prefix, QDir directory);
	+ static QString getName(const NamingOptions &options, const QString &prefix, const QDir &directory);
	QString &unloadedFileName();

	public slots:
	void confirm(bool result = true);
	void confirmation();
	void discard();
	void markUpload();
	void optimize();
	void optimizationDone();
	void save();
	void setPixmap(QPixmap pixmap);
	void take();
	void upload();
	void uploadDone(QString url);

	signals:
	void askConfirmation();
	void cleanup();
	void finished();

	private:
	void activeWindow();
	QString extension() const;
	void grabDesktop();
	QString newFileName() const;
	void selectedArea();
	void selectedWindow();
	bool unloadPixmap();
	void wholeScreen();

	private:
	Screenshot::Options mOptions;
	QPixmap mPixmap;
	bool mPixmapDelay;
	bool mUnloaded;
	QString mUnloadFilename;

	};

	#endif // SCREENSHOT_H
	diff --git a/tools/uploader/imageuploader.cpp b/tools/uploader/imageuploader.cpp
	index acf097b..8f9cb22 100644
	--- a/tools/uploader/imageuploader.cpp
	+++ b/tools/uploader/imageuploader.cpp
	@@ -1,15 +1,10 @@
	-#include "imageuploader.h"
	+#include "imageuploader.h"
	#include "imguruploader.h"

	-ImageUploader::ImageUploader(QVariantHash &options) : mOptions(options)
	-{
	-
	-}
	-
	-ImageUploader* ImageUploader::getNewUploader(QString name, QVariantHash options)
	+ImageUploader* ImageUploader::getNewUploader(const QString &name, const QVariantHash &options)
	{
	if (name == "imgur")
	return new ImgurUploader(options);

	return 0;
	}
	diff --git a/tools/uploader/imageuploader.h b/tools/uploader/imageuploader.h
	index 42f0c0f..a01aed6 100644
	--- a/tools/uploader/imageuploader.h
	+++ b/tools/uploader/imageuploader.h
	@@ -1,45 +1,45 @@
	#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());
	+ static ImageUploader* getNewUploader(const QString &name, const QVariantHash &options = QVariantHash());

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

	public:
	- ImageUploader(QVariantHash &options);
	+ inline ImageUploader(const QVariantHash &options) : QObject(0), mProgress(0), mOptions(options) {}
	QVariantHash &options() { return mOptions; }

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

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

	protected:
	QVariantHash mOptions;
	int mProgress;

	};

	#endif // IMAGEUPLOADER_H
	diff --git a/tools/uploader/imguruploader.cpp b/tools/uploader/imguruploader.cpp
	index 8d37b25..04d6e85 100644
	--- a/tools/uploader/imguruploader.cpp
	+++ b/tools/uploader/imguruploader.cpp
	@@ -1,109 +1,109 @@
	#include "imguruploader.h"
	#include <QNetworkAccessManager>
	#include <QtNetwork>

	-ImgurUploader::ImgurUploader(QVariantHash &options) : ImageUploader(options) {}
	+ImgurUploader::ImgurUploader(const QVariantHash &options) : ImageUploader(options) {}

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

	if (!file->open(QIODevice::ReadOnly)) {
	emit error(ImageUploader::FileError, tr("Unable to read screenshot file"), fileName);
	file->deleteLater();
	return;
	}

	QNetworkRequest request(QUrl("https://api.imgur.com/3/image"));
	request.setRawHeader("Authorization", "Client-ID 3ebe94c791445c1");

	QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);

	if (!mOptions.value("anonymous", true).toBool())
	{
	request.setRawHeader("Authorization", QByteArray("Bearer ") + mOptions.value("access_token").toByteArray());

	if (!mOptions.value("album").toString().isEmpty())
	{
	QHttpPart albumPart;
	albumPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"album\""));
	albumPart.setBody(mOptions.value("album").toByteArray());
	multiPart->append(albumPart);
	}
	}

	QHttpPart imagePart;
	imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QMimeDatabase().mimeTypeForFile(fileName, QMimeDatabase::MatchExtension).name());
	imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image\""));

	imagePart.setBodyDevice(file);
	file->setParent(multiPart);
	multiPart->append(imagePart);

	QNetworkReply reply = mOptions.value("networkManager").value<QNetworkAccessManager>()->post(request, multiPart);
	reply->setProperty("fileName", fileName);
	this->setProperty("fileName", fileName);

	connect(reply, SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
	connect(this , SIGNAL(cancelRequest()), reply, SLOT(abort()));
	connect(this , SIGNAL(cancelRequest()), reply, SLOT(deleteLater()));
	connect(reply, SIGNAL(finished()), this, SLOT(finished()));
	}

	void ImgurUploader::retry()
	{
	upload(property("fileName").toString());
	}

	void ImgurUploader::cancel()
	{
	emit cancelRequest();
	}

	void ImgurUploader::finished()
	{
	QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
	reply->deleteLater();

	QString fileName = reply->property("fileName").toString();

	if (reply->error() != QNetworkReply::NoError) {
	if (reply->error() == QNetworkReply::OperationCanceledError) {
	emit error(ImageUploader::CancelError, "", fileName);
	}
	else if (reply->error() == QNetworkReply::ContentOperationNotPermittedError \|\|
	reply->error() == QNetworkReply::AuthenticationRequiredError) {
	emit needAuthRefresh();
	}
	else {
	emit error(ImageUploader::NetworkError, reply->errorString(), fileName);
	}

	return;
	}

	if (reply->rawHeader("X-RateLimit-Remaining") == "0") {
	emit error(ImageUploader::HostError, tr("Imgur upload limit reached"), fileName);
	return;
	}

	QJsonObject imgurResponse = QJsonDocument::fromJson(reply->readAll()).object();

	if (imgurResponse.value("success").toBool() == true && imgurResponse.value("status").toInt() == 200) {
	QJsonObject imageData = imgurResponse.value("data").toObject();

	emit uploaded(fileName, imageData["link"].toString(), imageData["deletehash"].toString());
	}
	else {
	emit error(ImageUploader::HostError, tr("Imgur error"), fileName);
	}
	}

	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 b2a459f..f88df61 100644
	--- a/tools/uploader/imguruploader.h
	+++ b/tools/uploader/imguruploader.h
	@@ -1,31 +1,31 @@
	#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(const QVariantHash &options);

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

	private slots:
	void finished();
	void uploadProgress(qint64 bytesReceived, qint64 bytesTotal);

	signals:
	void cancelRequest();
	void needAuthRefresh();

	};

	#endif // IMGURUPLOADER_H

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions