diff --git a/src/ExportManager.cpp b/src/ExportManager.cpp
index d8070ee..3d1007f 100644
--- a/src/ExportManager.cpp
+++ b/src/ExportManager.cpp
@@ -1,468 +1,514 @@
 /*
  *  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(QLatin1String("%(\\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();
+        }
+
+        // seach 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 = QString::fromLatin1("(\\d{").append(QString::number(paddedLength)).append(QString::fromLatin1(",})"));
+            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);
     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(QLatin1String("."))) {
         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 65db6ef..6003896 100644
--- a/src/Gui/SettingsDialog/SaveOptionsPage.cpp
+++ b/src/Gui/SettingsDialog/SaveOptionsPage.cpp
@@ -1,173 +1,175 @@
 /*
  *  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));
 
 
     // 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"
+            "<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);
 
     // 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());
 
     // 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/SpectacleConfig.cpp b/src/SpectacleConfig.cpp
index 3d8d93d..8c7a265 100644
--- a/src/SpectacleConfig.cpp
+++ b/src/SpectacleConfig.cpp
@@ -1,303 +1,304 @@
 /*
  *  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"
 
 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();
 }
 
 // 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 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"), false);
 }
 
 void SpectacleConfig::setRememberLastRectangularRegion(bool enabled)
 {
     mGuiConfig.writeEntry(QStringLiteral("rememberLastRectangularRegion"), 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();
 }
 
 // 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
 {
-    return mGeneralConfig.readEntry(QStringLiteral("save-filename-format"),
-                                    QString(defaultFilename() + defaultTimestampTemplate()));
+    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();
 }