diff --git a/kuiviewer/kuiviewer.cpp b/kuiviewer/kuiviewer.cpp
index e50321c..cf99275 100644
--- a/kuiviewer/kuiviewer.cpp
+++ b/kuiviewer/kuiviewer.cpp
@@ -1,146 +1,146 @@
 /*
  *  This file is part of the kuiviewer package
  *  Copyright (c) 2003 Richard Moore <rich@kde.org>
  *  Copyright (c) 2003 Ian Reinhart Geiser <geiseri@kde.org>
  *  Copyright (c) 2004 Benjamin C. Meyer <ben+kuiviewer@meyerhome.net>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License version 2 as published by the Free Software Foundation.
  *
  *  This library 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
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "kuiviewer.h"
 #include "kuiviewer_part.h"
 
 // KF
 #include <KActionCollection>
 #include <KStandardAction>
 #include <KPluginFactory>
 #include <KPluginLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // Qt
 #include <QObject>
 #include <QPixmap>
 #include <QUrl>
 #include <QApplication>
 #include <QAction>
 #include <QFileDialog>
 
 
 KUIViewer::KUIViewer()
     : KParts::MainWindow()
 {
     setObjectName(QStringLiteral("KUIViewer"));
 
     // setup our actions
     setupActions();
 
     setMinimumSize(300, 200);
 
     // Bring up the gui
     setupGUI();
 
     // this routine will find and load our Part.  it finds the Part by
     // name which is a bad idea usually.. but it's alright in this
     // case since our Part is made for this Shell
     KPluginFactory* factory = KPluginLoader(QStringLiteral("kuiviewerpart")).factory();
     if (factory) {
         // now that the Part is loaded, we cast it to a Part to get
         // our hands on it
         m_part = factory->create<KParts::ReadOnlyPart>(this);
 
         if (m_part) {
             m_part->setObjectName(QStringLiteral("kuiviewer_part"));
             // tell the KParts::MainWindow that this is indeed the main widget
             setCentralWidget(m_part->widget());
 
             // and integrate the part's GUI with the shell's
             createGUI(m_part);
         }
     } else {
         // if we couldn't find our Part, we exit since the Shell by
         // itself can't do anything useful
         //FIXME improve message, which Part is this referring to?
         KMessageBox::error(this, i18n("Unable to locate Kuiviewer kpart."));
         QApplication::quit();
         // we return here, cause kapp->quit() only means "exit the
         // next time we enter the event loop...
         return;
     }
 }
 
 KUIViewer::~KUIViewer()
 {
 }
 
 void KUIViewer::load(const QUrl& url)
 {
     m_part->openUrl(url);
     adjustSize();
 }
 
 void KUIViewer::setupActions()
 {
     KStandardAction::open(this, &KUIViewer::fileOpen, actionCollection());
     KStandardAction::quit(this, &KUIViewer::close, actionCollection());
 }
 
 void KUIViewer::fileOpen()
 {
     // this slot is called whenever the File->Open menu is selected,
     // the Open shortcut is pressed (usually CTRL+O) or the Open toolbar
     // button is clicked
     QUrl file_name =
         QFileDialog::getOpenFileUrl(this, QString(), QUrl(), i18n("*.ui *.UI|User Interface Files"));
 
     if (!file_name.isEmpty()) {
         // About this function, the style guide (
         // http://developer.kde.org/documentation/standards/kde/style/basics/index.html )
         // says that it should open a new window if the document is _not_
         // in its initial state.  This is what we do here..
         if (m_part->url().isEmpty()) {
             // we open the file in this window...
             load(file_name);
         } else {
             // we open the file in a new window...
             KUIViewer* newWin = new KUIViewer;
             newWin->load(file_name);
             newWin->show();
         }
     }
 }
 
 void KUIViewer::takeScreenshot(const QString& filename, int w, int h)
 {
     if (!m_part) {
         return;
     }
 
     showMinimized();
 
     if (w != -1 && h != -1) {
         // resize widget to the desired size
         m_part->widget()->setMinimumSize(w, h);
         m_part->widget()->setMaximumSize(w, h);
         m_part->widget()->repaint();
         // resize app to be as large as desired size
         adjustSize();
         // Disable the saving of the size
         setAutoSaveSettings(QStringLiteral("MainWindow"), false);
     }
 
-    QPixmap pixmap = QPixmap::grabWidget(m_part->widget());
+    const QPixmap pixmap = m_part->widget()->grab();
     pixmap.save(filename, "PNG");
 }
diff --git a/kuiviewer/kuiviewer_part.cpp b/kuiviewer/kuiviewer_part.cpp
index a6aac6a..488d395 100644
--- a/kuiviewer/kuiviewer_part.cpp
+++ b/kuiviewer/kuiviewer_part.cpp
@@ -1,215 +1,215 @@
 /*
  *  This file is part of the kuiviewer package
  *  Copyright (c) 2003 Richard Moore <rich@kde.org>
  *  Copyright (c) 2003 Ian Reinhart Geiser <geiseri@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License version 2 as published by the Free Software Foundation.
  *
  *  This library 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
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #define TRANSLATION_DOMAIN "kuiviewer"
 
 #include "kuiviewer_part.h"
 
 #include <kuiviewer_part_debug.h>
 
 // KF
 #include <KActionCollection>
 #include <KSelectAction>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <KAboutData>
 #include <KPluginFactory>
 
 // Qt
 #include <QApplication>
 #include <QClipboard>
 #include <QFile>
 #include <QFormBuilder>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QVBoxLayout>
 
 
 K_PLUGIN_FACTORY(KUIViewerPartFactory, registerPlugin<KUIViewerPart>();)
 
 KUIViewerPart::KUIViewerPart(QWidget* parentWidget,
                              QObject* parent,
                              const QVariantList& /*args*/)
     : KParts::ReadOnlyPart(parent)
 {
     // we need an instance
     KAboutData about(QStringLiteral("kuiviewerpart"),
                      i18n("KUIViewerPart"),
                      QStringLiteral("0.2"),
                      i18n("Displays Designer's UI files"),
                      KAboutLicense::LGPL);
     about.addAuthor(i18n("Richard Moore"), i18n("Original author"), QStringLiteral("rich@kde.org"));
     about.addAuthor(i18n("Ian Reinhart Geiser"), i18n("Original author"), QStringLiteral("geiseri@kde.org"));
     setComponentData(about);
 
     // this should be your custom internal widget
     m_widget = new QWidget(parentWidget);
     QVBoxLayout* widgetVBoxLayout = new QVBoxLayout(m_widget);
     widgetVBoxLayout->setMargin(0);
 
     // notify the part that this is our internal widget
     setWidget(m_widget);
 
     // set our XML-UI resource file
     setXMLFile(QStringLiteral("kuiviewer_part.rc"));
 
     m_style = actionCollection()->add<KSelectAction>(QStringLiteral("change_style"));
     m_style->setText(i18n("Style"));
     connect(m_style, static_cast<void(KSelectAction::*)(int)>(&KSelectAction::triggered),
             this, &KUIViewerPart::slotStyle);
     //m_style->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
     m_style->setEditable(false);
 
     m_styleFromConfig = KConfigGroup(KSharedConfig::openConfig(), "General").readEntry("currentWidgetStyle", QString());
 
     const QStringList styles = QStyleFactory::keys();
     m_style->setItems(QStringList(i18nc("Default style", "Default")) + styles);
     m_style->setCurrentItem(0);
 
     // empty or incorrect value  means the default value of currentWidgetStyle,
     // which leads to the Default option.
     if (!m_styleFromConfig.isEmpty()) {
         QStringList::ConstIterator it = styles.begin();
         QStringList::ConstIterator end = styles.end();
 
         // Skip the default item
         int idx = 1;
         for (; it != end; ++it, ++idx) {
             if ((*it).toLower() == m_styleFromConfig.toLower()) {
                 m_style->setCurrentItem(idx);
                 break;
             }
         }
     }
 
     m_style->setToolTip(i18n("Set the style used for the view."));
     m_style->setMenuAccelsEnabled(true);
 
     m_copy = KStandardAction::copy(this, &KUIViewerPart::slotGrab, actionCollection());
     m_copy->setText(i18n("Copy as Image"));
 
     updateActions();
 
 // Commented out to fix warning (rich)
 // slot should probably be called saveAs() for consistency with
 // KParts::ReadWritePart BTW.
 //    KStandardAction::saveAs(this, SLOT(slotSave()), actionCollection());
 }
 
 KUIViewerPart::~KUIViewerPart()
 {
 }
 
 static QStringList designerPluginPaths()
 {
     QStringList paths;
     const QStringList& libraryPaths = QApplication::libraryPaths();
     for (const auto& path : libraryPaths) {
         paths.append(path + QLatin1String("/designer"));
     }
     return paths;
 }
 
 bool KUIViewerPart::openFile()
 {
     // m_file is always local so we can use QFile on it
     QFile file(localFilePath());
     if (!file.open(QIODevice::ReadOnly)) {
         return false;
     }
 
     delete m_view;
     QFormBuilder builder;
     builder.setPluginPath(designerPluginPaths());
     m_view = builder.load(&file, m_widget);
 
     file.close();
     updateActions();
 
     if (!m_view) {
         return false;
     }
 
     m_view->show();
     slotStyle(0);
 
     return true;
 }
 
 void KUIViewerPart::updateActions()
 {
     const bool hasView = !m_view.isNull();
 
     m_style->setEnabled(hasView);
     m_copy->setEnabled(hasView);
 }
 
 void KUIViewerPart::slotStyle(int)
 {
     if (m_view.isNull()) {
         updateActions();
         return;
     }
 
     const QString styleName = m_style->currentText();
     QStyle* style = QStyleFactory::create(styleName);
     qCDebug(KUIVIEWERPART) << "Change style: " << styleName;
 
     m_widget->hide();
     QApplication::setOverrideCursor(Qt::WaitCursor);
     m_widget->setStyle(style);
 
     const QList<QWidget*> l = m_widget->findChildren<QWidget*>();
     for (int i = 0; i < l.size(); ++i) {
         l.at(i)->setStyle(style);
     }
 
     m_widget->show();
     QApplication::restoreOverrideCursor();
 
     /* the style changed, update the configuration */
     if (m_styleFromConfig != styleName) {
         KSharedConfig::Ptr cfg = KSharedConfig::openConfig();
         KConfigGroup cg(cfg, "General");
         if (m_style->currentItem() > 0) {
             /* A style different from the default */
             cg.writeEntry("currentWidgetStyle", styleName);
         } else {
             /* default style: remove the entry */
             cg.deleteEntry("currentWidgetStyle");
         }
         cfg->sync();
     }
 }
 
 void KUIViewerPart::slotGrab()
 {
     if (m_view.isNull()) {
         updateActions();
         return;
     }
 
-    QClipboard* clipboard = QApplication::clipboard();
-    clipboard->setPixmap(QPixmap::grabWidget(m_widget));
+    const QPixmap pixmap = m_widget->grab();
+    QApplication::clipboard()->setPixmap(pixmap);
 }
 
 #include "kuiviewer_part.moc"