diff --git a/src/ExportManager.cpp b/src/ExportManager.cpp
index 3e0316e..dccaec9 100644
--- a/src/ExportManager.cpp
+++ b/src/ExportManager.cpp
@@ -1,514 +1,515 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "ExportManager.h"
 
 #include <QDir>
 #include <QMimeDatabase>
 #include <QImageWriter>
 #include <QTemporaryDir>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QClipboard>
 #include <QPainter>
 #include <QFileDialog>
 #include <QBuffer>
 #include <QRegularExpression>
 #include <QRegularExpressionMatch>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KIO/ListJob>
 #include <KIO/MkpathJob>
 #include <KIO/FileCopyJob>
 #include <KIO/StatJob>
 
 #include "SpectacleConfig.h"
 
 ExportManager::ExportManager(QObject *parent) :
     QObject(parent),
     mSavePixmap(QPixmap()),
     mTempFile(QUrl()),
     mTempDir(nullptr)
 {
     connect(this, &ExportManager::imageSaved, [this](const QUrl &savedAt) {
         SpectacleConfig::instance()->setLastSaveFile(savedAt);
     });
 }
 
 ExportManager::~ExportManager()
 {
     delete mTempDir;
 }
 
 ExportManager* ExportManager::instance()
 {
     static ExportManager instance;
     return &instance;
 }
 
 // screenshot pixmap setter and getter
 
 QPixmap ExportManager::pixmap() const
 {
     return mSavePixmap;
 }
 
 void ExportManager::setWindowTitle(const QString &windowTitle)
 {
     mWindowTitle = windowTitle;
 }
 
 QString ExportManager::windowTitle() const
 {
     return mWindowTitle;
 }
 
 ImageGrabber::GrabMode ExportManager::grabMode() const
 {
     return mGrabMode;
 }
 
 void ExportManager::setGrabMode(const ImageGrabber::GrabMode &grabMode)
 {
     mGrabMode = grabMode;
 }
 
 void ExportManager::setPixmap(const QPixmap &pixmap)
 {
     mSavePixmap = pixmap;
 
     // reset our saved tempfile
     if (mTempFile.isValid()) {
         mUsedTempFileNames.append(mTempFile);
         QFile file(mTempFile.toLocalFile());
         file.remove();
         mTempFile = QUrl();
     }
 }
 
 void ExportManager::updatePixmapTimestamp()
 {
 	mPixmapTimestamp = QDateTime::currentDateTime();
 }
 
 // native file save helpers
 
 QString ExportManager::defaultSaveLocation() const
 {
     QString savePath = SpectacleConfig::instance()->defaultSaveLocation();
     if (savePath.isEmpty() || savePath.isNull()) {
         savePath = QDir::homePath();
     }
     savePath = QDir::cleanPath(savePath);
 
     QDir savePathDir(savePath);
     if (!(savePathDir.exists())) {
         savePathDir.mkpath(QStringLiteral("."));
         SpectacleConfig::instance()->setDefaultSaveLocation(savePath);
     }
 
     return savePath;
 }
 
 QUrl ExportManager::getAutosaveFilename()
 {
     const QString baseDir = defaultSaveLocation();
     const QDir baseDirPath(baseDir);
     const QString filename = makeAutosaveFilename();
     const QString fullpath = autoIncrementFilename(baseDirPath.filePath(filename),
                                                    SpectacleConfig::instance()->saveImageFormat(),
                                                    &ExportManager::isFileExists);
 
     const QUrl fileNameUrl = QUrl::fromUserInput(fullpath);
     if (fileNameUrl.isValid()) {
         return fileNameUrl;
     } else {
         return QUrl();
     }
 }
 
 QString ExportManager::truncatedFilename(QString const &filename)
 {
     QString result = filename;
     constexpr auto maxFilenameLength = 255;
     constexpr auto maxExtensionLength = 5;  // For example, ".jpeg"
     constexpr auto maxCounterLength = 20;  // std::numeric_limits<quint64>::max() == 18446744073709551615
     constexpr auto maxLength = maxFilenameLength - maxCounterLength - maxExtensionLength;
     result.truncate(maxLength);
     return result;
 }
 
 QString ExportManager::makeAutosaveFilename()
 {
     const QDateTime timestamp = mPixmapTimestamp;
     QString baseName = SpectacleConfig::instance()->autoSaveFilenameFormat();
     const QString baseDir = defaultSaveLocation();
     QString title;
 
     if (mGrabMode == ImageGrabber::GrabMode::ActiveWindow ||
         mGrabMode == ImageGrabber::GrabMode::TransientWithParent ||
         mGrabMode == ImageGrabber::GrabMode::WindowUnderCursor) {
         title = mWindowTitle.replace(QLatin1String("/"), QLatin1String("_"));  // POSIX doesn't allow "/" in filenames
     } else {
         // Remove '%T' with separators around it
         const auto wordSymbol = QStringLiteral(R"(\p{L}\p{M}\p{N})");
         const auto separator = QStringLiteral("([^%1]+)").arg(wordSymbol);
         const auto re = QRegularExpression(QStringLiteral("(.*?)(%1%T|%T%1)(.*?)").arg(separator));
         baseName.replace(re, QStringLiteral(R"(\1\5)"));
     }
 
     QString result = baseName.replace(QLatin1String("%Y"), timestamp.toString(QStringLiteral("yyyy")))
                              .replace(QLatin1String("%y"), timestamp.toString(QStringLiteral("yy")))
                              .replace(QLatin1String("%M"), timestamp.toString(QStringLiteral("MM")))
                              .replace(QLatin1String("%D"), timestamp.toString(QStringLiteral("dd")))
                              .replace(QLatin1String("%H"), timestamp.toString(QStringLiteral("hh")))
                              .replace(QLatin1String("%m"), timestamp.toString(QStringLiteral("mm")))
                              .replace(QLatin1String("%S"), timestamp.toString(QStringLiteral("ss")))
                              .replace(QLatin1String("%T"), title);
                              
     // check if basename includes %[N]d token for sequential file numbering
     QRegularExpression paddingRE;
     paddingRE.setPattern(QStringLiteral("%(\\d*)d"));
     QRegularExpressionMatch paddingMatch;
                              
     if (result.indexOf(paddingRE, 0, &paddingMatch) > -1) {
         int highestFileNumber = 0;
 
         // determine padding value
         int paddedLength = 1;
         if (!paddingMatch.captured(1).isEmpty()) {
             paddedLength = paddingMatch.captured(1).toInt();
         }
 
         // search save directory for files
         QDir dir(baseDir);
         const QStringList fileNames = dir.entryList(QDir::Files, QDir::Name);
         
         // if there are files in the directory...
         if (fileNames.length() > 0) { 
             QString resultCopy = result;
             QRegularExpression fileNumberRE;
             const QString replacement = QStringLiteral("(\\d{").append(QString::number(paddedLength)).append(QLatin1String(",})"));
             const QString fullNameMatch = QStringLiteral("^").append(resultCopy.replace(paddingMatch.captured(),replacement)).append(QStringLiteral("\\..*$"));
             fileNumberRE.setPattern(fullNameMatch);
 
             // ... check the file names for string matching token with padding specified in result
             const QStringList filteredFiles = fileNames.filter(fileNumberRE);
 
             // if there are files in the direcory that look like the file name with sequential numbering
             if (filteredFiles.length() > 0) {
                 // loop through filtered file names looking for highest number
                 for (const QString &filteredFile: filteredFiles) {
                     int currentFileNumber = fileNumberRE.match(filteredFile).captured(1).toInt();
                     if (currentFileNumber > highestFileNumber) {
                         highestFileNumber = currentFileNumber;
                     }
                 }
             }
         }
         // replace placeholder with next number padded
         const QString nextFileNumberPadded = QString::number(highestFileNumber + 1).rightJustified(paddedLength, QLatin1Char('0'));
         result = result.replace(paddingMatch.captured(), nextFileNumberPadded);
     }
 
     // Remove leading and trailing '/'
     while (result.startsWith(QLatin1Char('/'))) {
         result.remove(0, 1);
     }
     while (result.endsWith(QLatin1Char('/'))) {
         result.chop(1);
     }
 
     if (result.isEmpty()) {
         result = SpectacleConfig::instance()->defaultFilename();
     }
     return truncatedFilename(result);
 }
 
 QString ExportManager::autoIncrementFilename(const QString &baseName, const QString &extension,
                                              FileNameAlreadyUsedCheck isFileNameUsed)
 {
     QString result = truncatedFilename(baseName) + QLatin1Literal(".") + extension;
     if (!((this->*isFileNameUsed)(QUrl::fromUserInput(result)))) {
         return result;
     }
 
     QString fileNameFmt = truncatedFilename(baseName) + QStringLiteral("-%1.");
     for (quint64 i = 1; i < std::numeric_limits<quint64>::max(); i++) {
         result = fileNameFmt.arg(i) + extension;
         if (!((this->*isFileNameUsed)(QUrl::fromUserInput(result)))) {
             return result;
         }
     }
 
     // unlikely this will ever happen, but just in case we've run
     // out of numbers
 
     result = fileNameFmt.arg(QStringLiteral("OVERFLOW-") + QString::number(qrand() % 10000));
     return truncatedFilename(result) + extension;
 }
 
 QString ExportManager::makeSaveMimetype(const QUrl &url)
 {
     QMimeDatabase mimedb;
     QString type = mimedb.mimeTypeForUrl(url).preferredSuffix();
 
     if (type.isEmpty()) {
         return SpectacleConfig::instance()->saveImageFormat();
     }
     return type;
 }
 
 bool ExportManager::writeImage(QIODevice *device, const QByteArray &format)
 {
     QImageWriter imageWriter(device, format);
+    imageWriter.setQuality(SpectacleConfig::instance()->compressionQuality());
     if (!(imageWriter.canWrite())) {
         emit errorMessage(i18n("QImageWriter cannot write image: %1", imageWriter.errorString()));
         return false;
     }
 
     return imageWriter.write(mSavePixmap.toImage());
 }
 
 bool ExportManager::localSave(const QUrl &url, const QString &mimetype)
 {
     // Create save directory if it doesn't exist
     const QUrl dirPath(url.adjusted(QUrl::RemoveFilename));
     const QDir dir(dirPath.path());
 
     if (!dir.mkpath(QStringLiteral("."))) {
         emit errorMessage(xi18nc("@info",
                                  "Cannot save screenshot because creating "
                                  "the directory failed:<nl/><filename>%1</filename>",
                                  dirPath.path()));
         return false;
     }
 
     QFile outputFile(url.toLocalFile());
 
     outputFile.open(QFile::WriteOnly);
     if(!writeImage(&outputFile, mimetype.toLatin1())) {
         emit errorMessage(i18n("Cannot save screenshot. Error while writing file."));
         return false;
     }
     return true;
 }
 
 bool ExportManager::remoteSave(const QUrl &url, const QString &mimetype)
 {
 
     // Check if remote save directory exists
     const QUrl dirPath(url.adjusted(QUrl::RemoveFilename));
     KIO::ListJob *listJob = KIO::listDir(dirPath);
     listJob->exec();
 
     if (listJob->error() != KJob::NoError) {
         // Create remote save directory
         KIO::MkpathJob *mkpathJob = KIO::mkpath(dirPath, QUrl(defaultSaveLocation()));
         mkpathJob->exec();
 
         if (mkpathJob->error() != KJob::NoError) {
             emit errorMessage(xi18nc("@info",
                                      "Cannot save screenshot because creating the "
                                      "remote directory failed:<nl/><filename>%1</filename>",
                                      dirPath.path()));
             return false;
         }
     }
 
     QTemporaryFile tmpFile;
 
     if (tmpFile.open()) {
         if(!writeImage(&tmpFile, mimetype.toLatin1())) {
             emit errorMessage(i18n("Cannot save screenshot. Error while writing temporary local file."));
             return false;
         }
 
         KIO::FileCopyJob *uploadJob = KIO::file_copy(QUrl::fromLocalFile(tmpFile.fileName()), url);
         uploadJob->exec();
 
         if (uploadJob->error() != KJob::NoError) {
             emit errorMessage(i18n("Unable to save image. Could not upload file to remote location."));
             return false;
         }
         return true;
     }
 
     return false;
 }
 
 QUrl ExportManager::tempSave(const QString &mimetype)
 {
     // if we already have a temp file saved, use that
     if (mTempFile.isValid()) {
         if (QFile(mTempFile.toLocalFile()).exists()) {
             return mTempFile;
         }
     }
 
     if (!mTempDir) {
         mTempDir = new QTemporaryDir(QDir::tempPath() + QDir::separator() + QStringLiteral("Spectacle.XXXXXX"));
     }
     if (mTempDir && mTempDir->isValid()) {
         // create the temporary file itself with normal file name and also unique one for this session
         // supports the use-case of creating multiple screenshots in a row
         // and exporting them to the same destination e.g. via clipboard,
         // where the temp file name is used as filename suggestion
         const QString baseFileName = mTempDir->path() + QDir::separator() + makeAutosaveFilename();
         const QString fileName = autoIncrementFilename(baseFileName, mimetype,
                                                        &ExportManager::isTempFileAlreadyUsed);
         QFile tmpFile(fileName);
         if (tmpFile.open(QFile::WriteOnly)) {
             if(writeImage(&tmpFile, mimetype.toLatin1())) {
                 mTempFile = QUrl::fromLocalFile(tmpFile.fileName());
                 // try to make sure 3rd-party which gets the url of the temporary file e.g. on export
                 // properly treats this as readonly, also hide from other users
                 tmpFile.setPermissions(QFile::ReadUser);
                 return mTempFile;
             }
         }
     }
 
     emit errorMessage(i18n("Cannot save screenshot. Error while writing temporary local file."));
     return QUrl();
 }
 
 bool ExportManager::save(const QUrl &url)
 {
     if (!(url.isValid())) {
         emit errorMessage(i18n("Cannot save screenshot. The save filename is invalid."));
         return false;
     }
 
     QString mimetype = makeSaveMimetype(url);
     if (url.isLocalFile()) {
         return localSave(url, mimetype);
     }
     return remoteSave(url, mimetype);
 }
 
 bool ExportManager::isFileExists(const QUrl &url) const
 {
     if (!(url.isValid())) {
         return false;
     }
 
     KIO::StatJob * existsJob = KIO::stat(url, KIO::StatJob::DestinationSide, 0);
     existsJob->exec();
 
     return (existsJob->error() == KJob::NoError);
 }
 
 bool ExportManager::isTempFileAlreadyUsed(const QUrl &url) const
 {
     return mUsedTempFileNames.contains(url);
 }
 
 // save slots
 
 void ExportManager::doSave(const QUrl &url, bool notify)
 {
     if (mSavePixmap.isNull()) {
         emit errorMessage(i18n("Cannot save an empty screenshot image."));
         return;
     }
 
     QUrl savePath = url.isValid() ? url : getAutosaveFilename();
     if (save(savePath)) {
         QDir dir(savePath.path());
         dir.cdUp();
         SpectacleConfig::instance()->setLastSaveFile(savePath);
 
         emit imageSaved(savePath);
         if (notify) {
             emit forceNotify(savePath);
         }
     }
 }
 
 bool ExportManager::doSaveAs(QWidget *parentWindow, bool notify)
 {
     QStringList supportedFilters;
     SpectacleConfig *config = SpectacleConfig::instance();
 
     // construct the supported mimetype list
     Q_FOREACH (auto mimeType, QImageWriter::supportedMimeTypes()) {
         supportedFilters.append(QString::fromUtf8(mimeType).trimmed());
     }
 
     // construct the file name
     const QString filenameExtension = SpectacleConfig::instance()->saveImageFormat();
     const QString mimetype = QMimeDatabase().mimeTypeForFile(QStringLiteral("~/fakefile.") + filenameExtension, QMimeDatabase::MatchExtension).name();
     QFileDialog dialog(parentWindow);
     dialog.setAcceptMode(QFileDialog::AcceptSave);
     dialog.setFileMode(QFileDialog::AnyFile);
     dialog.setDirectoryUrl(config->lastSaveAsLocation());
     dialog.selectFile(makeAutosaveFilename() + QStringLiteral(".") + filenameExtension);
     dialog.setDefaultSuffix(QStringLiteral(".") + filenameExtension);
     dialog.setMimeTypeFilters(supportedFilters);
     dialog.selectMimeTypeFilter(mimetype);
 
     // launch the dialog
     if (dialog.exec() == QFileDialog::Accepted) {
         const QUrl saveUrl = dialog.selectedUrls().first();
         if (saveUrl.isValid()) {
             if (save(saveUrl)) {
                 emit imageSaved(saveUrl);
                 config->setLastSaveAsFile(saveUrl);
 
                 if (notify) {
                     emit forceNotify(saveUrl);
                 }
                 return true;
             }
         }
     }
     return false;
 }
 
 // misc helpers
 
 void ExportManager::doCopyToClipboard()
 {
     QApplication::clipboard()->setPixmap(mSavePixmap, QClipboard::Clipboard);
 }
 
 void ExportManager::doPrint(QPrinter *printer)
 {
     QPainter painter;
 
     if (!(painter.begin(printer))) {
         emit errorMessage(i18n("Printing failed. The printer failed to initialize."));
         delete printer;
         return;
     }
 
     QRect devRect(0, 0, printer->width(), printer->height());
     QPixmap pixmap = mSavePixmap.scaled(devRect.size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
     QRect srcRect = pixmap.rect();
     srcRect.moveCenter(devRect.center());
 
     painter.drawPixmap(srcRect.topLeft(), pixmap);
     painter.end();
 
     delete printer;
     return;
 }
diff --git a/src/Gui/SettingsDialog/SaveOptionsPage.cpp b/src/Gui/SettingsDialog/SaveOptionsPage.cpp
index 6003896..b17ff59 100644
--- a/src/Gui/SettingsDialog/SaveOptionsPage.cpp
+++ b/src/Gui/SettingsDialog/SaveOptionsPage.cpp
@@ -1,175 +1,211 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "SaveOptionsPage.h"
 
 #include "SpectacleConfig.h"
 
 #include <KIOWidgets/KUrlRequester>
 #include <KLocalizedString>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QFormLayout>
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QComboBox>
 #include <QImageWriter>
 #include <QCheckBox>
 
 SaveOptionsPage::SaveOptionsPage(QWidget *parent) :
     SettingsPage(parent)
 {
     QFormLayout *mainLayout = new QFormLayout;
     setLayout(mainLayout);
 
     // Save location
     mUrlRequester = new KUrlRequester;
     mUrlRequester->setMode(KFile::Directory);
     connect(mUrlRequester, &KUrlRequester::textChanged, this, &SaveOptionsPage::markDirty);
     mainLayout->addRow(i18n("Save Location:"), mUrlRequester);
 
     // copy file location to clipboard after saving
     mCopyPathToClipboard = new QCheckBox(i18n("Copy file location to clipboard after saving"), this);
     connect(mCopyPathToClipboard, &QCheckBox::toggled, this, &SaveOptionsPage::markDirty);
     mainLayout->addRow(QString(), mCopyPathToClipboard);
 
 
     mainLayout->addItem(new QSpacerItem(0, 18, QSizePolicy::Fixed, QSizePolicy::Fixed));
 
+    // Compression quality slider and current value display
+    QHBoxLayout *sliderHorizLayout = new QHBoxLayout();
+    QVBoxLayout *sliderVertLayout = new QVBoxLayout();
+
+    // Current value
+    QLabel *qualityValue = new QLabel();
+    qualityValue->setNum(SpectacleConfig::instance()->compressionQuality());
+    qualityValue->setMinimumWidth(qualityValue->fontInfo().pointSize()*3);
+
+    // Slider
+    mQualitySlider = new QSlider(Qt::Horizontal);
+    mQualitySlider->setRange(0, 100);
+    mQualitySlider->setTickInterval(5);
+    mQualitySlider->setSliderPosition(SpectacleConfig::instance()->compressionQuality());
+    mQualitySlider->setTickPosition(QSlider::TicksBelow);
+    mQualitySlider->setTracking(true);
+    connect(mQualitySlider, &QSlider::valueChanged, [=](int value) {
+        qualityValue->setNum(value);
+        markDirty();
+    });
+
+    sliderHorizLayout->addWidget(mQualitySlider);
+    sliderHorizLayout->addWidget(qualityValue);
+
+    sliderVertLayout->addLayout(sliderHorizLayout);
+
+    QLabel *qualitySliderDescription = new QLabel();
+    qualitySliderDescription->setText(i18n("Choose the image quality when saving with lossy image formats like JPEG"));
+
+    sliderVertLayout->addWidget(qualitySliderDescription);
+
+    mainLayout->addRow(i18n("Compression Quality:"), sliderVertLayout);
+
+    mainLayout->addItem(new QSpacerItem(0, 18, QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     // filename chooser and instructional text
     QVBoxLayout *saveNameLayout = new QVBoxLayout;
 
     // filename chooser text field
     QHBoxLayout *saveFieldLayout = new QHBoxLayout;
     mSaveNameFormat = new QLineEdit;
     connect(mSaveNameFormat, &QLineEdit::textEdited, this, &SaveOptionsPage::markDirty);
     connect(mSaveNameFormat, &QLineEdit::textEdited, [&](const QString &newText) {
         QString fmt;
         Q_FOREACH(auto item, QImageWriter::supportedImageFormats()) {
             fmt = QString::fromLocal8Bit(item);
             if (newText.endsWith(QLatin1Char('.') + fmt, Qt::CaseInsensitive)) {
                 QString txtCopy = newText;
                 txtCopy.chop(fmt.length() + 1);
                 mSaveNameFormat->setText(txtCopy);
                 mSaveImageFormat->setCurrentIndex(mSaveImageFormat->findText(fmt.toUpper()));
             }
         }
     });
     mSaveNameFormat->setPlaceholderText(QStringLiteral("%d"));
     saveFieldLayout->addWidget(mSaveNameFormat);
 
     mSaveImageFormat = new QComboBox;
     mSaveImageFormat->addItems([&](){
         QStringList items;
         Q_FOREACH(auto fmt, QImageWriter::supportedImageFormats()) {
             items.append(QString::fromLocal8Bit(fmt).toUpper());
         }
         return items;
     }());
     connect(mSaveImageFormat, &QComboBox::currentTextChanged, this, &SaveOptionsPage::markDirty);
     saveFieldLayout->addWidget(mSaveImageFormat);
     saveNameLayout->addLayout(saveFieldLayout);
 
     // now the save filename format layout
     const QString helpText = i18nc("%1 is the default filename of a screenshot",
         "<p>You can use the following placeholders in the filename, which will be replaced "
         "with actual text when the file is saved:</p>"
 
         "<blockquote>"
             "<b>%Y</b>: Year (4 digit)<br />"
             "<b>%y</b>: Year (2 digit)<br />"
             "<b>%M</b>: Month<br />"
             "<b>%D</b>: Day<br />"
             "<b>%H</b>: Hour<br />"
             "<b>%m</b>: Minute<br />"
             "<b>%S</b>: Second<br />"
             "<b>%T</b>: Window title<br />"
             "<b>%d</b>: Sequential numbering<br />"
             "<b>%Nd</b>: Sequential numbering, padded out to N digits"
         "</blockquote>"
 
         "<p>To save to a sub-folder, use slashes, e.g.:</p>"
 
         "<blockquote>"
             "<b>%Y</b>/<b>%M</b>/%1"
         "</blockquote>",
         SpectacleConfig::instance()->defaultFilename() + SpectacleConfig::instance()->defaultTimestampTemplate()
     );
 
     QLabel *fmtHelpText = new QLabel(helpText, this);
     fmtHelpText->setWordWrap(true);
     fmtHelpText->setTextFormat(Qt::RichText);
     fmtHelpText->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
     saveNameLayout->addWidget(fmtHelpText);
     mainLayout->addRow(i18n("Filename:"), saveNameLayout);
 
     // read in the data
     resetChanges();
 }
 
 void SaveOptionsPage::markDirty()
 {
     mChangesMade = true;
 }
 
 void SaveOptionsPage::saveChanges()
 {
     // bring up the configuration reader
 
     SpectacleConfig *cfgManager = SpectacleConfig::instance();
 
     // save the data
 
     cfgManager->setDefaultSaveLocation(mUrlRequester->url().toDisplayString(QUrl::PreferLocalFile));
     cfgManager->setAutoSaveFilenameFormat(mSaveNameFormat->text());
     cfgManager->setSaveImageFormat(mSaveImageFormat->currentText().toLower());
     cfgManager->setCopySaveLocationToClipboard(mCopyPathToClipboard->checkState() == Qt::Checked);
+    cfgManager->setCompressionQuality(mQualitySlider->value());
 
     // done
 
     mChangesMade = false;
 }
 
 void SaveOptionsPage::resetChanges()
 {
     // bring up the configuration reader
 
     SpectacleConfig *cfgManager = SpectacleConfig::instance();
 
     // read in the data
 
     mSaveNameFormat->setText(cfgManager->autoSaveFilenameFormat());
     mUrlRequester->setUrl(QUrl::fromUserInput(cfgManager->defaultSaveLocation()));
     mCopyPathToClipboard->setChecked(cfgManager->copySaveLocationToClipboard());
+    mQualitySlider->setSliderPosition(cfgManager->compressionQuality());
 
     // read in the save image format and calculate its index
 
     {
         int index = mSaveImageFormat->findText(cfgManager->saveImageFormat().toUpper());
         if (index >= 0) {
             mSaveImageFormat->setCurrentIndex(index);
         }
     }
 
     // done
 
     mChangesMade = false;
 }
diff --git a/src/Gui/SettingsDialog/SaveOptionsPage.h b/src/Gui/SettingsDialog/SaveOptionsPage.h
index 8d77d8b..b1fa9cc 100644
--- a/src/Gui/SettingsDialog/SaveOptionsPage.h
+++ b/src/Gui/SettingsDialog/SaveOptionsPage.h
@@ -1,58 +1,58 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #ifndef SAVEOPTIONSPAGE_H
 #define SAVEOPTIONSPAGE_H
 
 #include "SettingsPage.h"
 
 class QDialogButtonBox;
 class QLineEdit;
 class QComboBox;
 class KUrlRequester;
 class QCheckBox;
+class QSlider;
 
 class SaveOptionsPage : public SettingsPage
 {
     Q_OBJECT
 
     public:
 
     explicit SaveOptionsPage(QWidget *parent = nullptr);
 
     public Q_SLOTS:
 
     void saveChanges() override;
     void resetChanges() override;
 
     private Q_SLOTS:
 
     void markDirty();
 
     private:
 
-    QDialogButtonBox *mDialogButtonBox;
     QLineEdit        *mSaveNameFormat;
     KUrlRequester    *mUrlRequester;
     QComboBox        *mSaveImageFormat;
     QCheckBox        *mCopyPathToClipboard;
-
+    QSlider          *mQualitySlider;
 };
 
 #endif // SAVEOPTIONSPAGE_H
diff --git a/src/Gui/SettingsDialog/SettingsDialog.cpp b/src/Gui/SettingsDialog/SettingsDialog.cpp
index 684154e..137f488 100644
--- a/src/Gui/SettingsDialog/SettingsDialog.cpp
+++ b/src/Gui/SettingsDialog/SettingsDialog.cpp
@@ -1,86 +1,86 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "SettingsDialog.h"
 
 #include "GeneralOptionsPage.h"
 #include "SaveOptionsPage.h"
 
 #include <KLocalizedString>
 
 #include <QIcon>
 #include <QMessageBox>
 
 SettingsDialog::SettingsDialog(QWidget *parent) :
     KPageDialog(parent)
 {
     // set up window options and geometry
     setWindowTitle(i18nc("@title:window", "Configure"));
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
-    resize(530, 470);
+    resize(600, 550);
 
     // init all pages
     QMetaObject::invokeMethod(this, "initPages", Qt::QueuedConnection);
 }
 
 void SettingsDialog::initPages()
 {
     KPageWidgetItem *generalOptions = new KPageWidgetItem(new GeneralOptionsPage(this), i18n("General"));
     generalOptions->setHeader(i18n("General"));
     generalOptions->setIcon(QIcon::fromTheme(QStringLiteral("view-preview"))); // This is what Dolphin uses for the icon on its General page...
     addPage(generalOptions);
     mPages.insert(generalOptions);
 
     KPageWidgetItem *saveOptions = new KPageWidgetItem(new SaveOptionsPage(this), i18n("Save"));
     saveOptions->setHeader(i18n("Save"));
     saveOptions->setIcon(QIcon::fromTheme(QStringLiteral("document-save")));
     addPage(saveOptions);
     mPages.insert(saveOptions);
 
     connect(this, &SettingsDialog::currentPageChanged, this, &SettingsDialog::onPageChanged);
 }
 
 void SettingsDialog::accept()
 {
     Q_FOREACH(auto page, mPages) {
         SettingsPage *pageWidget = dynamic_cast<SettingsPage *>(page->widget());
         if (pageWidget) {
             pageWidget->saveChanges();
         }
     }
 
     done(QDialog::Accepted);
 }
 
 void SettingsDialog::onPageChanged(KPageWidgetItem *current, KPageWidgetItem *before)
 {
     Q_UNUSED(current);
 
     SettingsPage *pageWidget = dynamic_cast<SettingsPage *>(before->widget());
     if (pageWidget && (pageWidget->changesMade())) {
         QMessageBox::StandardButton response = QMessageBox::question(this, i18n("Apply Unsaved Changes"),
                      i18n("You have made changes to the settings in this tab. Do you want to apply those changes?"));
 
         if (response == QMessageBox::Yes) {
             pageWidget->saveChanges();
         } else {
             pageWidget->resetChanges();
         }
     }
 }
diff --git a/src/SpectacleConfig.cpp b/src/SpectacleConfig.cpp
index 8dd823b..f8f276f 100644
--- a/src/SpectacleConfig.cpp
+++ b/src/SpectacleConfig.cpp
@@ -1,350 +1,363 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "SpectacleConfig.h"
 
 #include <KWindowSystem>
 
 SpectacleConfig::SpectacleConfig(QObject *parent) :
     QObject(parent)
 {
     mConfig = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     mGeneralConfig = KConfigGroup(mConfig, "General");
     mGuiConfig = KConfigGroup(mConfig, "GuiConfig");
 }
 
 SpectacleConfig::~SpectacleConfig()
 {}
 
 SpectacleConfig* SpectacleConfig::instance()
 {
     static SpectacleConfig instance;
     return &instance;
 }
 
 QString SpectacleConfig::defaultFilename() const
 {
     return QStringLiteral("Screenshot");
 }
 
 QString SpectacleConfig::defaultTimestampTemplate() const
 {
     // includes separator at the front
     return QStringLiteral("_%Y%M%D_%H%m%S");
 }
 
 // lastSaveAsLocation
 
 QUrl SpectacleConfig::lastSaveAsFile() const
 {
     return mGeneralConfig.readEntry(QStringLiteral("lastSaveAsFile"),
                                     QUrl(this->defaultSaveLocation()));
 }
 
 void SpectacleConfig::setLastSaveAsFile(const QUrl &location)
 {
     mGeneralConfig.writeEntry(QStringLiteral("lastSaveAsFile"), location);
     mGeneralConfig.sync();
 }
 
 QUrl SpectacleConfig::lastSaveAsLocation() const
 {
     return this->lastSaveAsFile().adjusted(QUrl::RemoveFilename);
 }
 
 // lastSaveLocation
 
 QUrl SpectacleConfig::lastSaveFile() const
 {
     return mGeneralConfig.readEntry(QStringLiteral("lastSaveFile"),
                                     QUrl(this->defaultSaveLocation()));
 }
 
 void SpectacleConfig::setLastSaveFile(const QUrl &location)
 {
     mGeneralConfig.writeEntry(QStringLiteral("lastSaveFile"), location);
     mGeneralConfig.sync();
 }
 
 QUrl SpectacleConfig::lastSaveLocation() const 
 {
     return this->lastSaveFile().adjusted(QUrl::RemoveFilename);
 }
 
 // cropRegion
 
 QRect SpectacleConfig::cropRegion() const
 {
     return mGuiConfig.readEntry(QStringLiteral("cropRegion"), QRect());
 }
 
 void SpectacleConfig::setCropRegion(const QRect &region)
 {
     mGuiConfig.writeEntry(QStringLiteral("cropRegion"), region);
     mGuiConfig.sync();
 }
 
 // onclick
 
 bool SpectacleConfig::onClickChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("onClickChecked"), false);
 }
 
 void SpectacleConfig::setOnClickChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("onClickChecked"), enabled);
     mGuiConfig.sync();
 }
 
 // include pointer
 
 bool SpectacleConfig::includePointerChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("includePointer"), true);
 }
 
 void SpectacleConfig::setIncludePointerChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("includePointer"), enabled);
     mGuiConfig.sync();
 }
 
 // include decorations
 
 bool SpectacleConfig::includeDecorationsChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("includeDecorations"), true);
 }
 
 void SpectacleConfig::setIncludeDecorationsChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("includeDecorations"), enabled);
     mGuiConfig.sync();
 }
 
 // capture transient window only
 
 bool SpectacleConfig::captureTransientWindowOnlyChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("transientOnly"), false);
 }
 
 void SpectacleConfig::setCaptureTransientWindowOnlyChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("transientOnly"), enabled);
     mGuiConfig.sync();
 }
 
 // quit after saving, copying, or exporting the image
 
 bool SpectacleConfig::quitAfterSaveOrCopyChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("quitAfterSaveCopyExport"), false);
 }
 
 void SpectacleConfig::setQuitAfterSaveOrCopyChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("quitAfterSaveCopyExport"), enabled);
     mGuiConfig.sync();
 }
 
 // show magnifier
 
 bool SpectacleConfig::showMagnifierChecked() const
 {
     return mGuiConfig.readEntry(QStringLiteral("showMagnifier"), false);
 }
 
 void SpectacleConfig::setShowMagnifierChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("showMagnifier"), enabled);
     mGuiConfig.sync();
 }
 
 // release mouse-button to capture
 
 bool SpectacleConfig::useReleaseToCapture() const
 {
     return mGuiConfig.readEntry(QStringLiteral("useReleaseToCapture"), false);
 }
 
 void SpectacleConfig::setUseReleaseToCaptureChecked(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("useReleaseToCapture"), enabled);
     mGuiConfig.sync();
 }
 
 // capture delay
 
 qreal SpectacleConfig::captureDelay() const
 {
     return mGuiConfig.readEntry(QStringLiteral("captureDelay"), 0.0);
 }
 
 void SpectacleConfig::setCaptureDelay(qreal delay)
 {
     mGuiConfig.writeEntry(QStringLiteral("captureDelay"), delay);
     mGuiConfig.sync();
 }
 
 // capture mode
 
 int SpectacleConfig::captureMode() const
 {
     return std::max(0, mGuiConfig.readEntry(QStringLiteral("captureModeIndex"), 0));
 }
 
 void SpectacleConfig::setCaptureMode(int index)
 {
     mGuiConfig.writeEntry(QStringLiteral("captureModeIndex"), index);
     mGuiConfig.sync();
 }
 
 // remember last rectangular region
 
 bool SpectacleConfig::rememberLastRectangularRegion() const
 {
     return mGuiConfig.readEntry(QStringLiteral("rememberLastRectangularRegion"), true);
 }
 
 void SpectacleConfig::setRememberLastRectangularRegion(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("rememberLastRectangularRegion"), enabled);
     mGuiConfig.sync();
 }
 
 bool SpectacleConfig::alwaysRememberRegion() const
 {
     // Default Value is for compatibility reasons as the old behavior was always to remember across restarts
     bool useOldBehavior = mGuiConfig.readEntry(QStringLiteral("rememberLastRectangularRegion"), false);
     return mGuiConfig.readEntry(QStringLiteral("alwaysRememberRegion"), useOldBehavior);
 }
 
 void SpectacleConfig::setAlwaysRememberRegion (bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("alwaysRememberRegion"), enabled);
     mGuiConfig.sync();
 }
 
 // use light region mask colour
 
 bool SpectacleConfig::useLightRegionMaskColour() const
 {
     return mGuiConfig.readEntry(QStringLiteral("useLightMaskColour"), false);
 }
 
 void SpectacleConfig::setUseLightRegionMaskColour(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("useLightMaskColour"), enabled);
     mGuiConfig.sync();
 }
 
+// compression quality setting
+
+int SpectacleConfig::compressionQuality() const
+{
+    return mGuiConfig.readEntry(QStringLiteral("compressionQuality"), 90);
+}
+
+void SpectacleConfig::setCompressionQuality(int value)
+{
+    mGuiConfig.writeEntry(QStringLiteral("compressionQuality"), value);
+    mGuiConfig.sync();
+}
+
 // last used save mode
 
 SaveMode SpectacleConfig::lastUsedSaveMode() const
 {
     switch (mGuiConfig.readEntry(QStringLiteral("lastUsedSaveMode"), 0)) {
         default:
         case 0:
             return SaveMode::SaveAs;
         case 1:
             return SaveMode::Save;
     }
 }
 
 void SpectacleConfig::setLastUsedSaveMode(SaveMode mode)
 {
     mGuiConfig.writeEntry(QStringLiteral("lastUsedSaveMode"), static_cast<int>(mode));
     mGuiConfig.sync();
 }
 
 // autosave filename format
 
 QString SpectacleConfig::autoSaveFilenameFormat() const
 {
     const QString sff = mGeneralConfig.readEntry(QStringLiteral("save-filename-format"),
                                            QString(defaultFilename() + defaultTimestampTemplate()));
     return sff.isEmpty() ? QStringLiteral("%d") : sff;
 }
 
 void SpectacleConfig::setAutoSaveFilenameFormat(const QString &format)
 {
     mGeneralConfig.writeEntry(QStringLiteral("save-filename-format"), format);
     mGeneralConfig.sync();
 }
 
 // autosave location
 
 QString SpectacleConfig::defaultSaveLocation() const
 {
     return mGeneralConfig.readPathEntry(QStringLiteral("default-save-location"),
                           QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
 }
 
 void SpectacleConfig::setDefaultSaveLocation(const QString &location)
 {
     mGeneralConfig.writePathEntry(QStringLiteral("default-save-location"), location);
     mGeneralConfig.sync();
 }
 
 // copy file location to clipboard after saving
 
 bool SpectacleConfig::copySaveLocationToClipboard() const
 {
     return mGeneralConfig.readEntry(QStringLiteral("copySaveLocation"), false);
 }
 
 void SpectacleConfig::setCopySaveLocationToClipboard(bool enabled)
 {
     mGeneralConfig.writeEntry(QStringLiteral("copySaveLocation"), enabled);
     mGeneralConfig.sync();
 }
 
 // autosave image format
 
 QString SpectacleConfig::saveImageFormat() const
 {
     return mGeneralConfig.readEntry(QStringLiteral("default-save-image-format"),
                              QStringLiteral("png"));
 }
 
 void SpectacleConfig::setSaveImageFormat(const QString &saveFmt)
 {
     mGeneralConfig.writeEntry(QStringLiteral("default-save-image-format"), saveFmt);
     mGeneralConfig.sync();
 }
 
 SpectacleConfig::PrintKeyActionRunning SpectacleConfig::printKeyActionRunning() const
 {
     mConfig->reparseConfiguration();
     int newScreenshotAction = static_cast<int>(SpectacleConfig::PrintKeyActionRunning::TakeNewScreenshot);
     int readValue = mGuiConfig.readEntry(QStringLiteral("printKeyActionRunning"), newScreenshotAction);
     if ((KWindowSystem::isPlatformWayland() || qstrcmp(qgetenv("XDG_SESSION_TYPE"), "wayland") == 0 )
         && readValue == SpectacleConfig::PrintKeyActionRunning::FocusWindow)  {
         return SpectacleConfig::PrintKeyActionRunning::TakeNewScreenshot;
     }
     return static_cast<SpectacleConfig::PrintKeyActionRunning>(readValue);
 }
 
 void SpectacleConfig::setPrintKeyActionRunning (SpectacleConfig::PrintKeyActionRunning action)
 {
     mGuiConfig.writeEntry(QStringLiteral("printKeyActionRunning"), static_cast<int>(action));
     mGuiConfig.sync();
 }
diff --git a/src/SpectacleConfig.h b/src/SpectacleConfig.h
index 4ff217b..8578d22 100644
--- a/src/SpectacleConfig.h
+++ b/src/SpectacleConfig.h
@@ -1,139 +1,142 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #ifndef SPECTACLECONFIG_H
 #define SPECTACLECONFIG_H
 
 #include <QObject>
 #include <QUrl>
 #include <QRect>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 enum class SaveMode {
     SaveAs,
     Save
 };
 
 class SpectacleConfig : public QObject
 {
     Q_OBJECT
 
     // singleton-ize the class
 
     public:
 
     static SpectacleConfig* instance();
 
     QString defaultFilename() const;
     QString defaultTimestampTemplate() const;
     
     QUrl lastSaveAsLocation() const;
     QUrl lastSaveLocation() const;
 
      enum PrintKeyActionRunning : int {
         TakeNewScreenshot = 0,
         StartNewInstance,
         FocusWindow
     };
 
     private:
 
     explicit SpectacleConfig(QObject *parent = nullptr);
     virtual ~SpectacleConfig();
 
     SpectacleConfig(SpectacleConfig const&) = delete;
     void operator= (SpectacleConfig const&) = delete;
 
     // everything else
 
     public Q_SLOTS:
 
     QUrl lastSaveAsFile() const;
     void setLastSaveAsFile(const QUrl &location);
 
     QUrl lastSaveFile() const;
     void setLastSaveFile(const QUrl &location);
 
     QRect cropRegion() const;
     void setCropRegion(const QRect &region);
 
     bool onClickChecked() const;
     void setOnClickChecked(bool enabled);
 
     bool includePointerChecked() const;
     void setIncludePointerChecked(bool enabled);
 
     bool includeDecorationsChecked() const;
     void setIncludeDecorationsChecked(bool enabled);
 
     bool captureTransientWindowOnlyChecked() const;
     void setCaptureTransientWindowOnlyChecked(bool enabled);
 
     bool quitAfterSaveOrCopyChecked() const;
     void setQuitAfterSaveOrCopyChecked(bool enabled);
 
     bool showMagnifierChecked() const;
     void setShowMagnifierChecked(bool enabled);
 
     bool useReleaseToCapture() const;
     void setUseReleaseToCaptureChecked(bool enabled);
 
     qreal captureDelay() const;
     void setCaptureDelay(qreal delay);
 
     int captureMode() const;
     void setCaptureMode(int index);
 
     bool rememberLastRectangularRegion() const;
     void setRememberLastRectangularRegion(bool enabled);
 
     bool alwaysRememberRegion() const;
     void setAlwaysRememberRegion(bool enabled);
 
     bool useLightRegionMaskColour() const;
     void setUseLightRegionMaskColour(bool enabled);
 
+    int compressionQuality() const;
+    void setCompressionQuality(int value);
+
     SaveMode lastUsedSaveMode() const;
     void setLastUsedSaveMode(SaveMode mode);
 
     QString autoSaveFilenameFormat() const;
     void setAutoSaveFilenameFormat(const QString &format);
 
     QString defaultSaveLocation() const;
     void setDefaultSaveLocation(const QString &location);
 
     bool copySaveLocationToClipboard() const;
     void setCopySaveLocationToClipboard(bool enabled);
 
     QString saveImageFormat() const;
     void setSaveImageFormat(const QString &saveFmt);
 
     PrintKeyActionRunning printKeyActionRunning() const;
     void setPrintKeyActionRunning (PrintKeyActionRunning action);
 
     private:
 
     KSharedConfigPtr mConfig;
     KConfigGroup     mGeneralConfig;
     KConfigGroup     mGuiConfig;
 };
 
 #endif // SPECTACLECONFIG_H