diff --git a/src/Gui/KSImageWidget.cpp b/src/Gui/KSImageWidget.cpp
index 7e9ce07..a627f5a 100644
--- a/src/Gui/KSImageWidget.cpp
+++ b/src/Gui/KSImageWidget.cpp
@@ -1,91 +1,91 @@
 /*
  *  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 "KSImageWidget.h"
 
 KSImageWidget::KSImageWidget(QWidget *parent):
     QLabel(parent),
     mPixmap(QPixmap())
 {
     mDSEffect = new QGraphicsDropShadowEffect(this);
 
-    mDSEffect->setBlurRadius(5);
+    mDSEffect->setBlurRadius(SpectacleImage::SHADOW_RADIUS);
     mDSEffect->setOffset(0);
     mDSEffect->setColor(QColor(Qt::black));
 
     setGraphicsEffect(mDSEffect);
     setCursor(Qt::OpenHandCursor);
     setAlignment(Qt::AlignCenter);
     setMinimumSize(size());
 }
 
 void KSImageWidget::setScreenshot(const QPixmap &pixmap)
 {
     mPixmap = pixmap;
     setToolTip(i18n("Image Size: %1x%2 pixels", mPixmap.width(), mPixmap.height()));
     setScaledPixmap();
 }
 
 void KSImageWidget::setScaledPixmap()
 {
     const qreal scale = qApp->devicePixelRatio();
     QPixmap scaledPixmap = mPixmap.scaled(size() * scale, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     scaledPixmap.setDevicePixelRatio(scale);
     setPixmap(scaledPixmap);
 }
 
 // drag handlers
 
 void KSImageWidget::mousePressEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::LeftButton) {
         mDragStartPosition = event->pos();
         setCursor(Qt::ClosedHandCursor);
     }
 }
 
 void KSImageWidget::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::LeftButton) {
         setCursor(Qt::OpenHandCursor);
     }
 }
 
 void KSImageWidget::mouseMoveEvent(QMouseEvent *event)
 {
     if (!(event->buttons() & Qt::LeftButton)) {
         return;
     }
 
     if ((event->pos() - mDragStartPosition).manhattanLength() < QGuiApplication::styleHints()->startDragDistance()) {
         return;
     }
 
     setCursor(Qt::OpenHandCursor);
     emit dragInitiated();
 }
 
 // resize handler
 
 void KSImageWidget::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event);
     setScaledPixmap();
 }
 
diff --git a/src/Gui/KSImageWidget.h b/src/Gui/KSImageWidget.h
index 0433698..d579f8d 100644
--- a/src/Gui/KSImageWidget.h
+++ b/src/Gui/KSImageWidget.h
@@ -1,63 +1,68 @@
 /*
  *  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 KSIMAGEWIDGET_H
 #define KSIMAGEWIDGET_H
 
 #include <QGuiApplication>
 #include <QStyleHints>
 #include <QLabel>
 #include <QColor>
 #include <QMouseEvent>
 #include <QPoint>
 #include <QPixmap>
 #include <QGraphicsDropShadowEffect>
 
 #include <KLocalizedString>
 
+namespace SpectacleImage {
+    static const int SHADOW_RADIUS = 5;
+}
+
 class KSImageWidget : public QLabel
 {
     Q_OBJECT
 
+
     public:
 
     explicit KSImageWidget(QWidget *parent = 0);
     void setScreenshot(const QPixmap &pixmap);
 
     signals:
 
     void dragInitiated();
 
     protected:
 
     void mousePressEvent(QMouseEvent *event)   Q_DECL_OVERRIDE;
     void mouseReleaseEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
     void mouseMoveEvent(QMouseEvent *event)    Q_DECL_OVERRIDE;
     void resizeEvent(QResizeEvent *event)      Q_DECL_OVERRIDE;
 
     private:
 
     void setScaledPixmap();
 
     QGraphicsDropShadowEffect *mDSEffect;
     QPixmap                    mPixmap;
     QPoint                     mDragStartPosition;
 };
 
 #endif // KSIMAGEWIDGET_H
diff --git a/src/Gui/KSMainWindow.cpp b/src/Gui/KSMainWindow.cpp
index 60dbab7..e491cb4 100644
--- a/src/Gui/KSMainWindow.cpp
+++ b/src/Gui/KSMainWindow.cpp
@@ -1,339 +1,361 @@
 /*
  *  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 "KSMainWindow.h"
 #include "Config.h"
 
 #include <QDesktopServices>
 #include <QJsonArray>
 #include <QPrintDialog>
 #include <QShortcut>
 #include <QTimer>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #ifdef XCB_FOUND
 #include <QX11Info>
 #include <xcb/xcb.h>
 #endif
 
 #include <KLocalizedString>
 #include <KGuiItem>
 #include <KStandardAction>
 #include <KStandardGuiItem>
 #include <KHelpMenu>
 #include <KAboutData>
 #include <KWindowSystem>
 
 #include "SettingsDialog/SettingsDialog.h"
 #include "ExportMenu.h"
 #include "ExportManager.h"
 #include "SpectacleConfig.h"
 
+static const int DEFAULT_WINDOW_HEIGHT = 420;
+static const int DEFAULT_WINDOW_WIDTH = 840;
+static const int MAXIMUM_WINDOW_WIDTH = 1000;
+
 KSMainWindow::KSMainWindow(bool onClickAvailable, QWidget *parent) :
     QDialog(parent),
     mKSWidget(new KSWidget),
     mDivider(new QFrame),
     mDialogButtonBox(new QDialogButtonBox),
     mConfigureButton(new QToolButton),
     mToolsButton(new QPushButton),
     mSendToButton(new QPushButton),
     mClipboardButton(new QToolButton),
     mSaveButton(new QToolButton),
     mSaveMenu(new QMenu),
     mMessageWidget(new KMessageWidget),
     mToolsMenu(new QMenu),
     mExportMenu(new ExportMenu(this)),
     mOnClickAvailable(onClickAvailable)
 {
     // before we do anything, we need to set a window property
     // that skips the close/hide window animation on kwin. this
     // fixes a ghost image of the spectacle window that appears
     // on subsequent screenshots taken with the take new screenshot
     // button
     //
     // credits for this goes to Thomas Lübking <thomas.luebking@gmail.com>
 
 #ifdef XCB_FOUND
     if (KWindowSystem::isPlatformX11()) {
         // create a window if we haven't already. note that the QWidget constructor
         // should already have done this
 
         if (winId() == 0) {
             create(0, true, true);
         }
 
         // do the xcb shenanigans
 
         xcb_connection_t *xcbConn = QX11Info::connection();
         const QByteArray effectName = QByteArrayLiteral("_KDE_NET_WM_SKIP_CLOSE_ANIMATION");
 
         xcb_intern_atom_cookie_t atomCookie = xcb_intern_atom_unchecked(xcbConn, false, effectName.length(), effectName.constData());
         QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> atom(xcb_intern_atom_reply(xcbConn, atomCookie, nullptr));
         if (atom.isNull()) {
           goto done;
         }
 
         uint32_t value = 1;
         xcb_change_property(xcbConn, XCB_PROP_MODE_REPLACE, winId(), atom->atom, XCB_ATOM_CARDINAL, 32, 1, &value);
     }
 #endif
 
     done:
     QMetaObject::invokeMethod(this, "init", Qt::QueuedConnection);
 }
 
 KSMainWindow::~KSMainWindow()
 {}
 
 // GUI init
 
 void KSMainWindow::init()
 {
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     KConfigGroup guiConfig(config, "GuiConfig");
 
     // window properties
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     QPoint location = guiConfig.readEntry("window-position", QPoint(50, 50));
     move(location);
 
     // change window title on save
 
     connect(ExportManager::instance(), &ExportManager::imageSaved, this, &KSMainWindow::setScreenshotWindowTitle);
 
     // the KSGWidget
 
     connect(mKSWidget, &KSWidget::newScreenshotRequest, this, &KSMainWindow::captureScreenshot);
     connect(mKSWidget, &KSWidget::dragInitiated, this, &KSMainWindow::dragAndDropRequest);
 
     // the Button Bar
 
     mDialogButtonBox->setStandardButtons(QDialogButtonBox::Help);
 
     mConfigureButton->setDefaultAction(KStandardAction::preferences(this, SLOT(showPreferencesDialog()), this));
     mConfigureButton->setText(i18n("Configure..."));
     mConfigureButton->setToolTip(i18n("Change Spectacle's settings."));
     mConfigureButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mDialogButtonBox->addButton(mConfigureButton, QDialogButtonBox::ResetRole);
 
     KGuiItem::assign(mToolsButton, KGuiItem(i18n("Tools")));
     mToolsButton->setIcon(QIcon::fromTheme(QStringLiteral("application-menu")));
     mDialogButtonBox->addButton(mToolsButton, QDialogButtonBox::ActionRole);
     mToolsMenu->addAction(KStandardAction::print(this, SLOT(showPrintDialog()), this));
     mToolsButton->setMenu(mToolsMenu);
 
     KGuiItem::assign(mSendToButton, KGuiItem(i18n("Export")));
     mSendToButton->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
     mDialogButtonBox->addButton(mSendToButton, QDialogButtonBox::ActionRole);
 
     mClipboardButton->setDefaultAction(KStandardAction::copy(this, SLOT(sendToClipboard()), this));
     mClipboardButton->setText(i18n("Copy To Clipboard"));
     mClipboardButton->setToolTip(i18n("Copy the current screenshot image to the clipboard."));
     mClipboardButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mDialogButtonBox->addButton(mClipboardButton, QDialogButtonBox::ActionRole);
 
     mSaveButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mSaveButton->setMenu(mSaveMenu);
     mSaveButton->setPopupMode(QToolButton::MenuButtonPopup);
     buildSaveMenu();
     mDialogButtonBox->addButton(mSaveButton, QDialogButtonBox::ActionRole);
 
     // the help menu
 
     KHelpMenu *helpMenu = new KHelpMenu(this, KAboutData::applicationData(), true);
     mDialogButtonBox->button(QDialogButtonBox::Help)->setMenu(helpMenu->menu());
 
     // message widget
     connect(mMessageWidget, &KMessageWidget::linkActivated, this, [](const QString &str) { QDesktopServices::openUrl(QUrl(str)); } );
 
     // layouts
 
     mDivider->setFrameShape(QFrame::HLine);
     mDivider->setLineWidth(2);
 
     QVBoxLayout *layout = new QVBoxLayout(this);
     layout->addWidget(mKSWidget);
     layout->addWidget(mMessageWidget);
     layout->addWidget(mDivider);
     layout->addWidget(mDialogButtonBox);
     mMessageWidget->hide();
 
     // populate our send-to actions
 
     mSendToButton->setMenu(mExportMenu);
     connect(mExportMenu, &ExportMenu::imageShared, this, &KSMainWindow::showImageSharedFeedback);
 
     // disable onClick mode if not available on the platform
 
     if (!mOnClickAvailable) {
         mKSWidget->disableOnClick();
     }
-    resize(QSize(840, 420).expandedTo(minimumSize()));
+    resize(QSize(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT).expandedTo(minimumSize()));
 
 
     // done with the init
 }
 
+int KSMainWindow::windowWidth(const QPixmap &pixmap) const
+{
+    // Calculates what the width of the window should be for the captured image to perfectly fit
+    // the area reserved for the image, with the height already set.
+
+    const float pixmapAspectRatio = (float)pixmap.width() / pixmap.height();
+    const int imageHeight = mKSWidget->height() - 2 * layout()->spacing();
+    const int imageWidth = pixmapAspectRatio * imageHeight;
+
+    int alignedWindowWidth = qMin(mKSWidget->imagePaddingWidth() + imageWidth, MAXIMUM_WINDOW_WIDTH);
+    alignedWindowWidth += layout()->contentsMargins().left() + layout()->contentsMargins().right();
+    alignedWindowWidth += 2; // margins is removing 1 - 1 pixel for some reason
+
+    return alignedWindowWidth;
+}
+
 void KSMainWindow::buildSaveMenu()
 {
     // first clear the menu
     mSaveMenu->clear();
 
     // get our actions in order
     QAction *actionSave = KStandardAction::save(this, &KSMainWindow::save, this);
     QAction *actionSaveAs = KStandardAction::saveAs(this, &KSMainWindow::saveAs, this);
     QAction *actionSaveExit = new QAction(QIcon::fromTheme(QStringLiteral("document-save")), i18n("Save &&& Exit"), this);
     actionSaveExit->setToolTip(i18n("Save screenshot in your Pictures directory and exit"));
     actionSaveExit->setShortcut(QKeySequence(QKeySequence::Quit));
     connect(actionSaveExit, &QAction::triggered, this, &KSMainWindow::saveAndExit);
 
     // static or dynamic
     SpectacleConfig *cfgManager = SpectacleConfig::instance();
     int switchState = cfgManager->useDynamicSaveButton() ? cfgManager->lastUsedSaveMode() : 0;
 
     // put the actions in order
     switch (switchState) {
     case 0:
     default:
         mSaveButton->setDefaultAction(actionSaveAs);
         mSaveMenu->addAction(actionSaveExit);
         mSaveMenu->addAction(actionSave);
         break;
     case 1:
         mSaveButton->setDefaultAction(actionSave);
         mSaveMenu->addAction(actionSaveExit);
         mSaveMenu->addAction(actionSaveAs);
         break;
     case 2:
         mSaveButton->setDefaultAction(actionSaveExit);
         mSaveMenu->addAction(actionSave);
         mSaveMenu->addAction(actionSaveAs);
         break;
     }
 }
 
 // overrides
 
 void KSMainWindow::moveEvent(QMoveEvent *event)
 {
     Q_UNUSED(event);
 
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     KConfigGroup guiConfig(config, "GuiConfig");
 
     guiConfig.writeEntry("window-position", pos());
     guiConfig.sync();
 }
 
 // slots
 
 void KSMainWindow::captureScreenshot(ImageGrabber::GrabMode mode, int timeout, bool includePointer, bool includeDecorations)
 {
     hide();
     emit newScreenshotRequest(mode, timeout, includePointer, includeDecorations);
 }
 
 void KSMainWindow::setScreenshotAndShow(const QPixmap &pixmap)
 {
     mKSWidget->setScreenshotPixmap(pixmap);
     mExportMenu->imageUpdated();
 
     setWindowTitle(i18nc("Unsaved Screenshot", "Unsaved[*]"));
     setWindowModified(true);
 
     show();
+
+    resize(QSize(windowWidth(pixmap), DEFAULT_WINDOW_HEIGHT));
 }
 
 void KSMainWindow::showPrintDialog()
 {
     QPrinter *printer = new QPrinter(QPrinter::HighResolution);
     QPrintDialog printDialog(printer, this);
     if (printDialog.exec() == QDialog::Accepted) {
         ExportManager::instance()->doPrint(printer);
         return;
     }
     delete printer;
 }
 
 void KSMainWindow::showImageSharedFeedback(bool error, const QString &message)
 {
     if (error) {
         mMessageWidget->setMessageType(KMessageWidget::Error);
         mMessageWidget->setText(i18n("There was a problem sharing the image: %1", message));
         mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-error")));
     } else {
         mMessageWidget->setMessageType(KMessageWidget::Positive);
         if (message.isEmpty())
             mMessageWidget->setText(i18n("Image shared"));
         else
             mMessageWidget->setText(i18n("You can find the shared image at: <a href=\"%1\">%1</a>", message));
         mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-ok-apply")));
     }
 
     mMessageWidget->animatedShow();
     QTimer::singleShot(20000, mMessageWidget, &KMessageWidget::animatedHide);
 }
 
 void KSMainWindow::sendToClipboard()
 {
     ExportManager::instance()->doCopyToClipboard();
 
     mMessageWidget->setMessageType(KMessageWidget::Information);
     mMessageWidget->setText(i18n("The screenshot has been copied to the clipboard."));
     mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-information")));
 
     mMessageWidget->animatedShow();
     QTimer::singleShot(10000, mMessageWidget, &KMessageWidget::animatedHide);
 }
 
 void KSMainWindow::showPreferencesDialog()
 {
     SettingsDialog prefDialog(this);
     prefDialog.exec();
 }
 
 void KSMainWindow::setScreenshotWindowTitle(QUrl location)
 {
     setWindowTitle(location.fileName());
     setWindowModified(false);
 }
 
 void KSMainWindow::save()
 {
     SpectacleConfig::instance()->setLastUsedSaveMode(1);
     buildSaveMenu();
     ExportManager::instance()->doSave();
 }
 
 void KSMainWindow::saveAs()
 {
     SpectacleConfig::instance()->setLastUsedSaveMode(0);
     buildSaveMenu();
     ExportManager::instance()->doSaveAs(this);
 }
 
 void KSMainWindow::saveAndExit()
 {
     SpectacleConfig::instance()->setLastUsedSaveMode(2);
     qApp->setQuitOnLastWindowClosed(false);
     ExportManager::instance()->doSave(QUrl(), true);
     hide();
 }
diff --git a/src/Gui/KSMainWindow.h b/src/Gui/KSMainWindow.h
index 350e572..ab78f31 100644
--- a/src/Gui/KSMainWindow.h
+++ b/src/Gui/KSMainWindow.h
@@ -1,88 +1,89 @@
 /*
  *  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 KSMAINWINDOW_H
 #define KSMAINWINDOW_H
 
 #include <QDialog>
 #include <QMenu>
 #include <QFrame>
 #include <QToolButton>
 #include <QDialogButtonBox>
 
 #include <KMessageWidget>
 
 #include "PlatformBackends/ImageGrabber.h"
 #include "ExportMenu.h"
 #include "KSWidget.h"
 
 class KSMainWindow : public QDialog
 {
     Q_OBJECT
 
     public:
 
     explicit KSMainWindow(bool onClickAvailable, QWidget *parent = 0);
     ~KSMainWindow();
 
     private slots:
 
     void captureScreenshot(ImageGrabber::GrabMode mode, int timeout, bool includePointer, bool includeDecorations);
     void showPrintDialog();
     void showPreferencesDialog();
     void showImageSharedFeedback(bool error, const QString &message);
     void sendToClipboard();
     void init();
     void buildSaveMenu();
     void save();
     void saveAs();
     void saveAndExit();
+    int windowWidth(const QPixmap &pixmap) const;
 
     public slots:
 
     void setScreenshotAndShow(const QPixmap &pixmap);
     void setScreenshotWindowTitle(QUrl location);
 
     signals:
 
     void newScreenshotRequest(ImageGrabber::GrabMode mode, int timeout, bool includePointer, bool includeDecorations);
     void dragAndDropRequest();
 
     protected:
 
     void moveEvent(QMoveEvent *event) Q_DECL_OVERRIDE;
 
     private:
 
     KSWidget         *mKSWidget;
     QFrame           *mDivider;
     QDialogButtonBox *mDialogButtonBox;
     QToolButton      *mConfigureButton;
     QPushButton      *mToolsButton;
     QPushButton      *mSendToButton;
     QToolButton      *mClipboardButton;
     QToolButton      *mSaveButton;
     QMenu            *mSaveMenu;
     KMessageWidget   *mMessageWidget;
     QMenu            *mToolsMenu;
     ExportMenu       *mExportMenu;
     bool              mOnClickAvailable;
 };
 
 #endif // KSMAINWINDOW_H
diff --git a/src/Gui/KSWidget.cpp b/src/Gui/KSWidget.cpp
index 8dceab2..28612ec 100644
--- a/src/Gui/KSWidget.cpp
+++ b/src/Gui/KSWidget.cpp
@@ -1,218 +1,234 @@
 /*
  *  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 "KSWidget.h"
 
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QFormLayout>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QPushButton>
 #include <QShortcut>
 #include <QTimer>
 
 #include <KLocalizedString>
 
 #include "KSImageWidget.h"
 #include "SmartSpinBox.h"
 
 #include "SpectacleConfig.h"
 
 KSWidget::KSWidget(QWidget *parent) :
     QWidget(parent)
 {
     // get a handle to the configuration manager
 
     SpectacleConfig *configManager = SpectacleConfig::instance();
 
     // we'll init the widget that holds the image first
 
     mImageWidget = new KSImageWidget(this);
     mImageWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     connect(mImageWidget, &KSImageWidget::dragInitiated, this, &KSWidget::dragInitiated);
 
     // the capture mode options first
 
     mCaptureModeLabel = new QLabel(i18n("<b>Capture Mode</b>"), this);
 
     mCaptureArea = new QComboBox(this);
     mCaptureArea->insertItem(1, i18n("Full Screen (All Monitors)"), ImageGrabber::FullScreen);
     mCaptureArea->insertItem(2, i18n("Current Screen"), ImageGrabber::CurrentScreen);
     mCaptureArea->insertItem(3, i18n("Active Window"), ImageGrabber::ActiveWindow);
     mCaptureArea->insertItem(4, i18n("Window Under Cursor"), ImageGrabber::WindowUnderCursor);
     mCaptureArea->insertItem(5, i18n("Rectangular Region"), ImageGrabber::RectangularRegion);
     mCaptureArea->setMinimumWidth(240);
     connect(mCaptureArea, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &KSWidget::captureModeChanged);
 
     mDelayMsec = new SmartSpinBox(this);
     mDelayMsec->setDecimals(1);
     mDelayMsec->setSingleStep(1.0);
     mDelayMsec->setMinimum(0.0);
     mDelayMsec->setMaximum(999.9);
     mDelayMsec->setSpecialValueText(i18n("No Delay"));
     mDelayMsec->setMinimumWidth(160);
     connect(mDelayMsec, static_cast<void (SmartSpinBox::*)(qreal)>(&SmartSpinBox::valueChanged),
             configManager, &SpectacleConfig::setCaptureDelay);
 
     mCaptureOnClick = new QCheckBox(i18n("On Click"), this);
     mCaptureOnClick->setToolTip(i18n("Wait for a mouse click before capturing the screenshot image"));
     connect(mCaptureOnClick, &QCheckBox::stateChanged, this, &KSWidget::onClickStateChanged);
     connect(mCaptureOnClick, &QCheckBox::clicked, configManager, &SpectacleConfig::setOnClickChecked);
 
     mDelayLayout = new QHBoxLayout;
     mDelayLayout->addWidget(mDelayMsec);
     mDelayLayout->addWidget(mCaptureOnClick);
 
     mCaptureModeForm = new QFormLayout;
     mCaptureModeForm->addRow(i18n("Area:"), mCaptureArea);
     mCaptureModeForm->addRow(i18n("Delay:"), mDelayLayout);
     mCaptureModeForm->setContentsMargins(24, 0, 0, 0);
 
     // the content options (mouse pointer, window decorations)
 
     mContentOptionsLabel = new QLabel(this);
     mContentOptionsLabel->setText(i18n("<b>Content Options</b>"));
 
     mMousePointer = new QCheckBox(i18n("Include mouse pointer"), this);
     mMousePointer->setToolTip(i18n("Show the mouse cursor in the screenshot image"));
     connect(mMousePointer, &QCheckBox::clicked, configManager, &SpectacleConfig::setIncludePointerChecked);
 
     mWindowDecorations = new QCheckBox(i18n("Include window titlebar and borders"), this);
     mWindowDecorations->setToolTip(i18n("Show the window title bar, the minimize/maximize/close buttons, and the window border"));
     mWindowDecorations->setEnabled(false);
     connect(mWindowDecorations, &QCheckBox::clicked, configManager, &SpectacleConfig::setIncludeDecorationsChecked);
 
     mCaptureTransientOnly = new QCheckBox(i18n("Capture the current pop-up only"), this);
     mCaptureTransientOnly->setToolTip(i18n("Capture only the current pop-up window (like a menu, tooltip etc).\n"
                                            "If disabled, the pop-up is captured along with the parent window"));
     mCaptureTransientOnly->setEnabled(false);
     connect(mCaptureTransientOnly, &QCheckBox::clicked, configManager, &SpectacleConfig::setCaptureTransientWindowOnlyChecked);
 
     mContentOptionsForm = new QVBoxLayout;
     mContentOptionsForm->addWidget(mMousePointer);
     mContentOptionsForm->addWidget(mWindowDecorations);
     mContentOptionsForm->addWidget(mCaptureTransientOnly);
     mContentOptionsForm->setSpacing(16);
     mContentOptionsForm->setContentsMargins(24, 0, 0, 0);
 
     // the take a new screenshot button
 
     mTakeScreenshotButton = new QPushButton(i18n("Take a New Screenshot"), this);
     mTakeScreenshotButton->setIcon(QIcon::fromTheme(QStringLiteral("spectacle")));
     mTakeScreenshotButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     mTakeScreenshotButton->setFocus();
     connect(mTakeScreenshotButton, &QPushButton::clicked, this, &KSWidget::newScreenshotClicked);
 
     QShortcut *shortcut = new QShortcut(QKeySequence(QKeySequence::New), mTakeScreenshotButton);
     auto clickFunc = [&]() {
         mTakeScreenshotButton->animateClick(100);
         QTimer::singleShot(100, mTakeScreenshotButton, &QPushButton::click);
     };
     connect(shortcut, &QShortcut::activated, clickFunc);
 
     // finally, finish up the layouts
 
     mRightLayout = new QVBoxLayout;
     mRightLayout->addStretch(1);
     mRightLayout->addWidget(mCaptureModeLabel);
     mRightLayout->addSpacing(10);
     mRightLayout->addLayout(mCaptureModeForm);
     mRightLayout->addStretch(1);
     mRightLayout->addWidget(mContentOptionsLabel);
     mRightLayout->addSpacing(10);
     mRightLayout->addLayout(mContentOptionsForm);
     mRightLayout->addStretch(10);
     mRightLayout->addWidget(mTakeScreenshotButton, 1, Qt::AlignHCenter);
-    mRightLayout->setContentsMargins(20, 0, 0, 10);
+    mRightLayout->setContentsMargins(10, 0, 0, 10);
 
     mMainLayout = new QGridLayout(this);
     mMainLayout->addWidget(mImageWidget, 0, 0, 1, 1);
     mMainLayout->addLayout(mRightLayout, 0, 1, 1, 1);
-    mMainLayout->setColumnMinimumWidth(0, 400);
-    mMainLayout->setColumnMinimumWidth(1, 400);
+    mMainLayout->setColumnMinimumWidth(0, 320);
+    mMainLayout->setColumnMinimumWidth(1, 320);
 
     // and read in the saved checkbox states and capture mode indices
 
     mMousePointer->setChecked         (configManager->includePointerChecked());
     mWindowDecorations->setChecked    (configManager->includeDecorationsChecked());
     mCaptureOnClick->setChecked       (configManager->onClickChecked());
     mCaptureTransientOnly->setChecked (configManager->captureTransientWindowOnlyChecked());
     mCaptureArea->setCurrentIndex     (configManager->captureMode());
     mDelayMsec->setValue              (configManager->captureDelay());
 
     // done
 }
 
+int KSWidget::imagePaddingWidth() const
+{
+    int rightLayoutLeft = 0;
+    int rightLayoutRight = 0;
+    int mainLayoutRight = 0;
+
+    mRightLayout->getContentsMargins(&rightLayoutLeft, nullptr, &rightLayoutRight, nullptr);
+    mMainLayout->getContentsMargins(nullptr, nullptr, &mainLayoutRight, nullptr);
+
+    int paddingWidth = (rightLayoutLeft + rightLayoutRight + mainLayoutRight);
+    paddingWidth += mRightLayout->contentsRect().width();
+    paddingWidth += 2 * SpectacleImage::SHADOW_RADIUS; // image drop shadow
+
+    return paddingWidth;
+}
+
 // public slots
 
 void KSWidget::setScreenshotPixmap(const QPixmap &pixmap)
 {
     mImageWidget->setScreenshot(pixmap);
 }
 
 void KSWidget::disableOnClick()
 {
     mCaptureOnClick->setEnabled(false);
     mDelayMsec->setEnabled(true);
 }
 
 // private slots
 
 void KSWidget::newScreenshotClicked()
 {
     int delay = mCaptureOnClick->isChecked() ? -1 : (mDelayMsec->value() * 1000);
     ImageGrabber::GrabMode mode = static_cast<ImageGrabber::GrabMode>(mCaptureArea->currentData().toInt());
     if (mode == ImageGrabber::WindowUnderCursor && !(mCaptureTransientOnly->isChecked())) {
         mode = ImageGrabber::TransientWithParent;
     }
 
     emit newScreenshotRequest(mode, delay, mMousePointer->isChecked(), mWindowDecorations->isChecked());
 }
 
 void KSWidget::onClickStateChanged(int state)
 {
     if (state == Qt::Checked) {
         mDelayMsec->setEnabled(false);
     } else if (state == Qt::Unchecked) {
         mDelayMsec->setEnabled(true);
     }
 }
 
 void KSWidget::captureModeChanged(int index)
 {
     SpectacleConfig::instance()->setCaptureMode(index);
 
     ImageGrabber::GrabMode mode = static_cast<ImageGrabber::GrabMode>(mCaptureArea->itemData(index).toInt());
     switch (mode) {
     case ImageGrabber::WindowUnderCursor:
         mWindowDecorations->setEnabled(true);
         mCaptureTransientOnly->setEnabled(true);
         break;
     case ImageGrabber::ActiveWindow:
         mWindowDecorations->setEnabled(true);
         mCaptureTransientOnly->setEnabled(false);
         break;
     default:
         mWindowDecorations->setEnabled(false);
         mCaptureTransientOnly->setEnabled(false);
     }
 }
diff --git a/src/Gui/KSWidget.h b/src/Gui/KSWidget.h
index 9a73e79..11998af 100644
--- a/src/Gui/KSWidget.h
+++ b/src/Gui/KSWidget.h
@@ -1,83 +1,85 @@
 /*
  *  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 KSWIDGET_H
 #define KSWIDGET_H
 
 #include <QWidget>
 #include <QPixmap>
 
 #include "PlatformBackends/ImageGrabber.h"
 
 class QGridLayout;
 class QHBoxLayout;
 class QVBoxLayout;
 class QFormLayout;
 class QComboBox;
 class QCheckBox;
 class QLabel;
 class QPushButton;
 
 class KSImageWidget;
 class SmartSpinBox;
 
 class KSWidget : public QWidget
 {
     Q_OBJECT
 
 	public:
-    
+
     explicit KSWidget(QWidget *parent = 0);
 
+    int imagePaddingWidth() const;
+
 	signals:
 
     void dragInitiated();
     void newScreenshotRequest(ImageGrabber::GrabMode mode, int captureDelay, bool capturePointer, bool captureDecorations);
 
 	public slots:
 
     void setScreenshotPixmap(const QPixmap &pixmap);
     void disableOnClick();
 
     private slots:
 
     void newScreenshotClicked();
     void onClickStateChanged(int state);
     void captureModeChanged(int index);
 
 	private:
-    
+
     QGridLayout   *mMainLayout;
     QHBoxLayout   *mDelayLayout;
     QVBoxLayout   *mRightLayout;
     QFormLayout   *mCaptureModeForm;
     QVBoxLayout   *mContentOptionsForm;
     KSImageWidget *mImageWidget;
     QPushButton   *mTakeScreenshotButton;
     QComboBox     *mCaptureArea;
     SmartSpinBox  *mDelayMsec;
     QCheckBox     *mCaptureOnClick;
     QCheckBox     *mMousePointer;
     QCheckBox     *mWindowDecorations;
     QCheckBox     *mCaptureTransientOnly;
     QLabel        *mCaptureModeLabel;
     QLabel        *mContentOptionsLabel;
 };
 
 #endif // KSWIDGET_H