No OneTemporary
Actions

Authored By

Unknown

Size

24 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/tools/os.cpp b/tools/os.cpp
	index 8ffeec5..ef9f27b 100644
	--- a/tools/os.cpp
	+++ b/tools/os.cpp
	@@ -1,387 +1,385 @@
	/*
	* Copyright (C) 2017 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 <QBitmap>
	#include <QDesktopServices>
	#include <QDesktopWidget>
	#include <QDialog>
	#include <QDir>
	#include <QGraphicsDropShadowEffect>
	#include <QIcon>
	#include <QLibrary>
	#include <QLocale>
	#include <QMessageBox>
	#include <QPixmap>
	#include <QPointer>
	#include <QProcess>
	#include <QSettings>
	#include <QTextEdit>
	#include <QTimeLine>
	#include <QTimer>
	#include <QUrl>
	#include <QWidget>
	#include <string>
	#include <QMessageBox>
	#include <QPainter>
	#include <QPair>

	#ifdef Q_OS_WIN
	#include <QtWin>
	#include <qt_windows.h>
	- #include <shlobj.h>
	+ #include <ShlObj.h>

	// Define for MinGW
	#ifndef SM_CXPADDEDBORDER
	- #define SM_CXPADDEDBORDER 92
	+ #define SM_CXPADDEDBORDER 92
	#endif
	#elif defined(Q_OS_LINUX)
	#include <QX11Info>
	#include <X11/X.h>
	#include <X11/Xlib.h>
	#include <X11/Xutil.h>
	#include <X11/Xatom.h>
	#endif

	#include "os.h"

	QPair<QPixmap, QPoint> os::cursor()
	{
	#ifdef Q_OS_WIN
	/*
	* Taken from: git://github.com/arrai/mumble-record.git > src > mumble > Overlay.cpp
	* BSD License.
	*/

	QPixmap pixmap;
	QPoint hotspot;

	CURSORINFO cursorInfo;
	cursorInfo.cbSize = sizeof(cursorInfo);
	::GetCursorInfo(&cursorInfo);

	HICON cursor = cursorInfo.hCursor;

	ICONINFO iconInfo;
	::GetIconInfo(cursor, &iconInfo);

	ICONINFO info;
	ZeroMemory(&info, sizeof(info));

	if (::GetIconInfo(cursor, &info)) {
	if (info.hbmColor) {
	pixmap = QtWin::fromHBITMAP(info.hbmColor, QtWin::HBitmapAlpha);
	} else {
	QBitmap orig(QtWin::fromHBITMAP(info.hbmMask));
	QImage img = orig.toImage();

	int h = img.height() / 2;
	- int w = img.bytesPerLine() / sizeof(quint32);
	+ int w = static_cast<uint>(img.bytesPerLine()) / sizeof(quint32);

	QImage out(img.width(), h, QImage::Format_MonoLSB);
	QImage outmask(img.width(), h, QImage::Format_MonoLSB);

	for (int i = 0; i < h; ++i) {
	const quint32 srcimg = reinterpret_cast<const quint32 >(img.scanLine(i + h));
	const quint32 srcmask = reinterpret_cast<const quint32 >(img.scanLine(i));

	quint32 dstimg = reinterpret_cast<quint32 >(out.scanLine(i));
	quint32 dstmask = reinterpret_cast<quint32 >(outmask.scanLine(i));

	for (int j = 0; j < w; ++j) {
	dstmask[j] = srcmask[j];
	dstimg[j] = srcimg[j];
	}
	}

	pixmap = QBitmap::fromImage(out, Qt::ColorOnly);
	}

	- hotspot.setX(info.xHotspot);
	- hotspot.setY(info.yHotspot);
	+ hotspot.setX(static_cast<int>(info.xHotspot));
	+ hotspot.setY(static_cast<int>(info.yHotspot));

	if (info.hbmMask) {
	::DeleteObject(info.hbmMask);
	}

	if (info.hbmColor) {
	::DeleteObject(info.hbmColor);
	}

	::DeleteObject(cursor);
	}

	return QPair<QPixmap, QPoint>(pixmap, hotspot);
	#else
	- return QPixmap();
	+ return QPair<QPixmap, QPoint>(QPixmap(), QPoint());
	#endif
	}

	void os::effect(QObject target, const char slot, int frames, int duration, const char *cleanup)
	{
	QTimeLine *timeLine = new QTimeLine(duration);
	timeLine->setFrameRange(0, frames);

	timeLine->connect(timeLine, SIGNAL(frameChanged(int)), target, slot);

	if (cleanup != 0) {
	timeLine->connect(timeLine, SIGNAL(finished()), target, SLOT(cleanup()));
	}

	timeLine->connect(timeLine, SIGNAL(finished()), timeLine, SLOT(deleteLater()));


	timeLine->start();
	}

	QString os::getDocumentsPath()
	{
	#ifdef Q_OS_WIN
	TCHAR szPath[MAX_PATH];

	if (SUCCEEDED(SHGetFolderPath(NULL,
	CSIDL_PERSONAL \| CSIDL_FLAG_CREATE,
	NULL,
	0,
	szPath))) {
	- std::wstring path(szPath);
	-
	- return QString::fromWCharArray(path.c_str());
	+ return QString::fromWCharArray(szPath);
	}

	return QDir::homePath() + QDir::separator() + "My Documents";
	#else
	return QDir::homePath() + QDir::separator() + "Documents";
	#endif
	}

	QPixmap os::grabWindow(WId winId)
	{
	#ifdef Q_OS_WIN
	RECT rcWindow;

	HWND hwndId = (HWND)winId;

	GetWindowRect(hwndId, &rcWindow);

	int margin = GetSystemMetrics(SM_CXSIZEFRAME) + GetSystemMetrics(SM_CXPADDEDBORDER) / 2;

	rcWindow.right -= margin;
	rcWindow.left += margin;

	if (IsZoomed(hwndId)) {
	rcWindow.top += margin;
	} else {
	rcWindow.top += GetSystemMetrics(SM_CXPADDEDBORDER);
	}

	rcWindow.bottom -= margin;

	int width, height;
	width = rcWindow.right - rcWindow.left;
	height = rcWindow.bottom - rcWindow.top;

	RECT rcScreen;
	GetWindowRect(GetDesktopWindow(), &rcScreen);

	RECT rcResult;
	UnionRect(&rcResult, &rcWindow, &rcScreen);

	QPixmap pixmap;

	// Comparing the rects to determine if the window is outside the boundaries of the screen,
	// the window DC method has the disadvantage that it does not show Aero glass transparency,
	// so we'll avoid it for the screenshots that don't need it.

	HDC hdcMem;
	HBITMAP hbmCapture;

	if (EqualRect(&rcScreen, &rcResult)) {
	// Grabbing the window from the Screen DC.
	HDC hdcScreen = GetDC(NULL);

	BringWindowToTop(hwndId);

	hdcMem = CreateCompatibleDC(hdcScreen);
	hbmCapture = CreateCompatibleBitmap(hdcScreen, width, height);
	SelectObject(hdcMem, hbmCapture);

	BitBlt(hdcMem, 0, 0, width, height, hdcScreen, rcWindow.left, rcWindow.top, SRCCOPY);
	} else {
	// Grabbing the window by its own DC
	HDC hdcWindow = GetWindowDC(hwndId);

	hdcMem = CreateCompatibleDC(hdcWindow);
	hbmCapture = CreateCompatibleBitmap(hdcWindow, width, height);
	SelectObject(hdcMem, hbmCapture);

	BitBlt(hdcMem, 0, 0, width, height, hdcWindow, 0, 0, SRCCOPY);
	}

	ReleaseDC(hwndId, hdcMem);
	DeleteDC(hdcMem);

	pixmap = QtWin::fromHBITMAP(hbmCapture);

	DeleteObject(hbmCapture);

	return pixmap;
	#else
	return QPixmap::grabWindow(winId);
	#endif
	}

	void os::setForegroundWindow(QWidget *window)
	{
	#ifdef Q_OS_WIN
	ShowWindow((HWND)window->winId(), SW_RESTORE);
	SetForegroundWindow((HWND)window->winId());
	#else
	Q_UNUSED(window)
	#endif
	}

	void os::setStartup(bool startup, bool hide)
	{
	QString lightscreen = QDir::toNativeSeparators(qApp->applicationFilePath());

	if (hide) {
	lightscreen.append(" -h");
	}

	#ifdef Q_OS_WIN
	// Windows startup settings
	QSettings init("Microsoft", "Windows");
	init.beginGroup("CurrentVersion");
	init.beginGroup("Run");

	if (startup) {
	init.setValue("Lightscreen", lightscreen);
	} else {
	init.remove("Lightscreen");
	}

	init.endGroup();
	init.endGroup();
	#endif

	#if defined(Q_OS_LINUX)
	QFile desktopFile(QDir::homePath() + "/.config/autostart/lightscreen.desktop");

	desktopFile.remove();

	if (startup) {
	desktopFile.open(QIODevice::WriteOnly);
	desktopFile.write(QString("[Desktop Entry]\nExec=%1\nType=Application").arg(lightscreen).toLatin1());
	}
	#endif
	}

	QGraphicsEffect *os::shadow(const QColor &color, int blurRadius, int offset)
	{
	QGraphicsDropShadowEffect *shadowEffect = new QGraphicsDropShadowEffect;
	shadowEffect->setBlurRadius(blurRadius);
	shadowEffect->setOffset(offset);
	shadowEffect->setColor(color);

	return shadowEffect;
	}

	QIcon os::icon(const QString &name, QColor backgroundColor)
	{
	if (!backgroundColor.isValid()) {
	backgroundColor = qApp->palette().color(QPalette::Button);
	}

	if (backgroundColor.value() > 125) {
	return QIcon(":/icons/" + name);
	} else {
	return QIcon(":/icons/inv/" + name);
	}
	}

	#ifdef Q_OS_LINUX
	// Taken from KSnapshot. Oh KDE, what would I do without you :D
	Window os::findRealWindow(Window w, int depth)
	{
	if (depth > 5) {
	return None;
	}

	static Atom wm_state = XInternAtom(QX11Info::display(), "WM_STATE", False);
	Atom type;
	int format;
	unsigned long nitems, after;
	unsigned char *prop;

	if (XGetWindowProperty(QX11Info::display(), w, wm_state, 0, 0, False, AnyPropertyType,
	&type, &format, &nitems, &after, &prop) == Success) {
	if (prop != NULL) {
	XFree(prop);
	}

	if (type != None) {
	return w;
	}
	}

	Window root, parent;
	Window *children;
	unsigned int nchildren;
	Window ret = None;

	if (XQueryTree(QX11Info::display(), w, &root, &parent, &children, &nchildren) != 0) {
	for (unsigned int i = 0;
	i < nchildren && ret == None;
	++i) {
	ret = os::findRealWindow(children[ i ], depth + 1);
	}

	if (children != NULL) {
	XFree(children);
	}
	}

	return ret;
	}

	Window os::windowUnderCursor(bool includeDecorations)
	{
	Window root;
	Window child;
	uint mask;
	int rootX, rootY, winX, winY;

	XQueryPointer(QX11Info::display(), QX11Info::appRootWindow(), &root, &child,
	&rootX, &rootY, &winX, &winY, &mask);

	if (child == None) {
	child = QX11Info::appRootWindow();
	}

	if (!includeDecorations) {
	Window real_child = os::findRealWindow(child);

	if (real_child != None) { // test just in case
	child = real_child;
	}
	}

	return child;
	}
	#endif
	diff --git a/tools/screenshot.cpp b/tools/screenshot.cpp
	index 07cdfc9..23f6983 100644
	--- a/tools/screenshot.cpp
	+++ b/tools/screenshot.cpp
	@@ -1,491 +1,516 @@
	/*
	* Copyright (C) 2017 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 <QStringBuilder>

	#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()
	{
	if (mOptions.format == Screenshot::PNG) {
	mOptions.quality = 80;
	}
	}

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

	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.
	for (auto 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;
	}

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

	const 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::Failure;

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

	for (auto 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.urlClipboard)) {
	if (mUnloaded) {
	mUnloaded = false;
	mPixmap = QPixmap(mUnloadFilename);
	}

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

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

	if (mOptions.file) {
	fileName = name % extension();

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

	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(const 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, mOptions.uploadService);
	} else if (unloadPixmap()) {
	Uploader::instance()->upload(mUnloadFilename, mOptions.uploadService);
	} else {
	emit finished();
	}
	}

	void Screenshot::uploadDone(const QString &url)
	{
	if (mOptions.urlClipboard && !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
	}

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

	void Screenshot::grabDesktop()
	{
	QRect geometry;
	+ QPoint cursorPosition = QCursor::pos();

	if (mOptions.currentMonitor) {
	geometry = QApplication::primaryScreen()->geometry();
	} else {
	+ int top = 0;
	+
	for (QScreen *screen : QGuiApplication::screens()) {
	- geometry = geometry.united(screen->geometry());
	+ auto screenRect = screen->geometry();
	+
	+ if (screenRect.top() < 0) {
	+ top += screenRect.top() * -1;
	+ }
	+
	+ if (screenRect.left() < 0) {
	+ cursorPosition.setX(cursorPosition.x() + screenRect.width()); //= localCursorPos + screenRect.normalized().topLeft();
	+ }
	+
	+ geometry = geometry.united(screenRect);
	}
	+
	+ cursorPosition.setY(cursorPosition.y() + top);
	}

	mPixmap = QApplication::primaryScreen()->grabWindow(QApplication::desktop()->winId(), geometry.x(), geometry.y(), geometry.width(), geometry.height());
	mPixmap.setDevicePixelRatio(QApplication::desktop()->devicePixelRatio());

	if (mOptions.cursor && !mPixmap.isNull()) {
	QPainter painter(&mPixmap);
	auto cursorInfo = os::cursor();
	auto cursorPixmap = cursorInfo.first;
	- cursorPixmap.setDevicePixelRatio(QApplication::desktop()->devicePixelRatio());
	- painter.drawPixmap(QCursor::pos()-cursorInfo.second, cursorPixmap);
	+ cursorPixmap.setDevicePixelRatio(QApplication::desktop()->devicePixelRatio());
	+
	+#if 0 // Debug cursor position helper
	+ painter.setBrush(QBrush(Qt::darkRed));
	+ painter.setPen(QPen(QBrush(Qt::red), 5));
	+ QRectF rect;
	+ rect.setSize(QSizeF(100, 100));
	+ rect.moveCenter(cursorPosition);
	+ painter.drawRoundRect(rect, rect.size().height()2, rect.size().height()2);
	+#endif
	+
	+ painter.drawPixmap(cursorPosition-cursorInfo.second, cursorPixmap);
	}
	}

	const 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 = QString("%1/.screenshot.%2%3").arg(mOptions.directory.path()).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();
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, May 15, 7:18 PM (2 h, 13 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63957
Default Alt Text: (24 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions