diff --git a/src/CopyInputDialog.cpp b/src/CopyInputDialog.cpp
index bc31e9b4..4913cc33 100644
--- a/src/CopyInputDialog.cpp
+++ b/src/CopyInputDialog.cpp
@@ -1,240 +1,230 @@
 /*
     Copyright 2008 by Robert Knight <robertknight@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.
 */
 
 // Own
 #include "CopyInputDialog.h"
 
 // Qt
 #include <QSortFilterProxyModel>
 
 // Konsole
 #include "ui_CopyInputDialog.h"
 
 #include <KLocalizedString>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace Konsole;
 
 CopyInputDialog::CopyInputDialog(QWidget *parent) :
     QDialog(parent)
     , _ui(nullptr)
     , _model(nullptr)
     , _masterSession(nullptr)
 {
     setWindowTitle(i18n("Copy Input"));
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     auto mainWidget = new QWidget(this);
     auto mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     mainLayout->addWidget(mainWidget);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &CopyInputDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &CopyInputDialog::reject);
     mainLayout->addWidget(buttonBox);
 
     setWindowModality(Qt::WindowModal);
 
     _ui = new Ui::CopyInputDialog();
     _ui->setupUi(mainWidget);
 
     connect(_ui->selectAllButton, &QPushButton::clicked, this,
             &Konsole::CopyInputDialog::selectAll);
     connect(_ui->deselectAllButton, &QPushButton::clicked, this,
             &Konsole::CopyInputDialog::deselectAll);
 
     _ui->filterEdit->setClearButtonEnabled(true);
     _ui->filterEdit->setFocus();
 
     _model = new CheckableSessionModel(parent);
     _model->setCheckColumn(1);
     _model->setSessions(SessionManager::instance()->sessions());
 
     auto filterProxyModel = new QSortFilterProxyModel(this);
     filterProxyModel->setDynamicSortFilter(true);
     filterProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
     filterProxyModel->setSourceModel(_model);
     filterProxyModel->setFilterKeyColumn(-1);
 
     connect(_ui->filterEdit, &QLineEdit::textChanged, filterProxyModel,
             &QSortFilterProxyModel::setFilterFixedString);
 
     _ui->sessionList->setModel(filterProxyModel);
     _ui->sessionList->setColumnHidden(0, true); // Hide number column
     _ui->sessionList->header()->hide();
 }
 
 CopyInputDialog::~CopyInputDialog()
 {
     delete _ui;
 }
 
 void CopyInputDialog::setChosenSessions(const QSet<Session *> &sessions)
 {
     QSet<Session *> checked = sessions;
     if (!_masterSession.isNull()) {
         checked.insert(_masterSession);
     }
 
     _model->setCheckedSessions(checked);
 }
 
 QSet<Session *> CopyInputDialog::chosenSessions() const
 {
     return _model->checkedSessions();
 }
 
 void CopyInputDialog::setMasterSession(Session *session)
 {
     if (!_masterSession.isNull()) {
         _model->setCheckable(_masterSession, true);
     }
 
     _model->setCheckable(session, false);
     QSet<Session *> checked = _model->checkedSessions();
     checked.insert(session);
     _model->setCheckedSessions(checked);
 
     _masterSession = session;
 }
 
 void CopyInputDialog::setSelectionChecked(bool checked)
 {
     QAbstractItemModel *model = _ui->sessionList->model();
     int rows = model->rowCount();
 
     QModelIndexList selected = _ui->sessionList->selectionModel()->selectedIndexes();
 
     if (selected.count() > 1) {
         foreach (const QModelIndex &index, selected) {
             setRowChecked(index.row(), checked);
         }
     } else {
         for (int i = 0; i < rows; i++) {
             setRowChecked(i, checked);
         }
     }
 }
 
 void CopyInputDialog::setRowChecked(int row, bool checked)
 {
     QAbstractItemModel *model = _ui->sessionList->model();
     QModelIndex index = model->index(row, _model->checkColumn());
-    if (checked) {
-        model->setData(index, static_cast<int>(Qt::Checked), Qt::CheckStateRole);
-    } else {
-        model->setData(index, static_cast<int>(Qt::Unchecked), Qt::CheckStateRole);
-    }
+    model->setData(index, static_cast<int>( checked ? Qt::Checked : Qt::Unchecked), Qt::CheckStateRole);
 }
 
 CheckableSessionModel::CheckableSessionModel(QObject *parent) :
     SessionListModel(parent),
     _checkedSessions(QSet<Session *>()),
     _fixedSessions(QSet<Session *>()),
     _checkColumn(0)
 {
 }
 
 void CheckableSessionModel::setCheckColumn(int column)
 {
     beginResetModel();
     _checkColumn = column;
     endResetModel();
 }
 
 Qt::ItemFlags CheckableSessionModel::flags(const QModelIndex &index) const
 {
     auto *session = static_cast<Session *>(index.internalPointer());
 
     if (_fixedSessions.contains(session)) {
         return SessionListModel::flags(index) & ~Qt::ItemIsEnabled;
-    } else {
-        return SessionListModel::flags(index) | Qt::ItemIsUserCheckable;
     }
+   return SessionListModel::flags(index) | Qt::ItemIsUserCheckable;
 }
 
 QVariant CheckableSessionModel::data(const QModelIndex &index, int role) const
 {
     if (role == Qt::CheckStateRole && index.column() == _checkColumn) {
         auto *session = static_cast<Session *>(index.internalPointer());
-
-        if (_checkedSessions.contains(session)) {
-            return QVariant::fromValue(static_cast<int>(Qt::Checked));
-        } else {
-            return QVariant::fromValue(static_cast<int>(Qt::Unchecked));
-        }
-    } else {
-        return SessionListModel::data(index, role);
+        return QVariant::fromValue(static_cast<int>(
+            _checkedSessions.contains(session) ? Qt::Checked : Qt::Unchecked)
+        );
     }
+    return SessionListModel::data(index, role);
 }
 
 bool CheckableSessionModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role == Qt::CheckStateRole && index.column() == _checkColumn) {
         auto *session = static_cast<Session *>(index.internalPointer());
 
         if (_fixedSessions.contains(session)) {
             return false;
         }
 
         if (value.toInt() == Qt::Checked) {
             _checkedSessions.insert(session);
         } else {
             _checkedSessions.remove(session);
         }
 
         emit dataChanged(index, index);
         return true;
-    } else {
-        return SessionListModel::setData(index, value, role);
     }
+    return SessionListModel::setData(index, value, role);
 }
 
 void CheckableSessionModel::setCheckedSessions(const QSet<Session *> &sessions)
 {
     beginResetModel();
     _checkedSessions = sessions;
     endResetModel();
 }
 
 QSet<Session *> CheckableSessionModel::checkedSessions() const
 {
     return _checkedSessions;
 }
 
 void CheckableSessionModel::setCheckable(Session *session, bool checkable)
 {
     beginResetModel();
 
     if (!checkable) {
         _fixedSessions.insert(session);
     } else {
         _fixedSessions.remove(session);
     }
 
     endResetModel();
 }
 
 void CheckableSessionModel::sessionRemoved(Session *session)
 {
     _checkedSessions.remove(session);
     _fixedSessions.remove(session);
 }