diff --git a/plugins/extensions/imagesize/dlg_imagesize.cc b/plugins/extensions/imagesize/dlg_imagesize.cc
index f490f8a346..a41795f7f4 100644
--- a/plugins/extensions/imagesize/dlg_imagesize.cc
+++ b/plugins/extensions/imagesize/dlg_imagesize.cc
@@ -1,423 +1,426 @@
 /*
  *  dlg_imagesize.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2009 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_imagesize.h"
 
 #include <QLocale>
 #include <kis_config.h>
 
 #include <KoUnit.h>
 #include <kis_size_group.h>
 #include <klocalizedstring.h>
 
 #include <kis_filter_strategy.h>
 
 #include "kis_aspect_ratio_locker.h"
 #include "kis_acyclic_signal_connector.h"
 #include "kis_signals_blocker.h"
 
 #include "kis_double_parse_unit_spin_box.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 
-static const int maxImagePixelSize = 10000;
+static const int maxImagePixelSize = 90000;
 
 static const QString pixelStr(KoUnit::unitDescription(KoUnit::Pixel));
 static const QString percentStr(i18n("Percent (%)"));
 static const QString pixelsInchStr(i18n("Pixels/Inch"));
 static const QString pixelsCentimeterStr(i18n("Pixels/Centimeter"));
 
 const QString DlgImageSize::PARAM_PREFIX = "imagesizedlg";
 const QString DlgImageSize::PARAM_IMSIZE_UNIT = DlgImageSize::PARAM_PREFIX + "_imsizeunit";
 const QString DlgImageSize::PARAM_SIZE_UNIT = DlgImageSize::PARAM_PREFIX + "_sizeunit";
 const QString DlgImageSize::PARAM_RES_UNIT = DlgImageSize::PARAM_PREFIX + "_resunit";
 const QString DlgImageSize::PARAM_RATIO_LOCK = DlgImageSize::PARAM_PREFIX + "_ratioLock";
 const QString DlgImageSize::PARAM_PRINT_SIZE_SEPARATE = DlgImageSize::PARAM_PREFIX + "_printSizeSeparatly";
 
 DlgImageSize::DlgImageSize(QWidget *parent, int width, int height, double resolution)
     : KoDialog(parent)
 {
     setCaption(i18n("Scale To New Size"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_page = new WdgImageSize(this);
 
     Q_CHECK_PTR(m_page);
     m_page->layout()->setMargin(0);
     m_page->setObjectName("image_size");
 
     m_page->pixelFilterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     m_page->pixelFilterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formattedDescriptions());
     m_page->pixelFilterCmb->setCurrent("Bicubic");
 
     /**
      * Initialize Pixel Width and Height fields
      */
 
     m_widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
     m_heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
     KisConfig cfg(true);
 
     /// configure the unit to image length, default unit is pixel and printing units are forbidden.
     m_widthUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
     m_heightUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
 
     m_widthUnitManager->syncWithOtherUnitManager(m_heightUnitManager); //sync the two managers, so that the units will be the same, but each manager will know a different reference for percents.
 
     m_widthUnitManager->setApparentUnitFromSymbol("px"); //set unit to pixel.
 
     m_page->pixelWidthDouble->setUnitManager(m_widthUnitManager);
     m_page->pixelHeightDouble->setUnitManager(m_heightUnitManager);
+    m_page->pixelWidthDouble->setMaximum(maxImagePixelSize);
+    m_page->pixelHeightDouble->setMaximum(maxImagePixelSize);
     m_page->pixelWidthDouble->changeValue(width);
     m_page->pixelHeightDouble->changeValue(height);
     m_page->pixelWidthDouble->setDisplayUnit(false);
     m_page->pixelHeightDouble->setDisplayUnit(false);
 
     /// add custom units
 
     int unitId = m_widthUnitManager->getApparentUnitId();
 
     m_page->pixelSizeUnit->setModel(m_widthUnitManager);
     m_page->pixelSizeUnit->setCurrentIndex(unitId);
 
     /**
      * Connect Pixel Unit switching controls
      */
 
     KisAcyclicSignalConnector *pixelUnitConnector = new KisAcyclicSignalConnector(this);
     pixelUnitConnector->connectForwardInt(m_page->pixelSizeUnit, SIGNAL(currentIndexChanged(int)),
                                           m_widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
     pixelUnitConnector->connectBackwardInt(m_widthUnitManager, SIGNAL(unitChanged(int)),
                                            m_page->pixelSizeUnit, SLOT(setCurrentIndex(int)));
 
     QString imSizeUnit = cfg.readEntry<QString>(PARAM_IMSIZE_UNIT, "px");
 
     m_widthUnitManager->setApparentUnitFromSymbol(imSizeUnit);
 
     /**
      * Initialize Print Width, Height and Resolution fields
      */
 
     m_printSizeUnitManager = new KisSpinBoxUnitManager(this);
 
     m_page->printWidth->setUnitManager(m_printSizeUnitManager);
     m_page->printHeight->setUnitManager(m_printSizeUnitManager);
     m_page->printWidth->setDecimals(2);
     m_page->printHeight->setDecimals(2);
     m_page->printWidth->setDisplayUnit(false);
     m_page->printHeight->setDisplayUnit(false);
     m_page->printResolution->setDecimals(2);
     m_page->printResolution->setAlignment(Qt::AlignRight);
 
     m_page->printWidthUnit->setModel(m_printSizeUnitManager);
 
     //TODO: create a resolution dimension in the unit manager.
     m_page->printResolutionUnit->addItem(pixelsInchStr);
     m_page->printResolutionUnit->addItem(pixelsCentimeterStr);
 
 
     /**
      * Initialize labels and layout
      */
     KisSizeGroup *labelsGroup = new KisSizeGroup(this);
     labelsGroup->addWidget(m_page->lblPixelWidth);
     labelsGroup->addWidget(m_page->lblPixelHeight);
     labelsGroup->addWidget(m_page->lblPixelFilter);
     labelsGroup->addWidget(m_page->lblPrintWidth);
     labelsGroup->addWidget(m_page->lblPrintHeight);
     labelsGroup->addWidget(m_page->lblResolution);
 
     KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
     spinboxesGroup->addWidget(m_page->pixelWidthDouble);
     spinboxesGroup->addWidget(m_page->pixelHeightDouble);
     spinboxesGroup->addWidget(m_page->printWidth);
     spinboxesGroup->addWidget(m_page->printHeight);
     spinboxesGroup->addWidget(m_page->printResolution);
 
     KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
     comboboxesGroup->addWidget(m_page->pixelSizeUnit);
     comboboxesGroup->addWidget(m_page->printWidthUnit);
     comboboxesGroup->addWidget(m_page->printResolutionUnit);
     connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
     /**
      * Initialize aspect ratio buttons and lockers
      */
 
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(true);
     m_page->printAspectRatioBtn->setKeepAspectRatio(true);
     m_page->constrainProportionsCkb->setChecked(true);
 
     m_pixelSizeLocker = new KisAspectRatioLocker(this);
     m_pixelSizeLocker->connectSpinBoxes(m_page->pixelWidthDouble, m_page->pixelHeightDouble, m_page->pixelAspectRatioBtn);
 
     m_printSizeLocker = new KisAspectRatioLocker(this);
     m_printSizeLocker->connectSpinBoxes(m_page->printWidth, m_page->printHeight, m_page->printAspectRatioBtn);
 
     /**
      * Connect Keep Aspect Lock buttons
      */
 
     KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
     constrainsConnector->connectBackwardBool(
         m_page->constrainProportionsCkb, SIGNAL(toggled(bool)),
         this, SLOT(slotLockAllRatioSwitched(bool)));
 
     constrainsConnector->connectForwardBool(
         m_pixelSizeLocker, SIGNAL(aspectButtonToggled(bool)),
         this, SLOT(slotLockPixelRatioSwitched(bool)));
 
     constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
         m_printSizeLocker, SIGNAL(aspectButtonToggled(bool)),
         this, SLOT(slotLockPrintRatioSwitched(bool)));
 
     constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
         m_page->adjustPrintSizeSeparatelyCkb, SIGNAL(toggled(bool)),
         this, SLOT(slotAdjustSeparatelySwitched(bool)));
 
     /**
      * Connect Print Unit switching controls
      */
 
     KisAcyclicSignalConnector *printUnitConnector = new KisAcyclicSignalConnector(this);
     printUnitConnector->connectForwardInt(
         m_page->printWidthUnit, SIGNAL(currentIndexChanged(int)),
         m_printSizeUnitManager, SLOT(selectApparentUnitFromIndex(int)));
 
     printUnitConnector->connectBackwardInt(
         m_printSizeUnitManager, SIGNAL(unitChanged(int)),
         m_page->printWidthUnit, SLOT(setCurrentIndex(int)));
 
     /// connect resolution
     connect(m_page->printResolutionUnit, SIGNAL(currentIndexChanged(int)),
             this, SLOT(slotPrintResolutionUnitChanged()));
 
     /**
      * Create syncing connections between Pixel and Print values
      */
     KisAcyclicSignalConnector *syncConnector = new KisAcyclicSignalConnector(this);
     syncConnector->connectForwardVoid(
         m_pixelSizeLocker, SIGNAL(sliderValueChanged()),
         this, SLOT(slotSyncPixelToPrintSize()));
 
     syncConnector->connectBackwardVoid(
         m_printSizeLocker, SIGNAL(sliderValueChanged()),
         this, SLOT(slotSyncPrintToPixelSize()));
 
     syncConnector->createCoordinatedConnector()->connectBackwardVoid(
         m_page->printResolution, SIGNAL(valueChanged(double)),
         this, SLOT(slotPrintResolutionChanged()));
 
 
     /**
      * Initialize printing values from the predefined image values
      */
     QString printSizeUnit;
 
     if (QLocale().measurementSystem() == QLocale::MetricSystem) {
         printSizeUnit = "cm";
     } else { // Imperial
         printSizeUnit = "in";
     }
 
     printSizeUnit = cfg.readEntry<QString>(PARAM_SIZE_UNIT, printSizeUnit);
 
     m_printSizeUnitManager->setApparentUnitFromSymbol(printSizeUnit);
 
-    setCurrentResilutionPPI(resolution);
+    setCurrentResolutionPPI(resolution);
     slotSyncPixelToPrintSize();
 
     /**
      * Initialize aspect ratio lockers with the current proportion.
      */
     m_pixelSizeLocker->updateAspect();
     m_printSizeLocker->updateAspect();
 
     QString printResUnit = cfg.readEntry<QString>(PARAM_RES_UNIT, "");
     m_page->printResolutionUnit->setCurrentText(printResUnit);
 
     m_page->constrainProportionsCkb->setChecked(cfg.readEntry<bool>(PARAM_RATIO_LOCK, true));
     m_page->adjustPrintSizeSeparatelyCkb->setChecked(cfg.readEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, false));
 
     setMainWidget(m_page);
 }
 
 DlgImageSize::~DlgImageSize()
 {
     KisConfig cfg(false);
     cfg.writeEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, m_page->adjustPrintSizeSeparatelyCkb->isChecked());
     cfg.writeEntry<bool>(PARAM_RATIO_LOCK, m_page->constrainProportionsCkb->isChecked());
 
     cfg.writeEntry<QString>(PARAM_IMSIZE_UNIT, m_widthUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_SIZE_UNIT, m_printSizeUnitManager->getApparentUnitSymbol());
     cfg.writeEntry<QString>(PARAM_RES_UNIT, m_page->printResolutionUnit->currentText());
 
     delete m_page;
 }
 
 qint32 DlgImageSize::width()
 {
     return int(m_page->pixelWidthDouble->value());
 }
 
 qint32 DlgImageSize::height()
 {
     return int(m_page->pixelHeightDouble->value());
 }
 
 double DlgImageSize::resolution()
 {
     return currentResolutionPPI();
 }
 
 KisFilterStrategy *DlgImageSize::filterType()
 {
     KoID filterID = m_page->pixelFilterCmb->currentItem();
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
     return filter;
 }
 
 void DlgImageSize::slotSyncPrintToPixelSize()
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (!printIsSeparate) {
         KisSignalsBlocker b(m_page->pixelWidthDouble, m_page->pixelHeightDouble);
         m_page->pixelWidthDouble->changeValue(m_page->printWidth->value() * currentResolutionPPI());
         m_page->pixelHeightDouble->changeValue(m_page->printHeight->value() * currentResolutionPPI());
     } else if (m_page->pixelWidthDouble->value() != 0.0) {
-        setCurrentResilutionPPI(m_page->pixelWidthDouble->value() / m_page->printWidth->value());
+        const qreal resolution = qMax(0.001, m_page->pixelWidthDouble->value() / m_page->printWidth->value());
+        setCurrentResolutionPPI(resolution);
     }
 }
 
 void DlgImageSize::slotSyncPixelToPrintSize()
 {
     const qreal resolution = currentResolutionPPI();
     if (resolution != 0.0) {
         KisSignalsBlocker b(m_page->printWidth, m_page->printHeight);
         m_page->printWidth->changeValue(m_page->pixelWidthDouble->value() / resolution);
         m_page->printHeight->changeValue(m_page->pixelHeightDouble->value() / resolution);
     }
 }
 
 void DlgImageSize::slotPrintResolutionChanged()
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (printIsSeparate) {
         slotSyncPixelToPrintSize();
     } else {
         slotSyncPrintToPixelSize();
     }
 
     updatePrintSizeMaximum();
 }
 
 void DlgImageSize::slotPrintResolutionUnitChanged()
 {
     qreal resolution = m_page->printResolution->value();
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Centimeter));
     } else {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Inch));
     }
 
     {
         KisSignalsBlocker b(m_page->printResolution);
         m_page->printResolution->setValue(resolution);
     }
 }
 
 void DlgImageSize::slotLockPixelRatioSwitched(bool value)
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     if (!printIsSeparate) {
         m_page->printAspectRatioBtn->setKeepAspectRatio(value);
     }
     m_page->constrainProportionsCkb->setChecked(value);
 }
 
 void DlgImageSize::slotLockPrintRatioSwitched(bool value)
 {
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
     m_page->constrainProportionsCkb->setChecked(value);
 }
 
 void DlgImageSize::slotLockAllRatioSwitched(bool value)
 {
     const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
     m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
 
     if (!printIsSeparate) {
         m_page->printAspectRatioBtn->setKeepAspectRatio(value);
     }
 }
 
 void DlgImageSize::slotAdjustSeparatelySwitched(bool value)
 {
     m_page->printAspectRatioBtn->setEnabled(!value);
     m_page->printAspectRatioBtn->setKeepAspectRatio(!value ? m_page->constrainProportionsCkb->isChecked() : true);
 }
 
 qreal DlgImageSize::currentResolutionPPI() const
 {
     qreal resolution = m_page->printResolution->value();
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
     } else {
         resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Centimeter));
     }
 
     return resolution;
 }
 
-void DlgImageSize::setCurrentResilutionPPI(qreal value)
+void DlgImageSize::setCurrentResolutionPPI(qreal value)
 {
     qreal newValue = value;
 
     if (m_page->printResolutionUnit->currentText() == pixelsInchStr) {
         newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Point));
     } else {
         newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Point));
     }
 
     {
         KisSignalsBlocker b(m_page->printResolution);
         m_page->printResolution->setValue(newValue);
     }
 
     updatePrintSizeMaximum();
 }
 
 void DlgImageSize::updatePrintSizeMaximum()
 {
     const qreal value = currentResolutionPPI();
     if (value == 0.0) return;
 
     m_page->printWidth->setMaximum(maxImagePixelSize / value);
     m_page->printHeight->setMaximum(maxImagePixelSize / value);
 }
diff --git a/plugins/extensions/imagesize/dlg_imagesize.h b/plugins/extensions/imagesize/dlg_imagesize.h
index fd12777036..a842cf95d6 100644
--- a/plugins/extensions/imagesize/dlg_imagesize.h
+++ b/plugins/extensions/imagesize/dlg_imagesize.h
@@ -1,94 +1,94 @@
 /*
  *  dlg_imagesize.h -- part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2013 Juan Palacios <jpalaciosdev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef DLG_IMAGESIZE
 #define DLG_IMAGESIZE
 
 #include <KoDialog.h>
 
 class KisFilterStrategy;
 class WdgImageSize;
 class KisDocumentAwareSpinBoxUnitManager;
 class KisSpinBoxUnitManager;
 class KisAspectRatioLocker;
 
 #include "ui_wdg_imagesize.h"
 
 class WdgImageSize : public QWidget, public Ui::WdgImageSize
 {
     Q_OBJECT
 
 public:
     WdgImageSize(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class DlgImageSize: public KoDialog
 {
 
     Q_OBJECT
 
 public:
 
     static const QString PARAM_PREFIX;
     static const QString PARAM_IMSIZE_UNIT;
     static const QString PARAM_SIZE_UNIT;
     static const QString PARAM_RES_UNIT;
     static const QString PARAM_RATIO_LOCK;
     static const QString PARAM_PRINT_SIZE_SEPARATE;
 
     DlgImageSize(QWidget * parent, int width, int height, double resolution);
     ~DlgImageSize() override;
 
     qint32 width();
     qint32 height();
     double resolution();
 
     KisFilterStrategy *filterType();
 
 private Q_SLOTS:
     void slotSyncPrintToPixelSize();
     void slotSyncPixelToPrintSize();
     void slotPrintResolutionChanged();
     void slotPrintResolutionUnitChanged();
 
     void slotLockPixelRatioSwitched(bool value);
     void slotLockPrintRatioSwitched(bool value);
     void slotLockAllRatioSwitched(bool value);
     void slotAdjustSeparatelySwitched(bool value);
 
 private:
     qreal currentResolutionPPI() const;
-    void setCurrentResilutionPPI(qreal value);
+    void setCurrentResolutionPPI(qreal value);
 
     void updatePrintSizeMaximum();
 
     WdgImageSize *m_page;
 
     KisAspectRatioLocker *m_pixelSizeLocker;
     KisAspectRatioLocker *m_printSizeLocker;
 
     KisDocumentAwareSpinBoxUnitManager* m_widthUnitManager;
     KisDocumentAwareSpinBoxUnitManager* m_heightUnitManager;
     KisSpinBoxUnitManager* m_printSizeUnitManager;
 };
 
 #endif // DLG_IMAGESIZE
diff --git a/plugins/extensions/imagesize/wdg_imagesize.ui b/plugins/extensions/imagesize/wdg_imagesize.ui
index d1b5cb0229..f79ea21dcd 100644
--- a/plugins/extensions/imagesize/wdg_imagesize.ui
+++ b/plugins/extensions/imagesize/wdg_imagesize.ui
@@ -1,405 +1,405 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgImageSize</class>
  <widget class="QWidget" name="WdgImageSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>391</width>
     <height>418</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Scale To New Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupImageSize">
      <property name="title">
       <string>Pixel Dimensions</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="pixelHeightDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>100000000.000000000000000</double>
+         <double>90000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPixelWidth">
         <property name="text">
          <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblPixelFilter">
         <property name="text">
          <string>&amp;Filter:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>pixelFilterCmb</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="pixelAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblPixelHeight">
         <property name="text">
          <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="pixelWidthDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>100000000.000000000000000</double>
+         <double>90000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2" colspan="2">
        <widget class="KisCmbIDList" name="pixelFilterCmb" native="true"/>
       </item>
       <item row="0" column="3" rowspan="2">
        <widget class="QComboBox" name="pixelSizeUnit"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupPrintSize">
      <property name="title">
       <string>Print Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="1" column="1">
        <widget class="QLabel" name="lblPrintHeight">
         <property name="text">
          <string>Hei&amp;ght:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printHeight</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="printWidth">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>100000000.000000000000000</double>
+         <double>1000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPrintWidth">
         <property name="text">
          <string>Wid&amp;th:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printWidth</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="printHeight">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>100000000.000000000000000</double>
+         <double>1000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="printAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblResolution">
         <property name="text">
          <string>Resolution:</string>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="KisDoubleParseSpinBox" name="printResolution">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="3">
        <widget class="QComboBox" name="printResolutionUnit"/>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="5">
        <spacer name="horizontalSpacer_3">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3" rowspan="2">
        <widget class="QComboBox" name="printWidthUnit"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer_2">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>16</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QCheckBox" name="constrainProportionsCkb">
      <property name="toolTip">
       <string>Constrain aspect ratio</string>
      </property>
      <property name="text">
       <string>Constrain proportions</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="adjustPrintSizeSeparatelyCkb">
      <property name="text">
       <string>Adjust print size separately</string>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>30</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseUnitSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends></extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>pixelWidthDouble</tabstop>
   <tabstop>pixelSizeUnit</tabstop>
   <tabstop>pixelHeightDouble</tabstop>
   <tabstop>pixelFilterCmb</tabstop>
   <tabstop>printWidth</tabstop>
   <tabstop>printWidthUnit</tabstop>
   <tabstop>printHeight</tabstop>
   <tabstop>printResolution</tabstop>
   <tabstop>printResolutionUnit</tabstop>
   <tabstop>constrainProportionsCkb</tabstop>
   <tabstop>adjustPrintSizeSeparatelyCkb</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>