No OneTemporary
Actions

Authored By

Unknown

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/dialogs/areadialog.cpp b/dialogs/areadialog.cpp
	index f730ef1..9694557 100644
	--- a/dialogs/areadialog.cpp
	+++ b/dialogs/areadialog.cpp
	@@ -1,584 +1,584 @@
	/*
	* Copyright (C) 2012 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
	*
	******
	*
	* Based on KDE's KSnapshot regiongrabber.cpp, revision 796531, Copyright 2007 Luca Gugelmann <lucag@student.ethz.ch>
	* released under the GNU LGPL <http://www.gnu.org/licenses/old-licenses/library.txt>
	*
	*/
	#include "areadialog.h"
	#include "../tools/os.h"
	#include "../tools/screenshot.h"
	#include "../tools/screenshotmanager.h"

	#include <QApplication>
	#include <QDesktopWidget>
	#include <QHBoxLayout>
	#include <QMouseEvent>
	#include <QPainter>
	#include <QPushButton>
	#include <QSettings>
	#include <QTimer>
	#include <QToolTip>

	#include <QDebug>

	AreaDialog::AreaDialog(Screenshot *screenshot) :
	QDialog(0), mScreenshot(screenshot), mMouseDown(false), mMouseMagnifier(false),
	mNewSelection(false), mHandleSize(10), mMouseOverHandle(0), mIdleTimer(),
	mShowHelp(true), mGrabbing(false), mOverlayAlpha(1), mAutoclose(false),
	mTLHandle(0, 0, mHandleSize, mHandleSize), mTRHandle(0, 0, mHandleSize, mHandleSize),
	mBLHandle(0, 0, mHandleSize, mHandleSize), mBRHandle(0, 0, mHandleSize, mHandleSize),
	mLHandle(0, 0, mHandleSize, mHandleSize), mTHandle(0, 0, mHandleSize, mHandleSize),
	mRHandle(0, 0, mHandleSize, mHandleSize), mBHandle(0, 0, mHandleSize, mHandleSize)
	{
	mHandles << &mTLHandle << &mTRHandle << &mBLHandle << &mBRHandle
	<< &mLHandle << &mTHandle << &mRHandle << &mBHandle;

	mMouseOverHandle = 0;

	setMouseTracking(true);
	setWindowTitle(tr("Lightscreen Area Mode"));
	setWindowFlags(Qt::WindowStaysOnTopHint \| Qt::FramelessWindowHint \| Qt::X11BypassWindowManagerHint);

	setCursor(Qt::CrossCursor);

	connect(&mIdleTimer, SIGNAL(timeout()), this, SLOT(displayHelp()));
	mIdleTimer.start(2000);

	mAutoclose = ScreenshotManager::instance()->settings()->value("options/areaAutoclose").toBool();

	if (mAutoclose)
	return; // Avoid creating the accept widget if it's not going to get used.

	// Creating accept widget:
	mAcceptWidget = new QWidget(this);
	mAcceptWidget->resize(140, 70);
	mAcceptWidget->setWindowOpacity(0.4);
	mAcceptWidget->setStyleSheet("QWidget { background: rgba(255, 255, 255, 200); border: 4px solid #232323; padding: 0; } QPushButton { background: transparent; border: none; height: 50px; padding: 5px; } QPushButton:hover { cursor: hand; }");

	- QPushButton *awAcceptButton = new QPushButton(os::icon("yes.big"), "", this);
	+ QPushButton *awAcceptButton = new QPushButton(QIcon(":/icon/yes.big"), "", this);
	connect(awAcceptButton, SIGNAL(clicked()), this, SLOT(grabRect()));
	awAcceptButton->setCursor(Qt::PointingHandCursor);
	awAcceptButton->setIconSize(QSize(48, 48));

	- QPushButton *awRejectButton = new QPushButton(os::icon("no.big"), "", this);
	+ QPushButton *awRejectButton = new QPushButton(QIcon(":/icon/no.big"), "", this);
	connect(awRejectButton, SIGNAL(clicked()), this, SLOT(cancel()));
	awRejectButton->setCursor(Qt::PointingHandCursor);
	awRejectButton->setIconSize(QSize(48, 48));

	QHBoxLayout *awLayout = new QHBoxLayout(this);
	awLayout->addWidget(awAcceptButton);
	awLayout->addWidget(awRejectButton);
	awLayout->setMargin(0);
	awLayout->setSpacing(0);

	mAcceptWidget->setLayout(awLayout);
	mAcceptWidget->setVisible(false);
	}

	QRect &AreaDialog::resultRect()
	{
	return mSelection;
	}

	void AreaDialog::animationTick(int frame)
	{
	mOverlayAlpha = frame;
	update();
	}

	void AreaDialog::cancel()
	{
	reject();
	}

	void AreaDialog::displayHelp()
	{
	mShowHelp = true;
	update();
	}

	void AreaDialog::grabRect()
	{
	QRect r = mSelection.normalized();
	if (!r.isNull() && r.isValid()) {
	mGrabbing = true;
	accept();
	}
	}

	void AreaDialog::keyPressEvent(QKeyEvent* e)
	{
	if (e->key() == Qt::Key_Escape) {
	cancel();
	}
	else if (e->key() == Qt::Key_Enter \|\| e->key() == Qt::Key_Return) {
	grabRect();
	}
	else {
	e->ignore();
	}
	}

	void AreaDialog::mouseDoubleClickEvent(QMouseEvent*)
	{
	grabRect();
	}

	void AreaDialog::mouseMoveEvent(QMouseEvent* e)
	{
	mMouseMagnifier = false;

	if (mMouseDown) {

	mMousePos = e->pos();

	if (mNewSelection) {
	QRect r = rect();

	mSelection = QRect(mDragStartPoint, limitPointToRect(mMousePos, r)).normalized();
	}
	else if (mMouseOverHandle == 0) { // moving the whole selection
	QRect r = rect().normalized(), s = mSelectionBeforeDrag.normalized();
	QPoint p = s.topLeft() + e->pos() - mDragStartPoint;
	r.setBottomRight(r.bottomRight() - QPoint(s.width(), s.height()));

	if (!r.isNull() && r.isValid())
	mSelection.moveTo(limitPointToRect(p, r));
	}
	else {// dragging a handle
	QRect r = mSelectionBeforeDrag;
	QPoint offset = e->pos() - mDragStartPoint;

	if (mMouseOverHandle == &mTLHandle \|\| mMouseOverHandle == &mTHandle
	\|\| mMouseOverHandle == &mTRHandle) // dragging one of the top handles
	{
	r.setTop(r.top() + offset.y());
	}

	if (mMouseOverHandle == &mTLHandle \|\| mMouseOverHandle == &mLHandle
	\|\| mMouseOverHandle == &mBLHandle) // dragging one of the left handles
	{
	r.setLeft(r.left() + offset.x());
	}

	if (mMouseOverHandle == &mBLHandle \|\| mMouseOverHandle == &mBHandle
	\|\| mMouseOverHandle == &mBRHandle) // dragging one of the bottom handles
	{
	r.setBottom(r.bottom() + offset.y());
	}

	if (mMouseOverHandle == &mTRHandle \|\| mMouseOverHandle == &mRHandle
	\|\| mMouseOverHandle == &mBRHandle) // dragging one of the right handles
	{
	r.setRight(r.right() + offset.x());
	}

	r = r.normalized();
	r.setTopLeft(limitPointToRect(r.topLeft(), rect()));
	r.setBottomRight(limitPointToRect(r.bottomRight(), rect()));
	mSelection = r;
	}

	if (qApp->keyboardModifiers() & Qt::ControlModifier)
	{
	// The lazy 1:1 aspect ratio approach!
	mSelection.setHeight(mSelection.width());
	}

	if (mAcceptWidget) {
	QPoint acceptPos = e->pos();
	QRect acceptRect = QRect(acceptPos, QSize(120, 70));

	// Prevent the widget from overlapping the handles
	if (acceptRect.intersects(mTLHandle)) {
	acceptPos = mTLHandle.bottomRight() + QPoint(2, 2); // Corner case
	}

	if (acceptRect.intersects(mBRHandle)) {
	acceptPos = mBRHandle.bottomRight();
	}

	if (acceptRect.intersects(mBHandle)) {
	acceptPos = mBHandle.bottomRight();
	}

	if (acceptRect.intersects(mRHandle)) {
	acceptPos = mRHandle.topRight();
	}

	if (acceptRect.intersects(mTHandle)) {
	acceptPos = mTHandle.bottomRight();
	}

	if ((acceptPos.x()+120) > mScreenshot->pixmap().rect().width())
	acceptPos.setX(acceptPos.x()-120);

	if ((acceptPos.y()+70) > mScreenshot->pixmap().rect().height())
	acceptPos.setY(acceptPos.y()-70);

	mAcceptWidget->move(acceptPos);
	}

	update();
	}
	else
	{
	if (mSelection.isNull()) {
	mMouseMagnifier = true;
	update();
	return;
	}

	bool found = false;
	foreach(QRect* r, mHandles) {
	if (r->contains(e->pos())) {
	mMouseOverHandle = r;
	found = true;
	break;
	}
	}

	if (!found) {
	mMouseOverHandle = 0;
	if (mSelection.contains(e->pos()))
	setCursor(Qt::OpenHandCursor);
	else if (mAcceptWidget && QRect(mAcceptWidget->mapToParent(mAcceptWidget->pos()), QSize(100, 60)).contains(e->pos()))
	setCursor(Qt::PointingHandCursor);
	else
	setCursor(Qt::CrossCursor);
	}
	else {
	if (mMouseOverHandle == &mTLHandle \|\| mMouseOverHandle == &mBRHandle)
	setCursor(Qt::SizeFDiagCursor);
	if (mMouseOverHandle == &mTRHandle \|\| mMouseOverHandle == &mBLHandle)
	setCursor(Qt::SizeBDiagCursor);
	if (mMouseOverHandle == &mLHandle \|\| mMouseOverHandle == &mRHandle)
	setCursor(Qt::SizeHorCursor);
	if (mMouseOverHandle == &mTHandle \|\| mMouseOverHandle == &mBHandle)
	setCursor(Qt::SizeVerCursor);
	}
	}
	}

	void AreaDialog::mousePressEvent(QMouseEvent* e)
	{
	mShowHelp = false;
	mIdleTimer.stop();

	if (mAcceptWidget)
	mAcceptWidget->hide();

	if (e->button() == Qt::LeftButton) {
	mMouseDown = true;
	mDragStartPoint = e->pos();
	mSelectionBeforeDrag = mSelection;
	if (!mSelection.contains(e->pos())) {
	mNewSelection = true;
	mSelection = QRect();
	mShowHelp = true;
	setCursor(Qt::CrossCursor);
	}
	else {
	setCursor(Qt::ClosedHandCursor);
	}
	}
	else if (e->button() == Qt::RightButton
	\|\| e->button() == Qt::MidButton)
	{
	cancel();
	}

	update();
	}

	void AreaDialog::mouseReleaseEvent(QMouseEvent* e)
	{
	if (mAutoclose)
	grabRect();

	if (!mSelection.isNull() && mAcceptWidget)
	mAcceptWidget->show();

	mMouseDown = false;
	mNewSelection = false;
	mIdleTimer.start();

	if (mMouseOverHandle == 0 && mSelection.contains(e->pos()))
	setCursor(Qt::OpenHandCursor);

	update();
	}

	void AreaDialog::paintEvent(QPaintEvent* e)
	{
	Q_UNUSED(e);

	if (mGrabbing) // grabWindow() should just get the background
	return;

	QPainter painter(this);

	QPalette pal = palette();
	QFont font = QToolTip::font();

	QColor handleColor(85, 160, 188, 220);
	QColor overlayColor(0, 0, 0, mOverlayAlpha);
	QColor textColor = pal.color(QPalette::Active, QPalette::Text);
	QColor textBackgroundColor = pal.color(QPalette::Active, QPalette::Base);
	painter.drawPixmap(0, 0, mScreenshot->pixmap());
	painter.setFont(font);

	QRect r = mSelection.normalized().adjusted(0, 0, -1, -1);

	QRegion grey(rect());
	grey = grey.subtracted(r);
	painter.setPen(handleColor);
	painter.setBrush(overlayColor);
	painter.setClipRegion(grey);
	painter.drawRect(-1, -1, rect().width() + 1, rect().height() + 1);
	painter.setClipRect(rect());
	painter.setBrush(Qt::NoBrush);
	painter.drawRect(r);

	if (mShowHelp) {
	//Drawing the explanatory text.
	QRect helpRect = qApp->desktop()->screenGeometry(qApp->desktop()->primaryScreen());
	QString helpTxt = tr("Lightscreen area mode:\nUse your mouse to draw a rectangle to capture.\nPress any key or right click to exit.");

	helpRect.setHeight(qRound((float)(helpRect.height() / 10))); // We get a decently sized rect where the text should be drawn (centered)

	// We draw the white contrasting background for the text, using the same text and options to get the boundingRect that the text will have.
	painter.setPen(QPen(Qt::white));
	painter.setBrush(QBrush(QColor(255, 255, 255, 180), Qt::SolidPattern));
	QRectF bRect = painter.boundingRect(helpRect, Qt::AlignCenter, helpTxt);

	// These four calls provide padding for the rect
	bRect.setWidth(bRect.width() + 12);
	bRect.setHeight(bRect.height() + 10);
	bRect.setX(bRect.x() - 12);
	bRect.setY(bRect.y() - 10);

	painter.drawRoundedRect(bRect, 8, 8);

	// Draw the text:
	painter.setPen(QPen(Qt::black));
	painter.drawText(helpRect, Qt::AlignCenter, helpTxt);
	}

	if (!mSelection.isNull()) {
	// The grabbed region is everything which is covered by the drawn
	// rectangles (border included). This means that there is no 0px
	// selection, since a 0px wide rectangle will always be drawn as a line.
	QString txt = QString("%1x%2").arg(mSelection.width() == 0 ? 2 : mSelection.width())
	.arg(mSelection.height() == 0 ? 2 : mSelection.height());
	QRect textRect = painter.boundingRect(rect(), Qt::AlignLeft, txt);
	QRect boundingRect = textRect.adjusted(-4, 0, 0, 0);

	if (textRect.width() < r.width() - 2*mHandleSize &&
	textRect.height() < r.height() - 2*mHandleSize &&
	(r.width() > 100 && r.height() > 100)) // center, unsuitable for small selections
	{
	boundingRect.moveCenter(r.center());
	textRect.moveCenter(r.center());
	}
	else if (r.y() - 3 > textRect.height() &&
	r.x() + textRect.width() < rect().right()) // on top, left aligned
	{
	boundingRect.moveBottomLeft(QPoint(r.x(), r.y() - 3));
	textRect.moveBottomLeft(QPoint(r.x() + 2, r.y() - 3));
	}
	else if (r.x() - 3 > textRect.width()) // left, top aligned
	{
	boundingRect.moveTopRight(QPoint(r.x() - 3, r.y()));
	textRect.moveTopRight(QPoint(r.x() - 5, r.y()));
	}
	else if (r.bottom() + 3 + textRect.height() < rect().bottom() &&
	r.right() > textRect.width()) // at bottom, right aligned
	{
	boundingRect.moveTopRight(QPoint(r.right(), r.bottom() + 3));
	textRect.moveTopRight(QPoint(r.right() - 2, r.bottom() + 3));
	}
	else if (r.right() + textRect.width() + 3 < rect().width()) // right, bottom aligned
	{
	boundingRect.moveBottomLeft(QPoint(r.right() + 3, r.bottom()));
	textRect.moveBottomLeft(QPoint(r.right() + 5, r.bottom()));
	}
	// if the above didn't catch it, you are running on a very tiny screen...
	painter.setPen(textColor);
	painter.setBrush(textBackgroundColor);
	painter.drawRect(boundingRect);
	painter.drawText(textRect, txt);

	if ((r.height() > mHandleSize2 && r.width() > mHandleSize2)
	\|\| !mMouseDown)
	{
	updateHandles();
	painter.setPen(handleColor);
	handleColor.setAlpha(80);
	painter.setBrush(handleColor);
	painter.drawRects(handleMask().rects());
	}
	}

	if (!mScreenshot->options().magnify)
	return;

	// Drawing the magnified version
	QPoint magStart, magEnd, drawPosition;
	QRect newRect;

	QRect pixmapRect = mScreenshot->pixmap().rect();

	if (mMouseMagnifier) {
	drawPosition = QCursor::pos() - QPoint(100, 100);

	magStart = QCursor::pos() - QPoint(50, 50);
	magEnd = QCursor::pos() + QPoint(50, 50);

	newRect = QRect(magStart, magEnd);
	}
	else {
	// So pretty.. oh so pretty.
	if (mMouseOverHandle == &mTLHandle)
	magStart = mSelection.topLeft();
	else if (mMouseOverHandle == &mTRHandle)
	magStart = mSelection.topRight();
	else if (mMouseOverHandle == &mBLHandle)
	magStart = mSelection.bottomLeft();
	else if (mMouseOverHandle == &mBRHandle)
	magStart = mSelection.bottomRight();
	else if (mMouseOverHandle == &mLHandle)
	magStart = QPoint(mSelection.left(), mSelection.center().y());
	else if (mMouseOverHandle == &mTHandle)
	magStart = QPoint(mSelection.center().x(), mSelection.top());
	else if (mMouseOverHandle == &mRHandle)
	magStart = QPoint(mSelection.right(), mSelection.center().y());
	else if (mMouseOverHandle == &mBHandle)
	magStart = QPoint(mSelection.center().x(), mSelection.bottom());
	else if (mMouseOverHandle == 0)
	magStart = QCursor::pos();

	magEnd = magStart;
	drawPosition = mSelection.bottomRight();

	magStart -= QPoint(50, 50);
	magEnd += QPoint(50, 50);

	newRect = QRect(magStart, magEnd);

	if ((drawPosition.x()+newRect.width()*2) > pixmapRect.width())
	drawPosition.setX(drawPosition.x()-newRect.width()*2);

	if ((drawPosition.y()+newRect.height()*2) > pixmapRect.height())
	drawPosition.setY(drawPosition.y()-newRect.height()*2);

	if (drawPosition.y() == mSelection.bottomRight().y()-newRect.height()*2
	&& drawPosition.x() == mSelection.bottomRight().x()-newRect.width()*2)
	painter.setOpacity(0.7);
	}

	if (!pixmapRect.contains(newRect, true) \|\| drawPosition.x() <= 0 \|\| drawPosition.y() <= 0) {
	return;
	}

	QPixmap magnified = mScreenshot->pixmap().copy(newRect).scaled(QSize(newRect.width()2, newRect.height()2));

	QPainter magPainter(&magnified);
	magPainter.setPen(QPen(QBrush(QColor(35, 35, 35)), 2)); // Same border pen
	magPainter.drawRect(magnified.rect());

	if (!mMouseMagnifier) {
	magPainter.drawText(magnified.rect().center()-QPoint(4, -4), "+"); //Center minus the 4 pixels wide and across of the "+" -- TODO: Test alternative DPI settings.
	}

	painter.drawPixmap(drawPosition, magnified);
	}

	void AreaDialog::resizeEvent(QResizeEvent* e)
	{
	Q_UNUSED(e);

	if (mSelection.isNull())
	return;

	QRect r = mSelection;
	r.setTopLeft(limitPointToRect(r.topLeft(), rect()));
	r.setBottomRight(limitPointToRect(r.bottomRight(), rect()));

	if (r.width() <= 1 \|\| r.height() <= 1) //this just results in ugly drawing...
	r = QRect();

	mSelection = r;
	}

	void AreaDialog::showEvent(QShowEvent* e)
	{
	Q_UNUSED(e)

	QRect geometry = qApp->desktop()->geometry();

	if (mScreenshot->options().currentMonitor) {
	geometry = qApp->desktop()->screenGeometry(qApp->desktop()->screenNumber(QCursor::pos()));
	}

	resize(geometry.size());
	move(geometry.topLeft());

	if (mScreenshot->options().animations) {
	os::effect(this, SLOT(animationTick(int)), 85, 300);
	}
	else {
	animationTick(85);
	}

	setMouseTracking(true);
	}

	void AreaDialog::updateHandles()
	{
	QRect r = mSelection.normalized().adjusted(0, 0, -1, -1);
	int s2 = mHandleSize / 2;

	mTLHandle.moveTopLeft(r.topLeft());
	mTRHandle.moveTopRight(r.topRight());
	mBLHandle.moveBottomLeft(r.bottomLeft());
	mBRHandle.moveBottomRight(r.bottomRight());

	mLHandle.moveTopLeft(QPoint(r.x(), r.y() + r.height() / 2 - s2));
	mTHandle.moveTopLeft(QPoint(r.x() + r.width() / 2 - s2, r.y()));
	mRHandle.moveTopRight(QPoint(r.right(), r.y() + r.height() / 2 - s2));
	mBHandle.moveBottomLeft(QPoint(r.x() + r.width() / 2 - s2, r.bottom()));
	}

	QRegion AreaDialog::handleMask() const
	{
	// note: not normalized QRects are bad here, since they will not be drawn
	QRegion mask;
	foreach(QRect* rect, mHandles) mask += QRegion(*rect);
	return mask;
	}

	QPoint AreaDialog::limitPointToRect(const QPoint &p, const QRect &r) const
	{
	QPoint q;
	q.setX(p.x() < r.x() ? r.x() : p.x() < r.right() ? p.x() : r.right());
	q.setY(p.y() < r.y() ? r.y() : p.y() < r.bottom() ? p.y() : r.bottom());
	return q;
	}
	diff --git a/dialogs/previewdialog.cpp b/dialogs/previewdialog.cpp
	index b09b1c6..7eaed8c 100644
	--- a/dialogs/previewdialog.cpp
	+++ b/dialogs/previewdialog.cpp
	@@ -1,409 +1,409 @@
	/*
	* Copyright (C) 2012 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 <QDesktopWidget>
	#include <QGraphicsDropShadowEffect>
	#include <QHBoxLayout>
	#include <QIcon>
	#include <QLabel>
	#include <QList>
	#include <QMenu>
	#include <QObject>
	#include <QPalette>
	#include <QPushButton>
	#include <QSettings>
	#include <QStackedLayout>
	#include <QToolButton>
	#include <QDesktopServices>
	#include <QUrl>

	#include <QDebug>

	PreviewDialog::PreviewDialog(QWidget *parent) :
	QDialog(parent), mAutoclose(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);
	+ mPrevButton = new QPushButton(os::icon("arrow-left"), "", this);
	connect(mPrevButton, SIGNAL(clicked()), this, SLOT(previous()));

	- mNextButton = new QPushButton(os::icon(":/arrow-right"), "", this);
	+ 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);

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

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

	move(where);
	}

	//

	bool PreviewDialog::event(QEvent *event)
	{
	if ((event->type() == QEvent::Enter \|\| event->type() == QEvent::Leave)
	&& mStack->currentWidget())
	{
	foreach (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::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--;
	}
	}

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: 70026
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions