diff --git a/kcm/src/controlpanel.cpp b/kcm/src/controlpanel.cpp
index a313576..bcd3d38 100644
--- a/kcm/src/controlpanel.cpp
+++ b/kcm/src/controlpanel.cpp
@@ -1,123 +1,125 @@
 /*
  * Copyright 2013  Daniel Vrátil <dvratil@redhat.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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "controlpanel.h"
 #include "outputconfig.h"
 #include "unifiedoutputconfig.h"
 #include "debug.h"
 
 #include <QVBoxLayout>
 
 #include <kscreen/config.h>
 
 ControlPanel::ControlPanel(QWidget *parent)
     : QFrame(parent)
     , mUnifiedOutputCfg(0)
 {
     setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
     setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
     mLayout = new QVBoxLayout(this);
 }
 
 ControlPanel::~ControlPanel()
 {
 }
 
 void ControlPanel::setConfig(const KScreen::ConfigPtr &config)
 {
     qDeleteAll(mOutputConfigs);
     mOutputConfigs.clear();
     delete mUnifiedOutputCfg;
     mUnifiedOutputCfg = 0;
 
     if (mConfig) {
         mConfig->disconnect(this);
     }
 
     mConfig = config;
     connect(mConfig.data(), &KScreen::Config::outputAdded,
             this, &ControlPanel::addOutput);
     connect(mConfig.data(), &KScreen::Config::outputRemoved,
             this, &ControlPanel::removeOutput);
 
     for (const KScreen::OutputPtr &output : mConfig->outputs()) {
         addOutput(output);
     }
 }
 
 void ControlPanel::addOutput(const KScreen::OutputPtr &output)
 {
-    OutputConfig *outputCfg = new OutputConfig(output, this);
+    OutputConfig *outputCfg = new OutputConfig(this);
     outputCfg->setVisible(false);
+    outputCfg->setShowScaleOption(mConfig->supportedFeatures().testFlag(KScreen::Config::Feature::PerOutputScaling));
+    outputCfg->setOutput(output);
     connect(outputCfg, &OutputConfig::changed,
             this, &ControlPanel::changed);
 
     mLayout->addWidget(outputCfg);
     mOutputConfigs << outputCfg;
 }
 
 void ControlPanel::removeOutput(int outputId)
 {
     for (OutputConfig *outputCfg : mOutputConfigs) {
         if (outputCfg->output()->id() == outputId) {
             mOutputConfigs.removeOne(outputCfg);
             delete outputCfg;
             return;
         }
     }
 }
 
 void ControlPanel::activateOutput(const KScreen::OutputPtr &output)
 {
     // Ignore activateOutput when in unified mode
     if (mUnifiedOutputCfg) {
         return;
     }
 
     qCDebug(KSCREEN_KCM) << "Activate output" << output->id();
 
     Q_FOREACH (OutputConfig *cfg, mOutputConfigs) {
         cfg->setVisible(cfg->output()->id() == output->id());
     }
 }
 
 void ControlPanel::setUnifiedOutput(const KScreen::OutputPtr &output)
 {
     Q_FOREACH (OutputConfig *config, mOutputConfigs) {
         if (!config->output()->isConnected()) {
             continue;
         }
 
         config->setVisible(output == 0);
     }
 
     if (output.isNull()) {
         mUnifiedOutputCfg->deleteLater();
         mUnifiedOutputCfg = 0;
     } else {
         mUnifiedOutputCfg = new UnifiedOutputConfig(mConfig, this);
         mUnifiedOutputCfg->setOutput(output);
         mUnifiedOutputCfg->setVisible(true);
         mLayout->insertWidget(mLayout->count() - 2, mUnifiedOutputCfg);
         connect(mUnifiedOutputCfg, &UnifiedOutputConfig::changed,
                 this, &ControlPanel::changed);
     }
 }
diff --git a/kcm/src/outputconfig.cpp b/kcm/src/outputconfig.cpp
index 2be0e77..d7cd0d4 100644
--- a/kcm/src/outputconfig.cpp
+++ b/kcm/src/outputconfig.cpp
@@ -1,226 +1,263 @@
 /*
  * Copyright 2013  Daniel Vrátil <dvratil@redhat.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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "outputconfig.h"
 #include "resolutionslider.h"
 #include "collapsablebutton.h"
 #include "utils.h"
 #include "debug.h"
 
 #include <QtCore/QStringBuilder>
 #include <QFormLayout>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QGroupBox>
 
 #include <KLocalizedString>
 #include <QComboBox>
 
 #include <kscreen/output.h>
 #include <kscreen/edid.h>
 
 OutputConfig::OutputConfig(QWidget *parent)
     : QWidget(parent)
     , mOutput(0)
 {
 }
 
 OutputConfig::OutputConfig(const KScreen::OutputPtr &output, QWidget *parent)
     : QWidget(parent)
 {
     setOutput(output);
 }
 
 OutputConfig::~OutputConfig()
 {
 }
 
 void OutputConfig::setTitle(const QString& title)
 {
     mTitle->setText(title);
 }
 
 
 void OutputConfig::initUi()
 {
     connect(mOutput.data(), &KScreen::Output::isConnectedChanged,
             this, [=]() {
                 if (!mOutput->isConnected()) {
                     setVisible(false);
                 }
             });
 
     connect(mOutput.data(), &KScreen::Output::isEnabledChanged,
             this, [=]() {
                 mEnabled->setChecked(mOutput->isEnabled());
             });
 
     connect(mOutput.data(), &KScreen::Output::rotationChanged,
             this, [=]() {
                 const int index = mRotation->findData(mOutput->rotation());
                 mRotation->setCurrentIndex(index);
             });
 
+    connect(mOutput.data(), &KScreen::Output::scaleChanged,
+            this, [=]() {
+                const int index = mScale->findData(mOutput->scale());
+                mScale->setCurrentIndex(index);
+            });
+
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     QVBoxLayout *vbox = new QVBoxLayout(this);
     mTitle = new QLabel(this);
     mTitle->setAlignment(Qt::AlignHCenter);
     vbox->addWidget(mTitle);
 
     setTitle(Utils::outputName(mOutput));
 
     QFormLayout *formLayout = new QFormLayout();
     vbox->addLayout(formLayout);
 
     mEnabled = new QCheckBox(i18n("Enabled"), this);
     mEnabled->setChecked(mOutput->isEnabled());
     connect(mEnabled, &QCheckBox::clicked,
             this, [=](bool checked) {
                   mOutput->setEnabled(checked);
                   qCDebug(KSCREEN_KCM) << mOutput.data() << mOutput->name() << mOutput->isEnabled();
                   Q_EMIT changed();
             });
     formLayout->addRow(i18n("Display:"), mEnabled);
 
     mResolution = new ResolutionSlider(mOutput, this);
     connect(mResolution, &ResolutionSlider::resolutionChanged,
             this, &OutputConfig::slotResolutionChanged);
     formLayout->addRow(i18n("Resolution:"), mResolution);
 
     mRotation = new QComboBox(this);
     mRotation->addItem(QIcon::fromTheme(QStringLiteral("arrow-up")), i18n("Normal"), KScreen::Output::None);
     mRotation->addItem(QIcon::fromTheme(QStringLiteral("arrow-right")), i18n("90° Clockwise"), KScreen::Output::Right);
     mRotation->addItem(QIcon::fromTheme(QStringLiteral("arrow-down")), i18n("Upside Down"), KScreen::Output::Inverted);
     mRotation->addItem(QIcon::fromTheme(QStringLiteral("arrow-left")), i18n("90° Counterclockwise"), KScreen::Output::Left);
     connect(mRotation, static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
             this, &OutputConfig::slotRotationChanged);
     mRotation->setCurrentIndex(mRotation->findData(mOutput->rotation()));
 
     formLayout->addRow(i18n("Orientation:"), mRotation);
 
-    formLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum));
+    if (mShowScaleOption) {
+        mScale = new QComboBox(this);
+        mScale->addItem(i18nc("Scale multiplier, show everything at 1 times normal scale", "1x"), 1);
+        mScale->addItem(i18nc("Scale multiplier, show everything at 2 times normal scale", "2x"), 2);
+        connect(mScale, static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
+                this, &OutputConfig::slotScaleChanged);
+        mScale->setCurrentIndex(mScale->findData(mOutput->scale()));
+
+        formLayout->addRow(i18n("Scale:"), mScale);
+
+        formLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum));
+    }
 
     CollapsableButton *advancedButton = new CollapsableButton(i18n("Advanced Settings"), this);
     advancedButton->setCollapsed(true);
     vbox->addWidget(advancedButton);
 
     QWidget *advancedWidget = new QWidget(this);
     int leftMargin, topMargin, rightMargin, bottomMargin;
     advancedWidget->getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);
     advancedWidget->setContentsMargins(25, topMargin, rightMargin, bottomMargin);
     vbox->addWidget(advancedWidget);
     advancedButton->setWidget(advancedWidget);
 
     formLayout = new QFormLayout(advancedWidget);
     advancedWidget->setLayout(formLayout);
 
     mRefreshRate = new QComboBox(advancedWidget);
     mRefreshRate->addItem(i18n("Auto"), -1);
     formLayout->addRow(i18n("Refresh rate:"), mRefreshRate);
     slotResolutionChanged(mResolution->currentResolution());
     connect(mRefreshRate, static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
             this, &OutputConfig::slotRefreshRateChanged);
 
     vbox->addStretch(2);
 }
 
 void OutputConfig::setOutput(const KScreen::OutputPtr &output)
 {
     mOutput = output;
     initUi();
 }
 
 KScreen::OutputPtr OutputConfig::output() const
 {
     return mOutput;
 }
 
 
 void OutputConfig::slotResolutionChanged(const QSize &size)
 {
     // Ignore disconnected outputs
     if (!size.isValid()) {
         return;
     }
 
     KScreen::ModePtr selectedMode;
     QList<KScreen::ModePtr> modes;
     Q_FOREACH (const KScreen::ModePtr mode, mOutput->modes()) {
         if (mode->size() == size) {
             modes << mode;
             if (!selectedMode || selectedMode->refreshRate() < mode->refreshRate()) {
                 selectedMode = mode;
             }
         }
     }
 
     Q_ASSERT(selectedMode);
     mOutput->setCurrentModeId(selectedMode->id());
 
     // Don't remove the first "Auto" item - prevents ugly flicker of the combobox
     // when changing resolution
     for (int i = 1; i < mRefreshRate->count(); ++i) {
         mRefreshRate->removeItem(i);
     }
 
     for (int i = 0; i < modes.count(); i++) {
         const KScreen::ModePtr mode = modes.at(i);
         mRefreshRate->addItem(i18n("%1 Hz", QString::fromLatin1("%1").arg(mode->refreshRate(), 0, 'f', 2)), mode->id());
 
         // If selected refresh rate is other then what we consider the "Auto" value
         // - that is it's not the highest resolution - then select it, otherwise
         // we stick with "Auto"
         if (mode == selectedMode && i > 1) {
             mRefreshRate->setCurrentIndex(i);
         }
     }
 
     Q_EMIT changed();
 }
 
 void OutputConfig::slotRotationChanged(int index)
 {
     KScreen::Output::Rotation rotation =
         static_cast<KScreen::Output::Rotation>(mRotation->itemData(index).toInt());
     mOutput->setRotation(rotation);
 
     Q_EMIT changed();
 }
 
 void OutputConfig::slotRefreshRateChanged(int index)
 {
     QString modeId;
     if (index == 0) {
         // Item 0 is "Auto" - "Auto" is equal to highest refresh rate (at least
         // that's how I understand it, and since the combobox is sorted in descending
         // order, we just pick the second item from top
         modeId = mRefreshRate->itemData(1).toString();
     } else {
         modeId = mRefreshRate->itemData(index).toString();
     }
     mOutput->setCurrentModeId(modeId);
 
     Q_EMIT changed();
 }
+
+void OutputConfig::slotScaleChanged(int index)
+{
+    auto scale = mScale->itemData(index).toInt();
+    mOutput->setScale(scale);
+    Q_EMIT changed();
+}
+
+void OutputConfig::setShowScaleOption(bool showScaleOption)
+{
+    mShowScaleOption = showScaleOption;
+    if (mOutput) {
+        initUi();
+    }
+}
+
+bool OutputConfig::showScaleOption() const
+{
+    return mShowScaleOption;
+}
diff --git a/kcm/src/outputconfig.h b/kcm/src/outputconfig.h
index aebc99e..08535df 100644
--- a/kcm/src/outputconfig.h
+++ b/kcm/src/outputconfig.h
@@ -1,70 +1,76 @@
 /*
  * Copyright 2013  Daniel Vrátil <dvratil@redhat.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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef OUTPUTCONFIG_H
 #define OUTPUTCONFIG_H
 
 #include <QGroupBox>
 #include <QComboBox>
 #include <QWidget>
 
 #include <kscreen/output.h>
 
 class CollapsableButton;
 class QCheckBox;
 class ResolutionSlider;
 class QLabel;
 
 
 class OutputConfig : public QWidget
 {
     Q_OBJECT
 
   public:
     explicit OutputConfig(QWidget *parent);
     explicit OutputConfig(const KScreen::OutputPtr &output, QWidget *parent = 0);
     virtual ~OutputConfig();
 
     virtual void setOutput(const KScreen::OutputPtr &output);
     KScreen::OutputPtr output() const;
 
     void setTitle(const QString &title);
+    void setShowScaleOption(bool showScaleOption);
+    bool showScaleOption() const;
+
   protected Q_SLOTS:
     void slotResolutionChanged(const QSize &size);
     void slotRotationChanged(int index);
     void slotRefreshRateChanged(int index);
+    void slotScaleChanged(int index);
 
   Q_SIGNALS:
     void changed();
 
   protected:
     virtual void initUi();
 
   protected:
     QLabel *mTitle;
     KScreen::OutputPtr mOutput;
     QCheckBox *mEnabled;
     ResolutionSlider *mResolution;
     QComboBox *mRotation;
+    QComboBox *mScale;
     QComboBox *mRefreshRate;
+    bool mShowScaleOption  = false;
 };
 
 #endif // OUTPUTCONFIG_H
diff --git a/kcm/src/widget.cpp b/kcm/src/widget.cpp
index ceb58a7..4d525d0 100644
--- a/kcm/src/widget.cpp
+++ b/kcm/src/widget.cpp
@@ -1,481 +1,484 @@
 /*
  * Copyright (C) 2013  Daniel Vr??til <dvratil@redhat.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 "widget.h"
 #include "controlpanel.h"
 #ifdef WITH_PROFILES
 #include "profilesmodel.h"
 #endif
 #include "primaryoutputcombo.h"
 
 #include <QVBoxLayout>
 #include <QSplitter>
 #include <QLabel>
 #include <QTimer>
 #include <QtCore/qglobal.h>
 
 #include "declarative/qmloutput.h"
 #include "declarative/qmlscreen.h"
 #include "utils.h"
 #include "scalingconfig.h"
 
 #include <kscreen/output.h>
 #include <kscreen/edid.h>
 #include <kscreen/mode.h>
 #include <kscreen/config.h>
 #include <kscreen/getconfigoperation.h>
 #include <kscreen/configmonitor.h>
 
 #include <QtCore/QDir>
 #include <QStandardPaths>
 #include <KLocalizedString>
 #include <QComboBox>
 #include <QPushButton>
 #include <QQuickView>
 
 #define QML_PATH "kcm_kscreen/qml/"
 
 Widget::Widget(QWidget *parent):
     QWidget(parent),
     mScreen(0),
     mConfig(0),
     mPrevConfig(0)
 {
     qRegisterMetaType<QQuickView*>();
 
     setMinimumHeight(550);
 
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     QSplitter *splitter = new QSplitter(Qt::Vertical, this);
     layout->addWidget(splitter);
 
     mDeclarativeView = new QQuickView();
     QWidget *container = QWidget::createWindowContainer(mDeclarativeView, this);
     mDeclarativeView->setResizeMode(QQuickView::SizeRootObjectToView);
     mDeclarativeView->setMinimumHeight(280);
     container->setMinimumHeight(280);
     splitter->addWidget(container);
 
     QWidget *widget = new QWidget(this);
     splitter->addWidget(widget);
     splitter->setStretchFactor(1, 1);
     widget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
 
     QVBoxLayout *vbox = new QVBoxLayout(widget);
     const int topMargin = style()->pixelMetric(QStyle::PM_LayoutTopMargin, 0, this);
     vbox->setContentsMargins(0, topMargin, 0, 0);
     widget->setLayout(vbox);
 
     QHBoxLayout *hbox = new QHBoxLayout;
     vbox->addLayout(hbox);
 
     mPrimaryCombo = new PrimaryOutputCombo(this);
     connect(mPrimaryCombo, &PrimaryOutputCombo::changed,
             this, &Widget::changed);
     hbox->addWidget(new QLabel(i18n("Primary display:")));
     hbox->addWidget(mPrimaryCombo);
 
     hbox->addStretch();
 
 #ifdef WITH_PROFILES
     mProfilesModel = new ProfilesModel(this);
 
     connect(mProfilesModel, &ProfilesModel::modelUpdated()),
             this, &Widget::slotProfilesUpdated);
     mProfilesCombo = new QComboBox(this);
     mProfilesCombo->setModel(mProfilesModel);
     mProfilesCombo->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     hbox->addWidget(new QLabel(i18n("Active profile")));
     hbox->addWidget(mProfilesCombo);
 #endif
 
     mControlPanel = new ControlPanel(this);
     connect(mControlPanel, &ControlPanel::changed,
             this, &Widget::changed);
     vbox->addWidget(mControlPanel);
 
     mUnifyButton = new QPushButton(i18n("Unify Outputs"), this);
     connect(mUnifyButton, &QPushButton::released,
             [this]{
                 slotUnifyOutputs();
             });
 
     vbox->addWidget(mUnifyButton);
 
-    auto setScaleButton = new QPushButton(i18n("Scale Display"), this);
-    connect(setScaleButton, &QPushButton::released,
+    mScaleAllOutputsButton = new QPushButton(i18n("Scale Display"), this);
+    connect(mScaleAllOutputsButton, &QPushButton::released,
             [this] {
                 QPointer<ScalingConfig> dialog = new ScalingConfig(mConfig->outputs(), this);
                 dialog->exec();
                 delete dialog;
             });
-    
-    vbox->addWidget(setScaleButton);
+
+    vbox->addWidget(mScaleAllOutputsButton);
+
 
     mOutputTimer = new QTimer(this);
     connect(mOutputTimer, &QTimer::timeout,
             this, &Widget::clearOutputIdentifiers);
 
     loadQml();
 }
 
 Widget::~Widget()
 {
     clearOutputIdentifiers();
 }
 
 bool Widget::eventFilter(QObject* object, QEvent* event)
 {
     if (event->type() == QEvent::Resize) {
         if (mOutputIdentifiers.contains(qobject_cast<QQuickView*>(object))) {
             QResizeEvent *e = static_cast<QResizeEvent*>(event);
             const QRect screenSize = object->property("screenSize").toRect();
             QRect geometry(QPoint(0, 0), e->size());
             geometry.moveCenter(screenSize.center());
             static_cast<QQuickView*>(object)->setGeometry(geometry);
             // Pass the event further
         }
     }
 
     return QObject::eventFilter(object, event);
 }
 
 
 void Widget::setConfig(const KScreen::ConfigPtr &config)
 {
     if (mConfig) {
         KScreen::ConfigMonitor::instance()->removeConfig(mConfig);
         for (const KScreen::OutputPtr &output : mConfig->outputs()) {
             output->disconnect(this);
         }
     }
 
     mConfig = config;
     KScreen::ConfigMonitor::instance()->addConfig(mConfig);
 
     mScreen->setConfig(mConfig);
     mControlPanel->setConfig(mConfig);
     mPrimaryCombo->setConfig(mConfig);
     mUnifyButton->setEnabled(mConfig->outputs().count() > 1);
+    mScaleAllOutputsButton->setVisible(!mConfig->supportedFeatures().testFlag(KScreen::Config::Feature::PerOutputScaling));
+
 
     for (const KScreen::OutputPtr &output : mConfig->outputs()) {
         connect(output.data(), &KScreen::Output::isEnabledChanged,
                 this, &Widget::slotOutputEnabledChanged);
         connect(output.data(), &KScreen::Output::posChanged,
                 this, &Widget::changed);
     }
 
     // Select the primary (or only) output by default
     QMLOutput *qmlOutput = mScreen->primaryOutput();
     if (qmlOutput) {
         mScreen->setActiveOutput(qmlOutput);
     } else {
         if (mScreen->outputs().count() > 0) {
             mScreen->setActiveOutput(mScreen->outputs()[0]);
         }
     }
 
     slotOutputEnabledChanged();
 }
 
 KScreen::ConfigPtr Widget::currentConfig() const
 {
     return mConfig;
 }
 
 void Widget::loadQml()
 {
     qmlRegisterType<QMLOutput>("org.kde.kscreen", 1, 0, "QMLOutput");
     qmlRegisterType<QMLScreen>("org.kde.kscreen", 1, 0, "QMLScreen");
 
     qmlRegisterType<KScreen::Output>("org.kde.kscreen", 1, 0, "KScreenOutput");
     qmlRegisterType<KScreen::Edid>("org.kde.kscreen", 1, 0, "KScreenEdid");
     qmlRegisterType<KScreen::Mode>("org.kde.kscreen", 1, 0, "KScreenMode");
 
     //const QString file = QDir::currentPath() + "/main.qml";
     const QString file = QStandardPaths::locate(QStandardPaths::QStandardPaths::GenericDataLocation, QStringLiteral("kcm_kscreen/qml/main.qml"));
     mDeclarativeView->setSource(QUrl::fromLocalFile(file));
 
     QQuickItem* rootObject = mDeclarativeView->rootObject();
     mScreen = rootObject->findChild<QMLScreen*>(QStringLiteral("outputView"));
     if (!mScreen) {
         return;
     }
     mScreen->setEngine(mDeclarativeView->engine());
 
     connect(mScreen, &QMLScreen::focusedOutputChanged,
             this, &Widget::slotFocusedOutputChanged);
     connect(rootObject->findChild<QObject*>(QStringLiteral("identifyButton")), SIGNAL(clicked()),
             this, SLOT(slotIdentifyButtonClicked()));
 }
 
 void Widget::slotFocusedOutputChanged(QMLOutput *output)
 {
     mControlPanel->activateOutput(output->outputPtr());
 }
 
 void Widget::slotOutputEnabledChanged()
 {
     int enabledOutputsCnt = 0;
     Q_FOREACH (const KScreen::OutputPtr &output, mConfig->outputs()) {
         if (output->isEnabled()) {
             ++enabledOutputsCnt;
         }
 
         if (enabledOutputsCnt > 1) {
             break;
         }
     }
 
     mUnifyButton->setEnabled(enabledOutputsCnt > 1);
 }
 
 void Widget::slotUnifyOutputs()
 {
     QMLOutput *base = mScreen->primaryOutput();
     QList<int> clones;
 
     if (!base) {
         Q_FOREACH (QMLOutput *output, mScreen->outputs()) {
             if (output->output()->isConnected() && output->output()->isEnabled()) {
                 base = output;
                 break;
             }
         }
 
         if (!base) {
             // WTF?
             return;
         }
     }
 
     if (base->isCloneMode()) {
         setConfig(mPrevConfig);
         mPrevConfig.clear();
 
         mPrimaryCombo->setEnabled(true);
         mUnifyButton->setText(i18n("Unify Outputs"));
     } else {
         // Clone the current config, so that we can restore it in case user
         // breaks the cloning
         mPrevConfig = mConfig->clone();
 
         Q_FOREACH (QMLOutput *output, mScreen->outputs()) {
             if (!output->output()->isConnected()) {
                 continue;
             }
 
             if (!output->output()->isEnabled()) {
                 output->setVisible(false);
                 continue;
             }
 
             if (base == 0) {
                 base = output;
             }
 
             output->setOutputX(0);
             output->setOutputY(0);
             output->output()->setPos(QPoint(0, 0));
             output->output()->setClones(QList<int>());
 
             if (base != output) {
                 clones << output->output()->id();
                 output->setCloneOf(base);
                 output->setVisible(false);
             }
         }
 
         base->output()->setClones(clones);
         base->setIsCloneMode(true);
 
         mScreen->updateOutputsPlacement();
 
         mPrimaryCombo->setEnabled(false);
         mControlPanel->setUnifiedOutput(base->outputPtr());
 
         mUnifyButton->setText(i18n("Break Unified Outputs"));
     }
 
     Q_EMIT changed();
 }
 
 void Widget::slotProfileChanged(int index)
 {
 #ifdef WITH_PROFILES
     const QVariantMap profile = mProfilesCombo->itemData(index, ProfilesModel::ProfileRole).toMap();
     const QVariantList outputs = profile[QLatin1String("outputs")].toList();
 
     // FIXME: Copy-pasted from KDED's Serializer::config()
     KScreen::Config *config = KScreen::Config::current();
     KScreen::OutputList outputList = config->outputs();
     Q_FOREACH(KScreen::Output * output, outputList) {
         if (!output->isConnected() && output->isEnabled()) {
             output->setEnabled(false);
         }
     }
 
     KScreen::Config *outputsConfig = config->clone();
     Q_FOREACH(const QVariant & info, outputs) {
         KScreen::Output *output = findOutput(outputsConfig, info.toMap());
         if (!output) {
             continue;
         }
 
         delete outputList.take(output->id());
         outputList.insert(output->id(), output);
     }
 
     config->setOutputs(outputList);
 
     setConfig(config);
 #else
     Q_UNUSED(index)
 #endif
 }
 
 // FIXME: Copy-pasted from KDED's Serializer::findOutput()
 KScreen::OutputPtr Widget::findOutput(const KScreen::ConfigPtr &config, const QVariantMap &info)
 {
     KScreen::OutputList outputs = config->outputs();
     Q_FOREACH(const KScreen::OutputPtr &output, outputs) {
         if (!output->isConnected()) {
             continue;
         }
 
         const QString outputId = (output->edid() && output->edid()->isValid()) ? output->edid()->hash() : output->name();
         if (outputId != info[QStringLiteral("id")].toString()) {
             continue;
         }
 
         QVariantMap posInfo = info[QStringLiteral("pos")].toMap();
         QPoint point(posInfo[QStringLiteral("x")].toInt(), posInfo[QStringLiteral("y")].toInt());
         output->setPos(point);
         output->setPrimary(info[QStringLiteral("primary")].toBool());
         output->setEnabled(info[QStringLiteral("enabled")].toBool());
         output->setRotation(static_cast<KScreen::Output::Rotation>(info[QStringLiteral("rotation")].toInt()));
 
         QVariantMap modeInfo = info[QStringLiteral("mode")].toMap();
         QVariantMap modeSize = modeInfo[QStringLiteral("size")].toMap();
         QSize size(modeSize[QStringLiteral("width")].toInt(), modeSize[QStringLiteral("height")].toInt());
 
         const KScreen::ModeList modes = output->modes();
         Q_FOREACH(const KScreen::ModePtr &mode, modes) {
             if (mode->size() != size) {
                 continue;
             }
             if (QString::number(mode->refreshRate()) != modeInfo[QStringLiteral("refresh")].toString()) {
                 continue;
             }
 
             output->setCurrentModeId(mode->id());
             break;
         }
         return output;
     }
 
     return KScreen::OutputPtr();
 }
 
 void Widget::slotProfilesAboutToUpdate()
 {
 #ifdef WITH_PROFILES
     disconnect(mProfilesCombo, &QComboBox::currentIndexChanged,
                this, &Widget::slotProfileChanged);
 #endif
 }
 
 void Widget::slotProfilesUpdated()
 {
 #ifdef WITH_PROFILES
     connect(mProfilesCombo, &QComboBox::currentIndexChanged,
             this, &Widget::slotProfileChanged);
 
     const int index = mProfilesModel->activeProfileIndex();
     mProfilesCombo->setCurrentIndex(index);
 #endif
 }
 
 
 void Widget::clearOutputIdentifiers()
 {
     mOutputTimer->stop();
     qDeleteAll(mOutputIdentifiers);
     mOutputIdentifiers.clear();
 }
 
 void Widget::slotIdentifyButtonClicked(bool checked)
 {
     Q_UNUSED(checked);
     connect(new KScreen::GetConfigOperation(), &KScreen::GetConfigOperation::finished,
             this, &Widget::slotIdentifyOutputs);
 }
 
 void Widget::slotIdentifyOutputs(KScreen::ConfigOperation *op)
 {
     if (op->hasError()) {
         return;
     }
 
     const KScreen::ConfigPtr config = qobject_cast<KScreen::GetConfigOperation*>(op)->config();
 
     const QString qmlPath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral(QML_PATH "OutputIdentifier.qml"));
 
     mOutputTimer->stop();
     clearOutputIdentifiers();
 
     /* Obtain the current active configuration from KScreen */
     Q_FOREACH (const KScreen::OutputPtr &output, config->outputs()) {
         if (!output->isConnected() || !output->currentMode()) {
             continue;
         }
 
         const KScreen::ModePtr mode = output->currentMode();
 
         QQuickView *view = new QQuickView();
 
         view->setFlags(Qt::X11BypassWindowManagerHint | Qt::FramelessWindowHint);
         view->setResizeMode(QQuickView::SizeViewToRootObject);
         view->setSource(QUrl::fromLocalFile(qmlPath));
         view->installEventFilter(this);
 
         QQuickItem *rootObj = view->rootObject();
         if (!rootObj) {
             qWarning() << "Failed to obtain root item";
             continue;
         }
         QSize realSize;
         if (output->isHorizontal()) {
             realSize = mode->size();
         } else {
             realSize = QSize(mode->size().height(), mode->size().width());
         }
         rootObj->setProperty("outputName", Utils::outputName(output));
         rootObj->setProperty("modeName", Utils::sizeToString(realSize));
         view->setProperty("screenSize", QRect(output->pos(), realSize));
         mOutputIdentifiers << view;
     }
 
     Q_FOREACH (QQuickView *view, mOutputIdentifiers) {
         view->show();
     }
 
     mOutputTimer->start(2500);
 }
diff --git a/kcm/src/widget.h b/kcm/src/widget.h
index 53caa9a..326349a 100644
--- a/kcm/src/widget.h
+++ b/kcm/src/widget.h
@@ -1,102 +1,103 @@
 /*
  * Copyright (C) 2013  Daniel Vrátil <dvratil@redhat.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 WIDGET_H
 #define WIDGET_H
 
 #include <QWidget>
 #include <QVariantMap>
 
 #include <kscreen/config.h>
 
 class ProfilesModel;
 class QMLOutput;
 class QMLScreen;
 class ControlPanel;
 class PrimaryOutputCombo;
 
 class QPushButton;
 class QComboBox;
 
 class QQuickView;
 
 namespace KScreen
 {
 class ConfigOperation;
 }
 
 class Widget : public QWidget
 {
     Q_OBJECT
 
   public:
     explicit Widget(QWidget *parent = 0);
     virtual ~Widget();
 
     void setConfig(const KScreen::ConfigPtr &config);
     KScreen::ConfigPtr currentConfig() const;
 
   protected:
     bool eventFilter(QObject *object, QEvent *event) Q_DECL_OVERRIDE;
 
   Q_SIGNALS:
     void changed();
 
   private Q_SLOTS:
     void slotFocusedOutputChanged(QMLOutput *output);
 
     void slotOutputEnabledChanged();
 
     void slotUnifyOutputs();
     void slotProfileChanged(int index);
 
     void slotProfilesAboutToUpdate();
     void slotProfilesUpdated();
 
     void slotIdentifyButtonClicked(bool checked = true);
     void slotIdentifyOutputs(KScreen::ConfigOperation *op);
     void clearOutputIdentifiers();
 
   private:
     void loadQml();
     void initPrimaryCombo();
 
     KScreen::OutputPtr findOutput(const KScreen::ConfigPtr &config, const QVariantMap &info);
 
   private:
     QMLScreen *mScreen;
     KScreen::ConfigPtr mConfig;
     KScreen::ConfigPtr mPrevConfig;
 
     QQuickView *mDeclarativeView;
     ControlPanel *mControlPanel;
 
     ProfilesModel *mProfilesModel;
     PrimaryOutputCombo *mPrimaryCombo;
     QComboBox *mProfilesCombo;
 
+    QPushButton *mScaleAllOutputsButton;
     QPushButton *mUnifyButton;
     QPushButton *mSaveProfileButton;
 
     QList<QQuickView*> mOutputIdentifiers;
     QTimer *mOutputTimer;
 
 };
 
 #endif // WIDGET_H