qt5: Remove "5" from class names in qt5 VCL plugin

Rename classes for the qt5 VCL plugin to no longer
contain the Qt version number "5" in them, e.g.
"Qt5Widget" -> "QtWidget".

Also, adapt some variable names and comments
accordingly.

The code will be used for an upcoming qt6 VCL plugin
as well, so a "Qt" prefix fits better than a "Qt5"
one.

Renaming the headers and source files will be done
in a separate commit to make tracking git history easier.

Change-Id: Idf422f82ca9dafbb70e9a64de9c8cfc4cc8c0909
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/122805
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>

66 files changed, 1151 insertions, 1164 deletions

diff --git a/vcl/inc/qt5/Qt5AccessibleEventListener.hxx b/vcl/inc/qt5/Qt5AccessibleEventListener.hxx
index 0fd3783eee73..5c66d816fc2a 100644
--- a/vcl/inc/qt5/Qt5AccessibleEventListener.hxx
+++ b/vcl/inc/qt5/Qt5AccessibleEventListener.hxx
@@ -17,13 +17,13 @@
 
 #include <cppuhelper/implbase.hxx>
 
-class Qt5AccessibleEventListener final
+class QtAccessibleEventListener final
     : public cppu::WeakImplHelper<css::accessibility::XAccessibleEventListener>
 {
 public:
-    Qt5AccessibleEventListener(
+    QtAccessibleEventListener(
         const css::uno::Reference<css::accessibility::XAccessible> xAccessible,
-        Qt5AccessibleWidget* pAccessibleWidget);
+        QtAccessibleWidget* pAccessibleWidget);
 
     virtual void SAL_CALL
     notifyEvent(const css::accessibility::AccessibleEventObject& aEvent) override;
@@ -32,7 +32,7 @@ public:
 
 private:
     css::uno::Reference<css::accessibility::XAccessible> m_xAccessible;
-    Qt5AccessibleWidget* m_pAccessibleWidget;
+    QtAccessibleWidget* m_pAccessibleWidget;
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/Qt5AccessibleWidget.hxx b/vcl/inc/qt5/Qt5AccessibleWidget.hxx
index 54dab2e672f5..102b5658fb28 100644
--- a/vcl/inc/qt5/Qt5AccessibleWidget.hxx
+++ b/vcl/inc/qt5/Qt5AccessibleWidget.hxx
@@ -33,23 +33,23 @@ namespace com::sun::star::accessibility
 class XAccessibleTable;
 }
 
-class Qt5Frame;
-class Qt5Widget;
-
-class Qt5AccessibleWidget final : public QObject,
-                                  public QAccessibleInterface,
-                                  public QAccessibleActionInterface,
-                                  public QAccessibleTextInterface,
-                                  public QAccessibleEditableTextInterface,
-                                  public QAccessibleTableCellInterface,
-                                  public QAccessibleTableInterface,
-                                  public QAccessibleValueInterface
+class QtFrame;
+class QtWidget;
+
+class QtAccessibleWidget final : public QObject,
+                                 public QAccessibleInterface,
+                                 public QAccessibleActionInterface,
+                                 public QAccessibleTextInterface,
+                                 public QAccessibleEditableTextInterface,
+                                 public QAccessibleTableCellInterface,
+                                 public QAccessibleTableInterface,
+                                 public QAccessibleValueInterface
 {
     Q_OBJECT
 
 public:
-    Qt5AccessibleWidget(const css::uno::Reference<css::accessibility::XAccessible> xAccessible,
-                        QObject* pObject);
+    QtAccessibleWidget(const css::uno::Reference<css::accessibility::XAccessible> xAccessible,
+                       QObject* pObject);
     QWindow* window() const override;
     int childCount() const override;
     int indexOfChild(const QAccessibleInterface* child) const override;
diff --git a/vcl/inc/qt5/Qt5Bitmap.hxx b/vcl/inc/qt5/Qt5Bitmap.hxx
index 348001d72ee5..a15deab29460 100644
--- a/vcl/inc/qt5/Qt5Bitmap.hxx
+++ b/vcl/inc/qt5/Qt5Bitmap.hxx
@@ -25,14 +25,14 @@
 
 class QImage;
 
-class Qt5Bitmap final : public SalBitmap
+class QtBitmap final : public SalBitmap
 {
     std::unique_ptr<QImage> m_pImage;
     BitmapPalette m_aPalette;
 
 public:
-    Qt5Bitmap();
-    Qt5Bitmap(const QImage& rQImage);
+    QtBitmap();
+    QtBitmap(const QImage& rQImage);
 
     const QImage* GetQImage() const { return m_pImage.get(); }
 
diff --git a/vcl/inc/qt5/Qt5Clipboard.hxx b/vcl/inc/qt5/Qt5Clipboard.hxx
index b99534f59039..69c2f7a27d9e 100644
--- a/vcl/inc/qt5/Qt5Clipboard.hxx
+++ b/vcl/inc/qt5/Qt5Clipboard.hxx
@@ -27,7 +27,7 @@
  * The first just sets the respective clipboard to the expected content from LO,
  * the latter will handle any reported changes.
  **/
-class Qt5Clipboard final
+class QtClipboard final
     : public QObject,
       public cppu::WeakComponentImplHelper<css::datatransfer::clipboard::XSystemClipboard,
                                            css::datatransfer::clipboard::XFlushableClipboard,
@@ -44,7 +44,7 @@ class Qt5Clipboard final
     // true, if LO really wants to give up clipboard ownership
     bool m_bDoClear;
 
-    // if not empty, this holds the setContents provided XTransferable or a Qt5ClipboardTransferable
+    // if not empty, this holds the setContents provided XTransferable or a QtClipboardTransferable
     css::uno::Reference<css::datatransfer::XTransferable> m_aContents;
     // the owner of the current contents, which must be informed on content change
     css::uno::Reference<css::datatransfer::clipboard::XClipboardOwner> m_aOwner;
@@ -53,7 +53,7 @@ class Qt5Clipboard final
     static bool isOwner(const QClipboard::Mode aMode);
     static bool isSupported(const QClipboard::Mode aMode);
 
-    explicit Qt5Clipboard(const OUString& aModeString, const QClipboard::Mode aMode);
+    explicit QtClipboard(const OUString& aModeString, const QClipboard::Mode aMode);
 
 private Q_SLOTS:
     void handleChanged(QClipboard::Mode mode);
@@ -63,7 +63,7 @@ signals:
     void clearClipboard();
 
 public:
-    // factory function to construct only valid Qt5Clipboard objects by name
+    // factory function to construct only valid QtClipboard objects by name
     static css::uno::Reference<css::uno::XInterface> create(const OUString& aModeString);
 
     // XServiceInfo
diff --git a/vcl/inc/qt5/Qt5Data.hxx b/vcl/inc/qt5/Qt5Data.hxx
index 1834835d3d6d..ef8ee8f6f8f1 100644
--- a/vcl/inc/qt5/Qt5Data.hxx
+++ b/vcl/inc/qt5/Qt5Data.hxx
@@ -28,13 +28,13 @@
 
 class QCursor;
 
-class VCLPLUG_QT5_PUBLIC Qt5Data final : public GenericUnixSalData
+class VCLPLUG_QT5_PUBLIC QtData final : public GenericUnixSalData
 {
     o3tl::enumarray<PointerStyle, std::unique_ptr<QCursor>> m_aCursors;
 
 public:
-    explicit Qt5Data(SalInstance* pInstance);
-    virtual ~Qt5Data() override;
+    explicit QtData(SalInstance* pInstance);
+    virtual ~QtData() override;
 
     virtual void ErrorTrapPush() override;
     virtual bool ErrorTrapPop(bool bIgnoreError = true) override;
diff --git a/vcl/inc/qt5/Qt5DragAndDrop.hxx b/vcl/inc/qt5/Qt5DragAndDrop.hxx
index c88465ab3ba6..0ca1ebfb83aa 100644
--- a/vcl/inc/qt5/Qt5DragAndDrop.hxx
+++ b/vcl/inc/qt5/Qt5DragAndDrop.hxx
@@ -16,24 +16,24 @@
 #include <com/sun/star/lang/XServiceInfo.hpp>
 #include <cppuhelper/compbase.hxx>
 
-class Qt5Frame;
+class QtFrame;
 
-class Qt5DragSource final
+class QtDragSource final
     : public cppu::WeakComponentImplHelper<css::datatransfer::dnd::XDragSource,
                                            css::lang::XInitialization, css::lang::XServiceInfo>
 {
     osl::Mutex m_aMutex;
-    Qt5Frame* m_pFrame;
+    QtFrame* m_pFrame;
     css::uno::Reference<css::datatransfer::dnd::XDragSourceListener> m_xListener;
 
 public:
-    Qt5DragSource()
+    QtDragSource()
         : WeakComponentImplHelper(m_aMutex)
         , m_pFrame(nullptr)
     {
     }
 
-    virtual ~Qt5DragSource() override;
+    virtual ~QtDragSource() override;
 
     // XDragSource
     virtual sal_Bool SAL_CALL isDragImageSupported() override;
@@ -57,14 +57,14 @@ public:
     void fire_dragEnd(sal_Int8 nAction, bool bSuccessful);
 };
 
-class Qt5DropTarget final
+class QtDropTarget final
     : public cppu::WeakComponentImplHelper<css::datatransfer::dnd::XDropTarget,
                                            css::datatransfer::dnd::XDropTargetDragContext,
                                            css::datatransfer::dnd::XDropTargetDropContext,
                                            css::lang::XInitialization, css::lang::XServiceInfo>
 {
     osl::Mutex m_aMutex;
-    Qt5Frame* m_pFrame;
+    QtFrame* m_pFrame;
     sal_Int8 m_nDropAction;
     bool m_bActive;
     sal_Int8 m_nDefaultActions;
@@ -72,8 +72,8 @@ class Qt5DropTarget final
     bool m_bDropSuccessful;
 
 public:
-    Qt5DropTarget();
-    virtual ~Qt5DropTarget() override;
+    QtDropTarget();
+    virtual ~QtDropTarget() override;
 
     // XInitialization
     virtual void SAL_CALL initialize(const css::uno::Sequence<css::uno::Any>& rArgs) override;
diff --git a/vcl/inc/qt5/Qt5FilePicker.hxx b/vcl/inc/qt5/Qt5FilePicker.hxx
index 4c59bd15b78e..ffad1acc6f2f 100644
--- a/vcl/inc/qt5/Qt5FilePicker.hxx
+++ b/vcl/inc/qt5/Qt5FilePicker.hxx
@@ -52,9 +52,9 @@ typedef ::cppu::WeakComponentImplHelper<css::frame::XTerminateListener, css::lan
                                         css::lang::XServiceInfo, css::ui::dialogs::XFilePicker3,
                                         css::ui::dialogs::XFilePickerControlAccess,
                                         css::ui::dialogs::XFolderPicker2>
-    Qt5FilePicker_Base;
+    QtFilePicker_Base;
 
-class VCLPLUG_QT5_PUBLIC Qt5FilePicker : public QObject, public Qt5FilePicker_Base
+class VCLPLUG_QT5_PUBLIC QtFilePicker : public QObject, public QtFilePicker_Base
 {
     Q_OBJECT
 
@@ -85,9 +85,9 @@ protected:
 public:
     // use non-native file dialog by default; there's no easy way to add custom widgets
     // in a generic way in the native one
-    explicit Qt5FilePicker(css::uno::Reference<css::uno::XComponentContext> const& context,
-                           QFileDialog::FileMode, bool bUseNative = false);
-    virtual ~Qt5FilePicker() override;
+    explicit QtFilePicker(css::uno::Reference<css::uno::XComponentContext> const& context,
+                          QFileDialog::FileMode, bool bUseNative = false);
+    virtual ~QtFilePicker() override;
 
     // XFilePickerNotifier
     virtual void SAL_CALL addFilePickerListener(
@@ -156,8 +156,8 @@ protected:
     void setCustomControlWidgetLayout(QGridLayout* pLayout) { m_pLayout = pLayout; }
 
 private:
-    Qt5FilePicker(const Qt5FilePicker&) = delete;
-    Qt5FilePicker& operator=(const Qt5FilePicker&) = delete;
+    QtFilePicker(const QtFilePicker&) = delete;
+    QtFilePicker& operator=(const QtFilePicker&) = delete;
 
     static QString getResString(TranslateId pRedId);
     static css::uno::Any handleGetListValue(const QComboBox* pWidget, sal_Int16 nControlAction);
diff --git a/vcl/inc/qt5/Qt5Font.hxx b/vcl/inc/qt5/Qt5Font.hxx
index 3f7520e64c4c..8c9d83c595c0 100644
--- a/vcl/inc/qt5/Qt5Font.hxx
+++ b/vcl/inc/qt5/Qt5Font.hxx
@@ -27,17 +27,17 @@
 
 #include "Qt5FontFace.hxx"
 
-class Qt5Font final : public QFont, public LogicalFontInstance
+class QtFont final : public QFont, public LogicalFontInstance
 {
     friend rtl::Reference<LogicalFontInstance>
-    Qt5FontFace::CreateFontInstance(const vcl::font::FontSelectPattern&) const;
+    QtFontFace::CreateFontInstance(const vcl::font::FontSelectPattern&) const;
 
     bool GetGlyphOutline(sal_GlyphId, basegfx::B2DPolyPolygon&, bool) const override;
     bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override;
 
     virtual hb_font_t* ImplInitHbFont() override;
 
-    explicit Qt5Font(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
+    explicit QtFont(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/Qt5FontFace.hxx b/vcl/inc/qt5/Qt5FontFace.hxx
index 19ced75acca3..2f15a26e308b 100644
--- a/vcl/inc/qt5/Qt5FontFace.hxx
+++ b/vcl/inc/qt5/Qt5FontFace.hxx
@@ -37,11 +37,11 @@ namespace vcl::font
 class FontSelectPattern;
 }
 
-class Qt5FontFace final : public PhysicalFontFace
+class QtFontFace final : public PhysicalFontFace
 {
 public:
-    static Qt5FontFace* fromQFont(const QFont& rFont);
-    static Qt5FontFace* fromQFontDatabase(const QString& aFamily, const QString& aStyle);
+    static QtFontFace* fromQFont(const QFont& rFont);
+    static QtFontFace* fromQFontDatabase(const QString& aFamily, const QString& aStyle);
     static void fillAttributesFromQFont(const QFont& rFont, FontAttributes& rFA);
 
     VCLPLUG_QT5_PUBLIC static FontWeight toFontWeight(const int nWeight);
@@ -63,8 +63,8 @@ public:
 private:
     typedef enum { Font, FontDB } FontIdType;
 
-    Qt5FontFace(const Qt5FontFace&);
-    Qt5FontFace(const FontAttributes&, const QString& rFontID, const FontIdType);
+    QtFontFace(const QtFontFace&);
+    QtFontFace(const FontAttributes&, const QString& rFontID, const FontIdType);
 
     const QString m_aFontId;
     const FontIdType m_eFontIdType;
diff --git a/vcl/inc/qt5/Qt5Frame.hxx b/vcl/inc/qt5/Qt5Frame.hxx
index 01b93ad3b825..3529c0d67c17 100644
--- a/vcl/inc/qt5/Qt5Frame.hxx
+++ b/vcl/inc/qt5/Qt5Frame.hxx
@@ -48,13 +48,13 @@
 #undef Unsorted
 #endif
 
-class Qt5DragSource;
-class Qt5DropTarget;
-class Qt5Graphics;
-class Qt5Instance;
-class Qt5MainWindow;
-class Qt5Menu;
-class Qt5SvpGraphics;
+class QtDragSource;
+class QtDropTarget;
+class QtGraphics;
+class QtInstance;
+class QtMainWindow;
+class QtMenu;
+class QtSvpGraphics;
 
 class QDragMoveEvent;
 class QDropEvent;
@@ -64,33 +64,33 @@ class QPaintDevice;
 class QScreen;
 class QWidget;
 
-class VCLPLUG_QT5_PUBLIC Qt5Frame : public QObject, public SalFrame
+class VCLPLUG_QT5_PUBLIC QtFrame : public QObject, public SalFrame
 {
     Q_OBJECT
 
-    friend class Qt5Widget;
+    friend class QtWidget;
 
     QWidget* m_pQWidget;
-    Qt5MainWindow* m_pTopLevel;
+    QtMainWindow* m_pTopLevel;
 
     const bool m_bUseCairo;
     std::unique_ptr<QImage> m_pQImage;
-    std::unique_ptr<Qt5Graphics> m_pQt5Graphics;
+    std::unique_ptr<QtGraphics> m_pQtGraphics;
     UniqueCairoSurface m_pSurface;
-    std::unique_ptr<Qt5SvpGraphics> m_pSvpGraphics;
+    std::unique_ptr<QtSvpGraphics> m_pSvpGraphics;
     DamageHandler m_aDamageHandler;
     QRegion m_aRegion;
     bool m_bNullRegion;
 
     bool m_bGraphicsInUse;
     SalFrameStyleFlags m_nStyle;
-    Qt5Frame* m_pParent;
+    QtFrame* m_pParent;
     PointerStyle m_ePointerStyle;
 
     SystemEnvData m_aSystemData;
 
-    Qt5DragSource* m_pDragSource;
-    Qt5DropTarget* m_pDropTarget;
+    QtDragSource* m_pDragSource;
+    QtDropTarget* m_pDropTarget;
     bool m_bInDrag;
 
     bool m_bDefaultSize;
@@ -131,11 +131,11 @@ class VCLPLUG_QT5_PUBLIC Qt5Frame : public QObject, public SalFrame
     void fixICCCMwindowGroup();
 
 public:
-    Qt5Frame(Qt5Frame* pParent, SalFrameStyleFlags nSalFrameStyle, bool bUseCairo);
-    virtual ~Qt5Frame() override;
+    QtFrame(QtFrame* pParent, SalFrameStyleFlags nSalFrameStyle, bool bUseCairo);
+    virtual ~QtFrame() override;
 
     QWidget* GetQWidget() const { return m_pQWidget; }
-    Qt5MainWindow* GetTopLevelWindow() const { return m_pTopLevel; }
+    QtMainWindow* GetTopLevelWindow() const { return m_pTopLevel; }
     QWidget* asChild() const;
     qreal devicePixelRatioF() const;
 
@@ -152,10 +152,10 @@ public:
     virtual void SetMenu(SalMenu* pMenu) override;
     virtual void DrawMenuBar() override;
 
-    virtual void registerDragSource(Qt5DragSource* pDragSource);
-    virtual void deregisterDragSource(Qt5DragSource const* pDragSource);
-    virtual void registerDropTarget(Qt5DropTarget* pDropTarget);
-    virtual void deregisterDropTarget(Qt5DropTarget const* pDropTarget);
+    virtual void registerDragSource(QtDragSource* pDragSource);
+    virtual void deregisterDragSource(QtDragSource const* pDragSource);
+    virtual void registerDropTarget(QtDropTarget* pDropTarget);
+    virtual void deregisterDropTarget(QtDropTarget const* pDropTarget);
 
     void handleDragLeave();
     void handleDragMove(QDragMoveEvent* pEvent);
@@ -213,13 +213,13 @@ public:
     inline bool isPopup() const;
 };
 
-inline bool Qt5Frame::CallCallback(SalEvent nEvent, const void* pEvent) const
+inline bool QtFrame::CallCallback(SalEvent nEvent, const void* pEvent) const
 {
     SolarMutexGuard aGuard;
     return SalFrame::CallCallback(nEvent, pEvent);
 }
 
-inline bool Qt5Frame::isPopup() const
+inline bool QtFrame::isPopup() const
 {
     return ((m_nStyle & SalFrameStyleFlags::FLOAT)
             && !(m_nStyle & SalFrameStyleFlags::OWNERDRAWDECORATION));
diff --git a/vcl/inc/qt5/Qt5Graphics.hxx b/vcl/inc/qt5/Qt5Graphics.hxx
index c58ccbaa4e21..bd459082548e 100644
--- a/vcl/inc/qt5/Qt5Graphics.hxx
+++ b/vcl/inc/qt5/Qt5Graphics.hxx
@@ -34,16 +34,16 @@
 class PhysicalFontCollection;
 class QImage;
 class QPushButton;
-class Qt5Font;
-class Qt5FontFace;
-class Qt5Frame;
-class Qt5Painter;
+class QtFont;
+class QtFontFace;
+class QtFrame;
+class QtPainter;
 
-class Qt5GraphicsBackend final : public SalGraphicsImpl, public Qt5GraphicsBase
+class QtGraphicsBackend final : public SalGraphicsImpl, public QtGraphicsBase
 {
-    friend class Qt5Painter;
+    friend class QtPainter;
 
-    Qt5Frame* m_pFrame;
+    QtFrame* m_pFrame;
     QImage* m_pQImage;
     QRegion m_aClipRegion;
     QPainterPath m_aClipPath;
@@ -52,8 +52,8 @@ class Qt5GraphicsBackend final : public SalGraphicsImpl, public Qt5GraphicsBase
     QPainter::CompositionMode m_eCompositionMode;
 
 public:
-    Qt5GraphicsBackend(Qt5Frame* pFrame, QImage* pQImage);
-    ~Qt5GraphicsBackend() override;
+    QtGraphicsBackend(QtFrame* pFrame, QImage* pQImage);
+    ~QtGraphicsBackend() override;
 
     void Init() override {}
 
@@ -161,33 +161,33 @@ private:
     void drawScaledImage(const SalTwoRect& rPosAry, const QImage& rImage);
 };
 
-class Qt5Graphics final : public SalGraphicsAutoDelegateToImpl, public Qt5GraphicsBase
+class QtGraphics final : public SalGraphicsAutoDelegateToImpl, public QtGraphicsBase
 {
-    friend class Qt5Bitmap;
+    friend class QtBitmap;
 
-    std::unique_ptr<Qt5GraphicsBackend> m_pBackend;
+    std::unique_ptr<QtGraphicsBackend> m_pBackend;
 
-    Qt5Frame* m_pFrame;
+    QtFrame* m_pFrame;
 
-    rtl::Reference<Qt5Font> m_pTextStyle[MAX_FALLBACK];
+    rtl::Reference<QtFont> m_pTextStyle[MAX_FALLBACK];
     Color m_aTextColor;
 
-    Qt5Graphics(Qt5Frame* pFrame, QImage* pQImage);
+    QtGraphics(QtFrame* pFrame, QImage* pQImage);
 
     void drawScaledImage(const SalTwoRect& rPosAry, const QImage& rImage);
 
     void handleDamage(const tools::Rectangle&) override;
 
 public:
-    Qt5Graphics(Qt5Frame* pFrame)
-        : Qt5Graphics(pFrame, nullptr)
+    QtGraphics(QtFrame* pFrame)
+        : QtGraphics(pFrame, nullptr)
     {
     }
-    Qt5Graphics(QImage* pQImage)
-        : Qt5Graphics(nullptr, pQImage)
+    QtGraphics(QImage* pQImage)
+        : QtGraphics(nullptr, pQImage)
     {
     }
-    virtual ~Qt5Graphics() override;
+    virtual ~QtGraphics() override;
 
     QImage* getQImage() { return m_pBackend->getQImage(); }
 
diff --git a/vcl/inc/qt5/Qt5GraphicsBase.hxx b/vcl/inc/qt5/Qt5GraphicsBase.hxx
index 91b8bfb20e9e..73c39fb5ba80 100644
--- a/vcl/inc/qt5/Qt5GraphicsBase.hxx
+++ b/vcl/inc/qt5/Qt5GraphicsBase.hxx
@@ -11,12 +11,12 @@
 
 #include <QtWidgets/QApplication>
 
-class Qt5GraphicsBase
+class QtGraphicsBase
 {
     qreal m_fDPR;
 
 public:
-    Qt5GraphicsBase()
+    QtGraphicsBase()
         : m_fDPR(qApp ? qApp->devicePixelRatio() : 1.0)
     {
     }
diff --git a/vcl/inc/qt5/Qt5Graphics_Controls.hxx b/vcl/inc/qt5/Qt5Graphics_Controls.hxx
index 515cae7be70b..17039f9d6038 100644
--- a/vcl/inc/qt5/Qt5Graphics_Controls.hxx
+++ b/vcl/inc/qt5/Qt5Graphics_Controls.hxx
@@ -31,16 +31,16 @@
 #include <QtWidgets/QStyle>
 #include <QtWidgets/QStyleOption>
 
-class Qt5GraphicsBase;
+class QtGraphicsBase;
 
-class Qt5Graphics_Controls final : public vcl::WidgetDrawInterface
+class QtGraphics_Controls final : public vcl::WidgetDrawInterface
 {
     std::unique_ptr<QImage> m_image;
     QRect m_lastPopupRect;
-    Qt5GraphicsBase const& m_rGraphics;
+    QtGraphicsBase const& m_rGraphics;
 
 public:
-    Qt5Graphics_Controls(const Qt5GraphicsBase& rGraphics);
+    QtGraphics_Controls(const QtGraphicsBase& rGraphics);
 
     QImage* getImage() { return m_image.get(); }
 
diff --git a/vcl/inc/qt5/Qt5Instance.hxx b/vcl/inc/qt5/Qt5Instance.hxx
index dc347021b9bb..c895e1e0cd00 100644
--- a/vcl/inc/qt5/Qt5Instance.hxx
+++ b/vcl/inc/qt5/Qt5Instance.hxx
@@ -35,7 +35,7 @@
 
 #include "Qt5FilePicker.hxx"
 
-class Qt5Timer;
+class QtTimer;
 
 class QApplication;
 class SalYieldMutex;
@@ -47,15 +47,15 @@ struct StdFreeCStr
 };
 using FreeableCStr = std::unique_ptr<char[], StdFreeCStr>;
 
-class VCLPLUG_QT5_PUBLIC Qt5Instance : public QObject,
-                                       public SalGenericInstance,
-                                       public SalUserEventList
+class VCLPLUG_QT5_PUBLIC QtInstance : public QObject,
+                                      public SalGenericInstance,
+                                      public SalUserEventList
 {
     Q_OBJECT
 
     osl::Condition m_aWaitingYieldCond;
     const bool m_bUseCairo;
-    Qt5Timer* m_pTimer;
+    QtTimer* m_pTimer;
     bool m_bSleeping;
     std::unordered_map<OUString, css::uno::Reference<css::uno::XInterface>> m_aClipboards;
 
@@ -80,7 +80,7 @@ Q_SIGNALS:
     void deleteObjectLaterSignal(QObject* pObject);
 
 protected:
-    virtual rtl::Reference<Qt5FilePicker>
+    virtual rtl::Reference<QtFilePicker>
     createPicker(css::uno::Reference<css::uno::XComponentContext> const& context,
                  QFileDialog::FileMode);
     bool useCairo() const { return m_bUseCairo; }
@@ -88,8 +88,8 @@ protected:
     OUString constructToolkitID(std::u16string_view sTKname);
 
 public:
-    explicit Qt5Instance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo = false);
-    virtual ~Qt5Instance() override;
+    explicit QtInstance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo = false);
+    virtual ~QtInstance() override;
 
     // handle common SalInstance setup
     static void AllocFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
diff --git a/vcl/inc/qt5/Qt5MainWindow.hxx b/vcl/inc/qt5/Qt5MainWindow.hxx
index 7eb968a63c5a..ec5c9058636b 100644
--- a/vcl/inc/qt5/Qt5MainWindow.hxx
+++ b/vcl/inc/qt5/Qt5MainWindow.hxx
@@ -24,17 +24,17 @@
 
 #include "Qt5Frame.hxx"
 
-class Qt5MainWindow final : public QMainWindow
+class QtMainWindow final : public QMainWindow
 {
     Q_OBJECT
 
-    Qt5Frame& m_rFrame;
+    QtFrame& m_rFrame;
 
     virtual void closeEvent(QCloseEvent* pEvent) override;
     void moveEvent(QMoveEvent*) override;
 
 public:
-    Qt5MainWindow(Qt5Frame& rFrame, Qt::WindowFlags f = Qt::WindowFlags());
+    QtMainWindow(QtFrame& rFrame, Qt::WindowFlags f = Qt::WindowFlags());
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/Qt5Menu.hxx b/vcl/inc/qt5/Qt5Menu.hxx
index 2e5434f4db74..55275ae6e099 100644
--- a/vcl/inc/qt5/Qt5Menu.hxx
+++ b/vcl/inc/qt5/Qt5Menu.hxx
@@ -21,33 +21,33 @@ class QActionGroup;
 class QPushButton;
 class QMenu;
 class QMenuBar;
-class Qt5MenuItem;
-class Qt5Frame;
+class QtMenuItem;
+class QtFrame;
 
 /*
- * Qt5Menu can represent
+ * QtMenu can represent
  * (1) the top-level menu of a menubar, in which case 'mbMenuBar' is true and
  *     'mpQMenuBar' refers to the corresponding QMenuBar
  * (2) another kind of menu (like a PopupMenu), in which case the corresponding QMenu
- *     object is instantiated and owned by this Qt5Menu (held in 'mpOwnedQMenu').
+ *     object is instantiated and owned by this QtMenu (held in 'mpOwnedQMenu').
  * (3) a "submenu" in an existing menu (like (1)), in which case the corresponding
- *     QMenu object is owned by the corresponding Qt5MenuItem.
+ *     QMenu object is owned by the corresponding QtMenuItem.
  *
  * For (2) and (3), member 'mpQMenu' points to the corresponding QMenu object.
  */
-class Qt5Menu : public QObject, public SalMenu
+class QtMenu : public QObject, public SalMenu
 {
     Q_OBJECT
 private:
-    std::vector<Qt5MenuItem*> maItems;
+    std::vector<QtMenuItem*> maItems;
     VclPtr<Menu> mpVCLMenu;
-    Qt5Menu* mpParentSalMenu;
-    Qt5Frame* mpFrame;
+    QtMenu* mpParentSalMenu;
+    QtFrame* mpFrame;
     bool mbMenuBar;
     QMenuBar* mpQMenuBar;
-    // self-created QMenu that this Qt5Menu represents, if applicable (s. comment for class)
+    // self-created QMenu that this QtMenu represents, if applicable (s. comment for class)
     std::unique_ptr<QMenu> mpOwnedQMenu;
-    // pointer to QMenu owned by the corresponding Qt5MenuItem or self (-> mpOwnedQMenu)
+    // pointer to QMenu owned by the corresponding QtMenuItem or self (-> mpOwnedQMenu)
     QMenu* mpQMenu;
     QPushButton* mpCloseButton;
     QMetaObject::Connection maCloseButtonConnection;
@@ -55,14 +55,14 @@ private:
     void DoFullMenuUpdate(Menu* pMenuBar);
     static void NativeItemText(OUString& rItemText);
 
-    void InsertMenuItem(Qt5MenuItem* pSalMenuItem, unsigned nPos);
+    void InsertMenuItem(QtMenuItem* pSalMenuItem, unsigned nPos);
 
     void ReinitializeActionGroup(unsigned nPos);
     void ResetAllActionGroups();
-    void UpdateActionGroupItem(const Qt5MenuItem* pSalMenuItem);
+    void UpdateActionGroupItem(const QtMenuItem* pSalMenuItem);
 
 public:
-    Qt5Menu(bool bMenuBar);
+    QtMenu(bool bMenuBar);
 
     virtual bool VisibleMenuBar() override; // must return TRUE to actually DISPLAY native menu bars
 
@@ -70,11 +70,11 @@ public:
     virtual void RemoveItem(unsigned nPos) override;
     virtual void SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned nPos) override;
     virtual void SetFrame(const SalFrame* pFrame) override;
-    const Qt5Frame* GetFrame() const;
+    const QtFrame* GetFrame() const;
     virtual void ShowMenuBar(bool bVisible) override;
     virtual bool ShowNativePopupMenu(FloatingWindow* pWin, const tools::Rectangle& rRect,
                                      FloatWinPopupFlags nFlags) override;
-    Qt5Menu* GetTopLevel();
+    QtMenu* GetTopLevel();
     virtual void SetItemBits(unsigned nPos, MenuItemBits nBits) override;
     virtual void CheckItem(unsigned nPos, bool bCheck) override;
     virtual void EnableItem(unsigned nPos, bool bEnable) override;
@@ -91,24 +91,24 @@ public:
     void SetMenu(Menu* pMenu) { mpVCLMenu = pMenu; }
     Menu* GetMenu() { return mpVCLMenu; }
     unsigned GetItemCount() const { return maItems.size(); }
-    Qt5MenuItem* GetItemAtPos(unsigned nPos) { return maItems[nPos]; }
+    QtMenuItem* GetItemAtPos(unsigned nPos) { return maItems[nPos]; }
 
 private slots:
-    static void slotMenuTriggered(Qt5MenuItem* pQItem);
-    static void slotMenuAboutToShow(Qt5MenuItem* pQItem);
-    static void slotMenuAboutToHide(Qt5MenuItem* pQItem);
+    static void slotMenuTriggered(QtMenuItem* pQItem);
+    static void slotMenuAboutToShow(QtMenuItem* pQItem);
+    static void slotMenuAboutToHide(QtMenuItem* pQItem);
     void slotCloseDocument();
 };
 
-class Qt5MenuItem : public SalMenuItem
+class QtMenuItem : public SalMenuItem
 {
 public:
-    Qt5MenuItem(const SalItemParams*);
+    QtMenuItem(const SalItemParams*);
 
     QAction* getAction() const;
 
-    Qt5Menu* mpParentMenu; // The menu into which this menu item is inserted
-    Qt5Menu* mpSubMenu; // Submenu of this item (if defined)
+    QtMenu* mpParentMenu; // The menu into which this menu item is inserted
+    QtMenu* mpSubMenu; // Submenu of this item (if defined)
     std::unique_ptr<QAction> mpAction; // action corresponding to this item
     std::unique_ptr<QMenu> mpMenu; // menu corresponding to this item
     std::shared_ptr<QActionGroup> mpActionGroup; // empty if it's a separator element
diff --git a/vcl/inc/qt5/Qt5Object.hxx b/vcl/inc/qt5/Qt5Object.hxx
index 9380cc57a75a..328946e4388e 100644
--- a/vcl/inc/qt5/Qt5Object.hxx
+++ b/vcl/inc/qt5/Qt5Object.hxx
@@ -26,24 +26,24 @@
 #include <QtGui/QRegion>
 #include <QtGui/QWindow>
 
-class Qt5Frame;
+class QtFrame;
 class QWidget;
 
-class Qt5Object final : public QObject, public SalObject
+class QtObject final : public QObject, public SalObject
 {
     Q_OBJECT
 
     SystemEnvData m_aSystemData;
-    Qt5Frame* m_pParent;
+    QtFrame* m_pParent;
     QWidget* m_pQWidget; // main widget, container
     QWindow* m_pQWindow; // contained window, used for opengl rendering
     QRegion m_pRegion;
 
 public:
-    Qt5Object(Qt5Frame* pParent, bool bShow);
-    ~Qt5Object() override;
+    QtObject(QtFrame* pParent, bool bShow);
+    ~QtObject() override;
 
-    Qt5Frame* frame() const { return m_pParent; }
+    QtFrame* frame() const { return m_pParent; }
     QWidget* widget() const { return m_pQWidget; }
     QWindow* windowHandle() const { return m_pQWindow; }
 
@@ -62,20 +62,20 @@ public:
     virtual const SystemEnvData* GetSystemData() const override { return &m_aSystemData; }
 };
 
-class Qt5ObjectWindow final : public QWindow
+class QtObjectWindow final : public QWindow
 {
-    Qt5Object& m_rParent;
+    QtObject& m_rParent;
 
     bool event(QEvent*) override;
     void focusInEvent(QFocusEvent*) override;
     void focusOutEvent(QFocusEvent*) override;
     void mousePressEvent(QMouseEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
-    // keyPressEvent(QKeyEvent*) is handled via event(QEvent*); see comment in Qt5Widget::event
+    // keyPressEvent(QKeyEvent*) is handled via event(QEvent*); see comment in QtWidget::event
     void keyReleaseEvent(QKeyEvent*) override;
 
 public:
-    explicit Qt5ObjectWindow(Qt5Object& rParent);
+    explicit QtObjectWindow(QtObject& rParent);
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/Qt5OpenGLContext.hxx b/vcl/inc/qt5/Qt5OpenGLContext.hxx
index df5424620bf3..8036d50777b9 100644
--- a/vcl/inc/qt5/Qt5OpenGLContext.hxx
+++ b/vcl/inc/qt5/Qt5OpenGLContext.hxx
@@ -24,7 +24,7 @@
 class QWindow;
 class QOpenGLContext;
 
-class Qt5OpenGLContext final : public OpenGLContext
+class QtOpenGLContext final : public OpenGLContext
 {
 public:
     virtual void initWindow() override;
diff --git a/vcl/inc/qt5/Qt5Painter.hxx b/vcl/inc/qt5/Qt5Painter.hxx
index ff3b22595144..803c05ecc071 100644
--- a/vcl/inc/qt5/Qt5Painter.hxx
+++ b/vcl/inc/qt5/Qt5Painter.hxx
@@ -26,15 +26,15 @@
 #include "Qt5Frame.hxx"
 #include "Qt5Graphics.hxx"
 
-class Qt5Painter final : public QPainter
+class QtPainter final : public QPainter
 {
-    Qt5GraphicsBackend& m_rGraphics;
+    QtGraphicsBackend& m_rGraphics;
     QRegion m_aRegion;
 
 public:
-    Qt5Painter(Qt5GraphicsBackend& rGraphics, bool bPrepareBrush = false,
-               sal_uInt8 nTransparency = 255);
-    ~Qt5Painter()
+    QtPainter(QtGraphicsBackend& rGraphics, bool bPrepareBrush = false,
+              sal_uInt8 nTransparency = 255);
+    ~QtPainter()
     {
         if (m_rGraphics.m_pFrame && !m_aRegion.isEmpty())
             m_rGraphics.m_pFrame->GetQWidget()->update(m_aRegion);
diff --git a/vcl/inc/qt5/Qt5Printer.hxx b/vcl/inc/qt5/Qt5Printer.hxx
index 23f5428caa65..5aacfd44ec05 100644
--- a/vcl/inc/qt5/Qt5Printer.hxx
+++ b/vcl/inc/qt5/Qt5Printer.hxx
@@ -23,10 +23,10 @@
 
 class SalFrame;
 
-class Qt5Printer final : public PspSalPrinter
+class QtPrinter final : public PspSalPrinter
 {
 public:
-    Qt5Printer(SalInfoPrinter* pInfoPrinter);
+    QtPrinter(SalInfoPrinter* pInfoPrinter);
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/Qt5SvpGraphics.hxx b/vcl/inc/qt5/Qt5SvpGraphics.hxx
index 23aa6a36f0b5..ffc164c83373 100644
--- a/vcl/inc/qt5/Qt5SvpGraphics.hxx
+++ b/vcl/inc/qt5/Qt5SvpGraphics.hxx
@@ -24,17 +24,17 @@
 
 #include "Qt5GraphicsBase.hxx"
 
-class Qt5Frame;
+class QtFrame;
 
-class VCLPLUG_QT5_PUBLIC Qt5SvpGraphics final : public SvpSalGraphics, public Qt5GraphicsBase
+class VCLPLUG_QT5_PUBLIC QtSvpGraphics final : public SvpSalGraphics, public QtGraphicsBase
 {
-    Qt5Frame* const m_pFrame;
+    QtFrame* const m_pFrame;
 
     void handleDamage(const tools::Rectangle&) override;
 
 public:
-    Qt5SvpGraphics(Qt5Frame* pFrame);
-    ~Qt5SvpGraphics() override;
+    QtSvpGraphics(QtFrame* pFrame);
+    ~QtSvpGraphics() override;
 
     void updateQWidget() const;
 
diff --git a/vcl/inc/qt5/Qt5SvpSurface.hxx b/vcl/inc/qt5/Qt5SvpSurface.hxx
index 0e4da4877c06..2c2b29cff386 100644
--- a/vcl/inc/qt5/Qt5SvpSurface.hxx
+++ b/vcl/inc/qt5/Qt5SvpSurface.hxx
@@ -13,23 +13,23 @@
 
 #include <vcl/cairo.hxx>
 
-class Qt5SvpGraphics;
+class QtSvpGraphics;
 class OutputDevice;
 
 namespace cairo
 {
-class Qt5SvpSurface final : public Surface
+class QtSvpSurface final : public Surface
 {
-    const Qt5SvpGraphics* m_pGraphics;
+    const QtSvpGraphics* m_pGraphics;
     cairo_t* const m_pCairoContext;
     CairoSurfaceSharedPtr m_pSurface;
 
 public:
     /// takes over ownership of passed cairo_surface
-    explicit Qt5SvpSurface(const CairoSurfaceSharedPtr& pSurface);
+    explicit QtSvpSurface(const CairoSurfaceSharedPtr& pSurface);
     /// create surface on subarea of given drawable
-    explicit Qt5SvpSurface(const Qt5SvpGraphics* pGraphics, int x, int y, int width, int height);
-    ~Qt5SvpSurface() override;
+    explicit QtSvpSurface(const QtSvpGraphics* pGraphics, int x, int y, int width, int height);
+    ~QtSvpSurface() override;
 
     // Surface interface
     CairoSharedPtr getCairo() const override;
diff --git a/vcl/inc/qt5/Qt5System.hxx b/vcl/inc/qt5/Qt5System.hxx
index 63a7e9bde7a4..6992e381c4c4 100644
--- a/vcl/inc/qt5/Qt5System.hxx
+++ b/vcl/inc/qt5/Qt5System.hxx
@@ -11,7 +11,7 @@
 
 #include <unx/gensys.h>
 
-class Qt5System final : public SalGenericSystem
+class QtSystem final : public SalGenericSystem
 {
 public:
     virtual unsigned int GetDisplayScreenCount() override;
diff --git a/vcl/inc/qt5/Qt5Timer.hxx b/vcl/inc/qt5/Qt5Timer.hxx
index 99878e67ad6b..204b1bfe43ad 100644
--- a/vcl/inc/qt5/Qt5Timer.hxx
+++ b/vcl/inc/qt5/Qt5Timer.hxx
@@ -22,7 +22,7 @@
 #include <saltimer.hxx>
 #include <QtCore/QTimer>
 
-class Qt5Timer final : public QObject, public SalTimer
+class QtTimer final : public QObject, public SalTimer
 {
     Q_OBJECT
 
@@ -38,7 +38,7 @@ Q_SIGNALS:
     void stopTimerSignal();
 
 public:
-    Qt5Timer();
+    QtTimer();
 
     int remainingTime() const { return m_aTimer.remainingTime(); }
 
diff --git a/vcl/inc/qt5/Qt5Tools.hxx b/vcl/inc/qt5/Qt5Tools.hxx
index 0af3d0f5a998..7221a8ce8dc6 100644
--- a/vcl/inc/qt5/Qt5Tools.hxx
+++ b/vcl/inc/qt5/Qt5Tools.hxx
@@ -98,7 +98,7 @@ inline QList<int> toQList(const css::uno::Sequence<sal_Int32>& aSequence)
     return aList;
 }
 
-constexpr QImage::Format Qt5_DefaultFormat32 = QImage::Format_ARGB32;
+constexpr QImage::Format Qt_DefaultFormat32 = QImage::Format_ARGB32;
 
 inline QImage::Format getBitFormat(vcl::PixelFormat ePixelFormat)
 {
@@ -111,7 +111,7 @@ inline QImage::Format getBitFormat(vcl::PixelFormat ePixelFormat)
         case vcl::PixelFormat::N24_BPP:
             return QImage::Format_RGB888;
         case vcl::PixelFormat::N32_BPP:
-            return Qt5_DefaultFormat32;
+            return Qt_DefaultFormat32;
         default:
             std::abort();
             break;
@@ -129,7 +129,7 @@ inline sal_uInt16 getFormatBits(QImage::Format eFormat)
             return 8;
         case QImage::Format_RGB888:
             return 24;
-        case Qt5_DefaultFormat32:
+        case Qt_DefaultFormat32:
         case QImage::Format_ARGB32_Premultiplied:
             return 32;
         default:
diff --git a/vcl/inc/qt5/Qt5Transferable.hxx b/vcl/inc/qt5/Qt5Transferable.hxx
index 0d1cc70502aa..8a4410535359 100644
--- a/vcl/inc/qt5/Qt5Transferable.hxx
+++ b/vcl/inc/qt5/Qt5Transferable.hxx
@@ -18,8 +18,8 @@
 #include <QtGui/QClipboard>
 
 /**
- * Qt5Transferable classes are used to read QMimeData via the XTransferable
- * interface. All the functionality is already implemented in the Qt5Transferable.
+ * QtTransferable classes are used to read QMimeData via the XTransferable
+ * interface. All the functionality is already implemented in the QtTransferable.
  *
  * The specialisations map to the two users, which provide QMimeData: the Clipboard
  * and the Drag'n'Drop functionality.
@@ -27,11 +27,11 @@
  * LO itself seem to just accept "text/plain;charset=utf-16", so it relies on the
  * backend to convert to this charset, but still offers "text/plain" itself.
  *
- * It's the "mirror" interface of the Qt5MimeData, which is defined below.
+ * It's the "mirror" interface of the QtMimeData, which is defined below.
  **/
-class Qt5Transferable : public cppu::WeakImplHelper<css::datatransfer::XTransferable>
+class QtTransferable : public cppu::WeakImplHelper<css::datatransfer::XTransferable>
 {
-    Qt5Transferable(const Qt5Transferable&) = delete;
+    QtTransferable(const QtTransferable&) = delete;
 
     const QMimeData* m_pMimeData;
     osl::Mutex m_aMutex;
@@ -39,7 +39,7 @@ class Qt5Transferable : public cppu::WeakImplHelper<css::datatransfer::XTransfer
     css::uno::Sequence<css::datatransfer::DataFlavor> m_aMimeTypeSeq;
 
 public:
-    Qt5Transferable(const QMimeData* pMimeData);
+    QtTransferable(const QMimeData* pMimeData);
     const QMimeData* mimeData() const { return m_pMimeData; }
 
     css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL getTransferDataFlavors() override;
@@ -59,7 +59,7 @@ public:
  * interface, but currently we don't. But we ensure to never report mixed content,
  * so we'll just cease operation on QMimeData change.
  **/
-class Qt5ClipboardTransferable final : public Qt5Transferable
+class QtClipboardTransferable final : public QtTransferable
 {
     // to detect in-flight QMimeData changes
     const QClipboard::Mode m_aMode;
@@ -67,9 +67,9 @@ class Qt5ClipboardTransferable final : public Qt5Transferable
     bool hasInFlightChanged() const;
 
 public:
-    explicit Qt5ClipboardTransferable(const QClipboard::Mode aMode, const QMimeData* pMimeData);
+    explicit QtClipboardTransferable(const QClipboard::Mode aMode, const QMimeData* pMimeData);
 
-    // these are the same then Qt5Transferable, except they go through RunInMainThread
+    // these are the same then QtTransferable, except they go through RunInMainThread
     css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL getTransferDataFlavors() override;
     sal_Bool SAL_CALL isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor) override;
     css::uno::Any SAL_CALL getTransferData(const css::datatransfer::DataFlavor& rFlavor) override;
@@ -80,7 +80,7 @@ public:
  *
  * This just uses the QMimeData provided by the QWidgets D'n'D events.
  **/
-typedef Qt5Transferable Qt5DnDTransferable;
+typedef QtTransferable QtDnDTransferable;
 
 /**
  * A lazy loading QMimeData for XTransferable reads
@@ -97,11 +97,11 @@ typedef Qt5Transferable Qt5DnDTransferable;
  * If LO misses to offer a UTF-8 or a locale encoded string, these objects
  * will offer them themselves and convert from UTF-16 on demand.
  *
- * It's the "mirror" interface of the Qt5Transferable.
+ * It's the "mirror" interface of the QtTransferable.
  **/
-class Qt5MimeData final : public QMimeData
+class QtMimeData final : public QMimeData
 {
-    friend class Qt5ClipboardTransferable;
+    friend class QtClipboardTransferable;
 
     const css::uno::Reference<css::datatransfer::XTransferable> m_aContents;
     mutable bool m_bHaveNoCharset; // = uses the locale charset
@@ -111,7 +111,7 @@ class Qt5MimeData final : public QMimeData
     QVariant retrieveData(const QString& mimeType, QVariant::Type type) const override;
 
 public:
-    explicit Qt5MimeData(const css::uno::Reference<css::datatransfer::XTransferable>& aContents);
+    explicit QtMimeData(const css::uno::Reference<css::datatransfer::XTransferable>& aContents);
 
     bool hasFormat(const QString& mimeType) const override;
     QStringList formats() const override;
diff --git a/vcl/inc/qt5/Qt5VirtualDevice.hxx b/vcl/inc/qt5/Qt5VirtualDevice.hxx
index 79e738e8981f..2481f63d0657 100644
--- a/vcl/inc/qt5/Qt5VirtualDevice.hxx
+++ b/vcl/inc/qt5/Qt5VirtualDevice.hxx
@@ -26,19 +26,19 @@
 
 #include <QtCore/QSize>
 
-class Qt5Graphics;
+class QtGraphics;
 class QImage;
 enum class DeviceFormat;
 
-class Qt5VirtualDevice final : public SalVirtualDevice
+class QtVirtualDevice final : public SalVirtualDevice
 {
-    std::vector<Qt5Graphics*> m_aGraphics;
+    std::vector<QtGraphics*> m_aGraphics;
     std::unique_ptr<QImage> m_pImage;
     QSize m_aFrameSize;
     double m_fScale;
 
 public:
-    Qt5VirtualDevice(double fScale);
+    QtVirtualDevice(double fScale);
 
     // SalVirtualDevice
     virtual SalGraphics* AcquireGraphics() override;
diff --git a/vcl/inc/qt5/Qt5Widget.hxx b/vcl/inc/qt5/Qt5Widget.hxx
index 60db1a306efd..801cd290ff88 100644
--- a/vcl/inc/qt5/Qt5Widget.hxx
+++ b/vcl/inc/qt5/Qt5Widget.hxx
@@ -26,15 +26,15 @@
 #include <com/sun/star/accessibility/XAccessibleEditableText.hpp>
 
 class QInputEvent;
-class Qt5Frame;
-class Qt5Object;
+class QtFrame;
+class QtObject;
 struct SalAbstractMouseEvent;
 
-class Qt5Widget : public QWidget
+class QtWidget : public QWidget
 {
     Q_OBJECT
 
-    Qt5Frame& m_rFrame;
+    QtFrame& m_rFrame;
     bool m_bNonEmptyIMPreeditSeen;
     int m_nDeltaX;
     int m_nDeltaY;
@@ -45,10 +45,10 @@ class Qt5Widget : public QWidget
         Released
     };
 
-    static void commitText(Qt5Frame&, const QString& aText);
-    static bool handleKeyEvent(Qt5Frame&, const QWidget&, QKeyEvent*, const ButtonKeyState);
-    static void handleMouseButtonEvent(const Qt5Frame&, const QMouseEvent*, const ButtonKeyState);
-    static void fillSalAbstractMouseEvent(const Qt5Frame& rFrame, const QInputEvent* pQEvent,
+    static void commitText(QtFrame&, const QString& aText);
+    static bool handleKeyEvent(QtFrame&, const QWidget&, QKeyEvent*, const ButtonKeyState);
+    static void handleMouseButtonEvent(const QtFrame&, const QMouseEvent*, const ButtonKeyState);
+    static void fillSalAbstractMouseEvent(const QtFrame& rFrame, const QInputEvent* pQEvent,
                                           const QPoint& rPos, Qt::MouseButtons eButtons, int nWidth,
                                           SalAbstractMouseEvent& aSalEvent);
 
@@ -78,30 +78,30 @@ class Qt5Widget : public QWidget
     static void closePopup();
 
 public:
-    Qt5Widget(Qt5Frame& rFrame, Qt::WindowFlags f = Qt::WindowFlags());
+    QtWidget(QtFrame& rFrame, Qt::WindowFlags f = Qt::WindowFlags());
 
-    Qt5Frame& frame() const { return m_rFrame; }
+    QtFrame& frame() const { return m_rFrame; }
     void endExtTextInput();
 
-    static bool handleEvent(Qt5Frame&, const QWidget&, QEvent*);
+    static bool handleEvent(QtFrame&, const QWidget&, QEvent*);
     // key events might be propagated further down => call base on false
-    static inline bool handleKeyReleaseEvent(Qt5Frame&, const QWidget&, QKeyEvent*);
+    static inline bool handleKeyReleaseEvent(QtFrame&, const QWidget&, QKeyEvent*);
     // mouse events are always accepted
-    static inline void handleMousePressEvent(const Qt5Frame&, const QMouseEvent*);
-    static inline void handleMouseReleaseEvent(const Qt5Frame&, const QMouseEvent*);
+    static inline void handleMousePressEvent(const QtFrame&, const QMouseEvent*);
+    static inline void handleMouseReleaseEvent(const QtFrame&, const QMouseEvent*);
 };
 
-bool Qt5Widget::handleKeyReleaseEvent(Qt5Frame& rFrame, const QWidget& rWidget, QKeyEvent* pEvent)
+bool QtWidget::handleKeyReleaseEvent(QtFrame& rFrame, const QWidget& rWidget, QKeyEvent* pEvent)
 {
     return handleKeyEvent(rFrame, rWidget, pEvent, ButtonKeyState::Released);
 }
 
-void Qt5Widget::handleMousePressEvent(const Qt5Frame& rFrame, const QMouseEvent* pEvent)
+void QtWidget::handleMousePressEvent(const QtFrame& rFrame, const QMouseEvent* pEvent)
 {
     handleMouseButtonEvent(rFrame, pEvent, ButtonKeyState::Pressed);
 }
 
-void Qt5Widget::handleMouseReleaseEvent(const Qt5Frame& rFrame, const QMouseEvent* pEvent)
+void QtWidget::handleMouseReleaseEvent(const QtFrame& rFrame, const QMouseEvent* pEvent)
 {
     handleMouseButtonEvent(rFrame, pEvent, ButtonKeyState::Released);
 }
diff --git a/vcl/inc/qt5/Qt5XAccessible.hxx b/vcl/inc/qt5/Qt5XAccessible.hxx
index fe8e424e4628..4f4285e8065b 100644
--- a/vcl/inc/qt5/Qt5XAccessible.hxx
+++ b/vcl/inc/qt5/Qt5XAccessible.hxx
@@ -17,17 +17,17 @@
 
 #include <vcl/window.hxx>
 
-class Qt5Frame;
-class Qt5Widget;
+class QtFrame;
+class QtWidget;
 
 // Wrapper class to hold a css::accessibility::XAccessible object
 // while being able to pass it as a QObject
-class Qt5XAccessible : public QObject
+class QtXAccessible : public QObject
 {
     Q_OBJECT
 
 public:
-    Qt5XAccessible(css::uno::Reference<css::accessibility::XAccessible> xAccessible);
+    QtXAccessible(css::uno::Reference<css::accessibility::XAccessible> xAccessible);
     css::uno::Reference<css::accessibility::XAccessible> m_xAccessible;
 };
 
diff --git a/vcl/qt5/Qt5AccessibleEventListener.cxx b/vcl/qt5/Qt5AccessibleEventListener.cxx
index 621e541723c8..6f0e3bf827f8 100644
--- a/vcl/qt5/Qt5AccessibleEventListener.cxx
+++ b/vcl/qt5/Qt5AccessibleEventListener.cxx
@@ -30,15 +30,14 @@ using namespace css::accessibility;
 using namespace css::lang;
 using namespace css::uno;
 
-Qt5AccessibleEventListener::Qt5AccessibleEventListener(const Reference<XAccessible> xAccessible,
-                                                       Qt5AccessibleWidget* pAccessibleWidget)
+QtAccessibleEventListener::QtAccessibleEventListener(const Reference<XAccessible> xAccessible,
+                                                     QtAccessibleWidget* pAccessibleWidget)
     : m_xAccessible(xAccessible)
     , m_pAccessibleWidget(pAccessibleWidget)
 {
 }
 
-void Qt5AccessibleEventListener::notifyEvent(
-    const css::accessibility::AccessibleEventObject& aEvent)
+void QtAccessibleEventListener::notifyEvent(const css::accessibility::AccessibleEventObject& aEvent)
 {
     QAccessibleInterface* pQAccessibleInterface = m_pAccessibleWidget;
 
@@ -169,6 +168,6 @@ void Qt5AccessibleEventListener::notifyEvent(
     }
 }
 
-void Qt5AccessibleEventListener::disposing(const EventObject& /* Source */) {}
+void QtAccessibleEventListener::disposing(const EventObject& /* Source */) {}
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5AccessibleWidget.cxx b/vcl/qt5/Qt5AccessibleWidget.cxx
index 3a6e5a288194..5dcb30b2da6e 100644
--- a/vcl/qt5/Qt5AccessibleWidget.cxx
+++ b/vcl/qt5/Qt5AccessibleWidget.cxx
@@ -60,7 +60,7 @@ using namespace css::accessibility;
 using namespace css::beans;
 using namespace css::uno;
 
-Qt5AccessibleWidget::Qt5AccessibleWidget(const Reference<XAccessible> xAccessible, QObject* pObject)
+QtAccessibleWidget::QtAccessibleWidget(const Reference<XAccessible> xAccessible, QObject* pObject)
     : m_xAccessible(xAccessible)
     , m_pObject(pObject)
 {
@@ -69,12 +69,12 @@ Qt5AccessibleWidget::Qt5AccessibleWidget(const Reference<XAccessible> xAccessibl
     if (xBroadcaster.is())
     {
         Reference<XAccessibleEventListener> xListener(
-            new Qt5AccessibleEventListener(xAccessible, this));
+            new QtAccessibleEventListener(xAccessible, this));
         xBroadcaster->addAccessibleEventListener(xListener);
     }
 }
 
-Reference<XAccessibleContext> Qt5AccessibleWidget::getAccessibleContextImpl() const
+Reference<XAccessibleContext> QtAccessibleWidget::getAccessibleContextImpl() const
 {
     Reference<XAccessibleContext> xAc;
 
@@ -101,7 +101,7 @@ Reference<XAccessibleContext> Qt5AccessibleWidget::getAccessibleContextImpl() co
 }
 
 css::uno::Reference<css::accessibility::XAccessibleTable>
-Qt5AccessibleWidget::getAccessibleTableForParent() const
+QtAccessibleWidget::getAccessibleTableForParent() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -118,9 +118,9 @@ Qt5AccessibleWidget::getAccessibleTableForParent() const
     return Reference<XAccessibleTable>(xParentContext, UNO_QUERY);
 }
 
-QWindow* Qt5AccessibleWidget::window() const { return nullptr; }
+QWindow* QtAccessibleWidget::window() const { return nullptr; }
 
-int Qt5AccessibleWidget::childCount() const
+int QtAccessibleWidget::childCount() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -129,7 +129,7 @@ int Qt5AccessibleWidget::childCount() const
     return xAc->getAccessibleChildCount();
 }
 
-int Qt5AccessibleWidget::indexOfChild(const QAccessibleInterface* /* child */) const { return 0; }
+int QtAccessibleWidget::indexOfChild(const QAccessibleInterface* /* child */) const { return 0; }
 
 namespace
 {
@@ -213,13 +213,13 @@ void lcl_appendRelation(QVector<QPair<QAccessibleInterface*, QAccessible::Relati
     {
         Reference<XAccessible> xAccessible(aRelation.TargetSet[i], uno::UNO_QUERY);
         relations->append(
-            { QAccessible::queryAccessibleInterface(new Qt5XAccessible(xAccessible)), aQRelation });
+            { QAccessible::queryAccessibleInterface(new QtXAccessible(xAccessible)), aQRelation });
     }
 }
 }
 
 QVector<QPair<QAccessibleInterface*, QAccessible::Relation>>
-Qt5AccessibleWidget::relations(QAccessible::Relation match) const
+QtAccessibleWidget::relations(QAccessible::Relation match) const
 {
     QVector<QPair<QAccessibleInterface*, QAccessible::Relation>> relations;
 
@@ -249,15 +249,15 @@ Qt5AccessibleWidget::relations(QAccessible::Relation match) const
     return relations;
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::focusChild() const
+QAccessibleInterface* QtAccessibleWidget::focusChild() const
 {
     /* if (m_pWindow->HasChildPathFocus())
         return QAccessible::queryAccessibleInterface(
-            new Qt5XAccessible(m_xAccessible->getAccessibleContext()->getAccessibleChild(index))); */
+            new QtXAccessible(m_xAccessible->getAccessibleContext()->getAccessibleChild(index))); */
     return QAccessible::queryAccessibleInterface(object());
 }
 
-QRect Qt5AccessibleWidget::rect() const
+QRect QtAccessibleWidget::rect() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -270,25 +270,24 @@ QRect Qt5AccessibleWidget::rect() const
     return QRect(aPoint.X, aPoint.Y, aSize.Width, aSize.Height);
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::parent() const
+QAccessibleInterface* QtAccessibleWidget::parent() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
         return nullptr;
 
-    return QAccessible::queryAccessibleInterface(new Qt5XAccessible(xAc->getAccessibleParent()));
+    return QAccessible::queryAccessibleInterface(new QtXAccessible(xAc->getAccessibleParent()));
 }
-QAccessibleInterface* Qt5AccessibleWidget::child(int index) const
+QAccessibleInterface* QtAccessibleWidget::child(int index) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
         return nullptr;
 
-    return QAccessible::queryAccessibleInterface(
-        new Qt5XAccessible(xAc->getAccessibleChild(index)));
+    return QAccessible::queryAccessibleInterface(new QtXAccessible(xAc->getAccessibleChild(index)));
 }
 
-QString Qt5AccessibleWidget::text(QAccessible::Text text) const
+QString QtAccessibleWidget::text(QAccessible::Text text) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -309,7 +308,7 @@ QString Qt5AccessibleWidget::text(QAccessible::Text text) const
             return QString("Unknown");
     }
 }
-QAccessible::Role Qt5AccessibleWidget::role() const
+QAccessible::Role QtAccessibleWidget::role() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -690,7 +689,7 @@ void lcl_addState(QAccessible::State* state, sal_Int16 nState)
 }
 }
 
-QAccessible::State Qt5AccessibleWidget::state() const
+QAccessible::State QtAccessibleWidget::state() const
 {
     QAccessible::State state;
 
@@ -713,7 +712,7 @@ QAccessible::State Qt5AccessibleWidget::state() const
     return state;
 }
 
-QColor Qt5AccessibleWidget::foregroundColor() const
+QColor QtAccessibleWidget::foregroundColor() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -723,7 +722,7 @@ QColor Qt5AccessibleWidget::foregroundColor() const
     return toQColor(Color(ColorTransparency, xAccessibleComponent->getForeground()));
 }
 
-QColor Qt5AccessibleWidget::backgroundColor() const
+QColor QtAccessibleWidget::backgroundColor() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -733,7 +732,7 @@ QColor Qt5AccessibleWidget::backgroundColor() const
     return toQColor(Color(ColorTransparency, xAccessibleComponent->getBackground()));
 }
 
-void* Qt5AccessibleWidget::interface_cast(QAccessible::InterfaceType t)
+void* QtAccessibleWidget::interface_cast(QAccessible::InterfaceType t)
 {
     if (t == QAccessible::ActionInterface)
         return static_cast<QAccessibleActionInterface*>(this);
@@ -750,17 +749,17 @@ void* Qt5AccessibleWidget::interface_cast(QAccessible::InterfaceType t)
     return nullptr;
 }
 
-bool Qt5AccessibleWidget::isValid() const
+bool QtAccessibleWidget::isValid() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     return xAc.is();
 }
 
-QObject* Qt5AccessibleWidget::object() const { return m_pObject; }
+QObject* QtAccessibleWidget::object() const { return m_pObject; }
 
-void Qt5AccessibleWidget::setText(QAccessible::Text /* t */, const QString& /* text */) {}
+void QtAccessibleWidget::setText(QAccessible::Text /* t */, const QString& /* text */) {}
 
-QAccessibleInterface* Qt5AccessibleWidget::childAt(int x, int y) const
+QAccessibleInterface* QtAccessibleWidget::childAt(int x, int y) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -768,31 +767,31 @@ QAccessibleInterface* Qt5AccessibleWidget::childAt(int x, int y) const
 
     Reference<XAccessibleComponent> xAccessibleComponent(xAc, UNO_QUERY);
     return QAccessible::queryAccessibleInterface(
-        new Qt5XAccessible(xAccessibleComponent->getAccessibleAtPoint(awt::Point(x, y))));
+        new QtXAccessible(xAccessibleComponent->getAccessibleAtPoint(awt::Point(x, y))));
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::customFactory(const QString& classname, QObject* object)
+QAccessibleInterface* QtAccessibleWidget::customFactory(const QString& classname, QObject* object)
 {
-    if (classname == QLatin1String("Qt5Widget") && object && object->isWidgetType())
+    if (classname == QLatin1String("QtWidget") && object && object->isWidgetType())
     {
-        Qt5Widget* pWidget = static_cast<Qt5Widget*>(object);
+        QtWidget* pWidget = static_cast<QtWidget*>(object);
         vcl::Window* pWindow = pWidget->frame().GetWindow();
 
         if (pWindow)
-            return new Qt5AccessibleWidget(pWindow->GetAccessible(), object);
+            return new QtAccessibleWidget(pWindow->GetAccessible(), object);
     }
-    if (classname == QLatin1String("Qt5XAccessible") && object)
+    if (classname == QLatin1String("QtXAccessible") && object)
     {
-        Qt5XAccessible* pXAccessible = dynamic_cast<Qt5XAccessible*>(object);
+        QtXAccessible* pXAccessible = dynamic_cast<QtXAccessible*>(object);
         if (pXAccessible && pXAccessible->m_xAccessible.is())
-            return new Qt5AccessibleWidget(pXAccessible->m_xAccessible, object);
+            return new QtAccessibleWidget(pXAccessible->m_xAccessible, object);
     }
 
     return nullptr;
 }
 
 // QAccessibleActionInterface
-QStringList Qt5AccessibleWidget::actionNames() const
+QStringList QtAccessibleWidget::actionNames() const
 {
     QStringList actionNames;
     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
@@ -808,7 +807,7 @@ QStringList Qt5AccessibleWidget::actionNames() const
     return actionNames;
 }
 
-void Qt5AccessibleWidget::doAction(const QString& actionName)
+void QtAccessibleWidget::doAction(const QString& actionName)
 {
     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
     if (!xAccessibleAction.is())
@@ -820,7 +819,7 @@ void Qt5AccessibleWidget::doAction(const QString& actionName)
     xAccessibleAction->doAccessibleAction(index);
 }
 
-QStringList Qt5AccessibleWidget::keyBindingsForAction(const QString& actionName) const
+QStringList QtAccessibleWidget::keyBindingsForAction(const QString& actionName) const
 {
     QStringList keyBindings;
     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
@@ -847,7 +846,7 @@ QStringList Qt5AccessibleWidget::keyBindingsForAction(const QString& actionName)
 }
 
 // QAccessibleTextInterface
-void Qt5AccessibleWidget::addSelection(int /* startOffset */, int /* endOffset */)
+void QtAccessibleWidget::addSelection(int /* startOffset */, int /* endOffset */)
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::addSelection");
 }
@@ -878,7 +877,7 @@ OUString lcl_convertFontWeight(double fontWeight)
 }
 }
 
-QString Qt5AccessibleWidget::attributes(int offset, int* startOffset, int* endOffset) const
+QString QtAccessibleWidget::attributes(int offset, int* startOffset, int* endOffset) const
 {
     if (startOffset == nullptr || endOffset == nullptr)
         return QString();
@@ -933,20 +932,20 @@ QString Qt5AccessibleWidget::attributes(int offset, int* startOffset, int* endOf
     return toQString(aRet);
 }
 
-int Qt5AccessibleWidget::characterCount() const
+int QtAccessibleWidget::characterCount() const
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
         return xText->getCharacterCount();
     return 0;
 }
-QRect Qt5AccessibleWidget::characterRect(int /* offset */) const
+QRect QtAccessibleWidget::characterRect(int /* offset */) const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::characterRect");
     return QRect();
 }
 
-int Qt5AccessibleWidget::cursorPosition() const
+int QtAccessibleWidget::cursorPosition() const
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
@@ -954,23 +953,23 @@ int Qt5AccessibleWidget::cursorPosition() const
     return 0;
 }
 
-int Qt5AccessibleWidget::offsetAtPoint(const QPoint& /* point */) const
+int QtAccessibleWidget::offsetAtPoint(const QPoint& /* point */) const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::offsetAtPoint");
     return 0;
 }
-void Qt5AccessibleWidget::removeSelection(int /* selectionIndex */)
+void QtAccessibleWidget::removeSelection(int /* selectionIndex */)
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::removeSelection");
 }
-void Qt5AccessibleWidget::scrollToSubstring(int startIndex, int endIndex)
+void QtAccessibleWidget::scrollToSubstring(int startIndex, int endIndex)
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
         xText->scrollSubstringTo(startIndex, endIndex, AccessibleScrollType_SCROLL_ANYWHERE);
 }
 
-void Qt5AccessibleWidget::selection(int selectionIndex, int* startOffset, int* endOffset) const
+void QtAccessibleWidget::selection(int selectionIndex, int* startOffset, int* endOffset) const
 {
     if (!startOffset && !endOffset)
         return;
@@ -985,42 +984,42 @@ void Qt5AccessibleWidget::selection(int selectionIndex, int* startOffset, int* e
         *endOffset = xText.is() ? xText->getSelectionEnd() : 0;
 }
 
-int Qt5AccessibleWidget::selectionCount() const
+int QtAccessibleWidget::selectionCount() const
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is() && !xText->getSelectedText().isEmpty())
         return 1; // Only 1 selection supported atm
     return 0;
 }
-void Qt5AccessibleWidget::setCursorPosition(int position)
+void QtAccessibleWidget::setCursorPosition(int position)
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
         xText->setCaretPosition(position);
 }
-void Qt5AccessibleWidget::setSelection(int /* selectionIndex */, int startOffset, int endOffset)
+void QtAccessibleWidget::setSelection(int /* selectionIndex */, int startOffset, int endOffset)
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
         xText->setSelection(startOffset, endOffset);
 }
-QString Qt5AccessibleWidget::text(int startOffset, int endOffset) const
+QString QtAccessibleWidget::text(int startOffset, int endOffset) const
 {
     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
     if (xText.is())
         return toQString(xText->getTextRange(startOffset, endOffset));
     return QString();
 }
-QString Qt5AccessibleWidget::textAfterOffset(int /* offset */,
-                                             QAccessible::TextBoundaryType /* boundaryType */,
-                                             int* /* startOffset */, int* /* endOffset */) const
+QString QtAccessibleWidget::textAfterOffset(int /* offset */,
+                                            QAccessible::TextBoundaryType /* boundaryType */,
+                                            int* /* startOffset */, int* /* endOffset */) const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::textAfterOffset");
     return QString();
 }
 
-QString Qt5AccessibleWidget::textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType,
-                                          int* startOffset, int* endOffset) const
+QString QtAccessibleWidget::textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType,
+                                         int* startOffset, int* endOffset) const
 {
     if (startOffset == nullptr || endOffset == nullptr)
         return QString();
@@ -1046,9 +1045,9 @@ QString Qt5AccessibleWidget::textAtOffset(int offset, QAccessible::TextBoundaryT
     return toQString(segment.SegmentText);
 }
 
-QString Qt5AccessibleWidget::textBeforeOffset(int /* offset */,
-                                              QAccessible::TextBoundaryType /* boundaryType */,
-                                              int* /* startOffset */, int* /* endOffset */) const
+QString QtAccessibleWidget::textBeforeOffset(int /* offset */,
+                                             QAccessible::TextBoundaryType /* boundaryType */,
+                                             int* /* startOffset */, int* /* endOffset */) const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTextInterface::textBeforeOffset");
     return QString();
@@ -1056,7 +1055,7 @@ QString Qt5AccessibleWidget::textBeforeOffset(int /* offset */,
 
 // QAccessibleEditableTextInterface
 
-void Qt5AccessibleWidget::deleteText(int startOffset, int endOffset)
+void QtAccessibleWidget::deleteText(int startOffset, int endOffset)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1068,7 +1067,7 @@ void Qt5AccessibleWidget::deleteText(int startOffset, int endOffset)
     xEditableText->deleteText(startOffset, endOffset);
 }
 
-void Qt5AccessibleWidget::insertText(int offset, const QString& text)
+void QtAccessibleWidget::insertText(int offset, const QString& text)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1080,7 +1079,7 @@ void Qt5AccessibleWidget::insertText(int offset, const QString& text)
     xEditableText->insertText(toOUString(text), offset);
 }
 
-void Qt5AccessibleWidget::replaceText(int startOffset, int endOffset, const QString& text)
+void QtAccessibleWidget::replaceText(int startOffset, int endOffset, const QString& text)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1093,7 +1092,7 @@ void Qt5AccessibleWidget::replaceText(int startOffset, int endOffset, const QStr
 }
 
 // QAccessibleValueInterface
-QVariant Qt5AccessibleWidget::currentValue() const
+QVariant QtAccessibleWidget::currentValue() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1107,7 +1106,7 @@ QVariant Qt5AccessibleWidget::currentValue() const
     return QVariant(aDouble);
 }
 
-QVariant Qt5AccessibleWidget::maximumValue() const
+QVariant QtAccessibleWidget::maximumValue() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1121,7 +1120,7 @@ QVariant Qt5AccessibleWidget::maximumValue() const
     return QVariant(aDouble);
 }
 
-QVariant Qt5AccessibleWidget::minimumStepSize() const
+QVariant QtAccessibleWidget::minimumStepSize() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1135,7 +1134,7 @@ QVariant Qt5AccessibleWidget::minimumStepSize() const
     return QVariant(dMinStep);
 }
 
-QVariant Qt5AccessibleWidget::minimumValue() const
+QVariant QtAccessibleWidget::minimumValue() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1149,7 +1148,7 @@ QVariant Qt5AccessibleWidget::minimumValue() const
     return QVariant(aDouble);
 }
 
-void Qt5AccessibleWidget::setCurrentValue(const QVariant& value)
+void QtAccessibleWidget::setCurrentValue(const QVariant& value)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1162,7 +1161,7 @@ void Qt5AccessibleWidget::setCurrentValue(const QVariant& value)
 }
 
 // QAccessibleTable
-QAccessibleInterface* Qt5AccessibleWidget::caption() const
+QAccessibleInterface* QtAccessibleWidget::caption() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1171,11 +1170,10 @@ QAccessibleInterface* Qt5AccessibleWidget::caption() const
     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
     if (!xTable.is())
         return nullptr;
-    return QAccessible::queryAccessibleInterface(
-        new Qt5XAccessible(xTable->getAccessibleCaption()));
+    return QAccessible::queryAccessibleInterface(new QtXAccessible(xTable->getAccessibleCaption()));
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::cellAt(int row, int column) const
+QAccessibleInterface* QtAccessibleWidget::cellAt(int row, int column) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1185,10 +1183,10 @@ QAccessibleInterface* Qt5AccessibleWidget::cellAt(int row, int column) const
     if (!xTable.is())
         return nullptr;
     return QAccessible::queryAccessibleInterface(
-        new Qt5XAccessible(xTable->getAccessibleCellAt(row, column)));
+        new QtXAccessible(xTable->getAccessibleCellAt(row, column)));
 }
 
-int Qt5AccessibleWidget::columnCount() const
+int QtAccessibleWidget::columnCount() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1200,7 +1198,7 @@ int Qt5AccessibleWidget::columnCount() const
     return xTable->getAccessibleColumnCount();
 }
 
-QString Qt5AccessibleWidget::columnDescription(int column) const
+QString QtAccessibleWidget::columnDescription(int column) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1212,7 +1210,7 @@ QString Qt5AccessibleWidget::columnDescription(int column) const
     return toQString(xTable->getAccessibleColumnDescription(column));
 }
 
-bool Qt5AccessibleWidget::isColumnSelected(int nColumn) const
+bool QtAccessibleWidget::isColumnSelected(int nColumn) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1225,7 +1223,7 @@ bool Qt5AccessibleWidget::isColumnSelected(int nColumn) const
     return xTable->isAccessibleColumnSelected(nColumn);
 }
 
-bool Qt5AccessibleWidget::isRowSelected(int nRow) const
+bool QtAccessibleWidget::isRowSelected(int nRow) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1238,9 +1236,9 @@ bool Qt5AccessibleWidget::isRowSelected(int nRow) const
     return xTable->isAccessibleRowSelected(nRow);
 }
 
-void Qt5AccessibleWidget::modelChange(QAccessibleTableModelChangeEvent*) {}
+void QtAccessibleWidget::modelChange(QAccessibleTableModelChangeEvent*) {}
 
-int Qt5AccessibleWidget::rowCount() const
+int QtAccessibleWidget::rowCount() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1252,7 +1250,7 @@ int Qt5AccessibleWidget::rowCount() const
     return xTable->getAccessibleRowCount();
 }
 
-QString Qt5AccessibleWidget::rowDescription(int row) const
+QString QtAccessibleWidget::rowDescription(int row) const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1264,7 +1262,7 @@ QString Qt5AccessibleWidget::rowDescription(int row) const
     return toQString(xTable->getAccessibleRowDescription(row));
 }
 
-bool Qt5AccessibleWidget::selectColumn(int column)
+bool QtAccessibleWidget::selectColumn(int column)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1276,7 +1274,7 @@ bool Qt5AccessibleWidget::selectColumn(int column)
     return xTableSelection->selectColumn(column);
 }
 
-bool Qt5AccessibleWidget::selectRow(int row)
+bool QtAccessibleWidget::selectRow(int row)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1288,19 +1286,19 @@ bool Qt5AccessibleWidget::selectRow(int row)
     return xTableSelection->selectRow(row);
 }
 
-int Qt5AccessibleWidget::selectedCellCount() const
+int QtAccessibleWidget::selectedCellCount() const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTableInterface::selectedCellCount");
     return 0;
 }
 
-QList<QAccessibleInterface*> Qt5AccessibleWidget::selectedCells() const
+QList<QAccessibleInterface*> QtAccessibleWidget::selectedCells() const
 {
     SAL_INFO("vcl.qt5", "Unsupported QAccessibleTableInterface::selectedCells");
     return QList<QAccessibleInterface*>();
 }
 
-int Qt5AccessibleWidget::selectedColumnCount() const
+int QtAccessibleWidget::selectedColumnCount() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1312,7 +1310,7 @@ int Qt5AccessibleWidget::selectedColumnCount() const
     return xTable->getSelectedAccessibleColumns().getLength();
 }
 
-QList<int> Qt5AccessibleWidget::selectedColumns() const
+QList<int> QtAccessibleWidget::selectedColumns() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1324,7 +1322,7 @@ QList<int> Qt5AccessibleWidget::selectedColumns() const
     return toQList(xTable->getSelectedAccessibleColumns());
 }
 
-int Qt5AccessibleWidget::selectedRowCount() const
+int QtAccessibleWidget::selectedRowCount() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1336,7 +1334,7 @@ int Qt5AccessibleWidget::selectedRowCount() const
     return xTable->getSelectedAccessibleRows().getLength();
 }
 
-QList<int> Qt5AccessibleWidget::selectedRows() const
+QList<int> QtAccessibleWidget::selectedRows() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1348,7 +1346,7 @@ QList<int> Qt5AccessibleWidget::selectedRows() const
     return toQList(xTable->getSelectedAccessibleRows());
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::summary() const
+QAccessibleInterface* QtAccessibleWidget::summary() const
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1357,11 +1355,10 @@ QAccessibleInterface* Qt5AccessibleWidget::summary() const
     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
     if (!xTable.is())
         return nullptr;
-    return QAccessible::queryAccessibleInterface(
-        new Qt5XAccessible(xTable->getAccessibleSummary()));
+    return QAccessible::queryAccessibleInterface(new QtXAccessible(xTable->getAccessibleSummary()));
 }
 
-bool Qt5AccessibleWidget::unselectColumn(int column)
+bool QtAccessibleWidget::unselectColumn(int column)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1373,7 +1370,7 @@ bool Qt5AccessibleWidget::unselectColumn(int column)
     return xTableSelection->unselectColumn(column);
 }
 
-bool Qt5AccessibleWidget::unselectRow(int row)
+bool QtAccessibleWidget::unselectRow(int row)
 {
     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
     if (!xAc.is())
@@ -1385,13 +1382,13 @@ bool Qt5AccessibleWidget::unselectRow(int row)
     return xTableSelection->unselectRow(row);
 }
 
-QList<QAccessibleInterface*> Qt5AccessibleWidget::columnHeaderCells() const
+QList<QAccessibleInterface*> QtAccessibleWidget::columnHeaderCells() const
 {
     SAL_WARN("vcl.qt5", "Unsupported QAccessibleTableCellInterface::columnHeaderCells");
     return QList<QAccessibleInterface*>();
 }
 
-int Qt5AccessibleWidget::columnIndex() const
+int QtAccessibleWidget::columnIndex() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -1405,7 +1402,7 @@ int Qt5AccessibleWidget::columnIndex() const
     return xTable->getAccessibleColumn(nIndexInParent);
 }
 
-bool Qt5AccessibleWidget::isSelected() const
+bool QtAccessibleWidget::isSelected() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -1420,7 +1417,7 @@ bool Qt5AccessibleWidget::isSelected() const
     return xTable->isAccessibleSelected(nRow, nColumn);
 }
 
-int Qt5AccessibleWidget::columnExtent() const
+int QtAccessibleWidget::columnExtent() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -1435,13 +1432,13 @@ int Qt5AccessibleWidget::columnExtent() const
     return xTable->getAccessibleColumnExtentAt(nRow, nColumn);
 }
 
-QList<QAccessibleInterface*> Qt5AccessibleWidget::rowHeaderCells() const
+QList<QAccessibleInterface*> QtAccessibleWidget::rowHeaderCells() const
 {
     SAL_WARN("vcl.qt5", "Unsupported QAccessibleTableCellInterface::rowHeaderCells");
     return QList<QAccessibleInterface*>();
 }
 
-int Qt5AccessibleWidget::rowExtent() const
+int QtAccessibleWidget::rowExtent() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -1456,7 +1453,7 @@ int Qt5AccessibleWidget::rowExtent() const
     return xTable->getAccessibleRowExtentAt(nRow, nColumn);
 }
 
-int Qt5AccessibleWidget::rowIndex() const
+int QtAccessibleWidget::rowIndex() const
 {
     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
     if (!xAcc.is())
@@ -1470,7 +1467,7 @@ int Qt5AccessibleWidget::rowIndex() const
     return xTable->getAccessibleRow(nIndexInParent);
 }
 
-QAccessibleInterface* Qt5AccessibleWidget::table() const
+QAccessibleInterface* QtAccessibleWidget::table() const
 {
     SAL_WARN("vcl.qt5", "Unsupported QAccessibleTableCellInterface::table");
     return nullptr;
diff --git a/vcl/qt5/Qt5Bitmap.cxx b/vcl/qt5/Qt5Bitmap.cxx
index 4ad2ea9c9f60..951046612e46 100644
--- a/vcl/qt5/Qt5Bitmap.cxx
+++ b/vcl/qt5/Qt5Bitmap.cxx
@@ -29,11 +29,11 @@
 #include <sal/log.hxx>
 #include <tools/helpers.hxx>
 
-Qt5Bitmap::Qt5Bitmap() {}
+QtBitmap::QtBitmap() {}
 
-Qt5Bitmap::Qt5Bitmap(const QImage& rImage) { m_pImage.reset(new QImage(rImage)); }
+QtBitmap::QtBitmap(const QImage& rImage) { m_pImage.reset(new QImage(rImage)); }
 
-bool Qt5Bitmap::Create(const Size& rSize, vcl::PixelFormat ePixelFormat, const BitmapPalette& rPal)
+bool QtBitmap::Create(const Size& rSize, vcl::PixelFormat ePixelFormat, const BitmapPalette& rPal)
 {
     if (ePixelFormat == vcl::PixelFormat::INVALID)
         return false;
@@ -58,55 +58,55 @@ bool Qt5Bitmap::Create(const Size& rSize, vcl::PixelFormat ePixelFormat, const B
     return true;
 }
 
-bool Qt5Bitmap::Create(const SalBitmap& rSalBmp)
+bool QtBitmap::Create(const SalBitmap& rSalBmp)
 {
-    const Qt5Bitmap* pBitmap = static_cast<const Qt5Bitmap*>(&rSalBmp);
+    const QtBitmap* pBitmap = static_cast<const QtBitmap*>(&rSalBmp);
     m_pImage.reset(new QImage(*pBitmap->m_pImage));
     m_aPalette = pBitmap->m_aPalette;
     return true;
 }
 
-bool Qt5Bitmap::Create(const SalBitmap& rSalBmp, SalGraphics* pSalGraphics)
+bool QtBitmap::Create(const SalBitmap& rSalBmp, SalGraphics* pSalGraphics)
 {
-    const Qt5Bitmap* pBitmap = static_cast<const Qt5Bitmap*>(&rSalBmp);
-    Qt5Graphics* pGraphics = static_cast<Qt5Graphics*>(pSalGraphics);
+    const QtBitmap* pBitmap = static_cast<const QtBitmap*>(&rSalBmp);
+    QtGraphics* pGraphics = static_cast<QtGraphics*>(pSalGraphics);
     QImage* pImage = pGraphics->getQImage();
     m_pImage.reset(new QImage(pBitmap->m_pImage->convertToFormat(pImage->format())));
     return true;
 }
 
-bool Qt5Bitmap::Create(const SalBitmap& rSalBmp, vcl::PixelFormat eNewPixelFormat)
+bool QtBitmap::Create(const SalBitmap& rSalBmp, vcl::PixelFormat eNewPixelFormat)
 {
     if (eNewPixelFormat == vcl::PixelFormat::INVALID)
         return false;
-    const Qt5Bitmap* pBitmap = static_cast<const Qt5Bitmap*>(&rSalBmp);
+    const QtBitmap* pBitmap = static_cast<const QtBitmap*>(&rSalBmp);
     m_pImage.reset(new QImage(pBitmap->m_pImage->convertToFormat(getBitFormat(eNewPixelFormat))));
     return true;
 }
 
-bool Qt5Bitmap::Create(const css::uno::Reference<css::rendering::XBitmapCanvas>& /*rBitmapCanvas*/,
-                       Size& /*rSize*/, bool /*bMask*/)
+bool QtBitmap::Create(const css::uno::Reference<css::rendering::XBitmapCanvas>& /*rBitmapCanvas*/,
+                      Size& /*rSize*/, bool /*bMask*/)
 {
     return false;
 }
 
-void Qt5Bitmap::Destroy() { m_pImage.reset(); }
+void QtBitmap::Destroy() { m_pImage.reset(); }
 
-Size Qt5Bitmap::GetSize() const
+Size QtBitmap::GetSize() const
 {
     if (m_pImage)
         return toSize(m_pImage->size());
     return Size();
 }
 
-sal_uInt16 Qt5Bitmap::GetBitCount() const
+sal_uInt16 QtBitmap::GetBitCount() const
 {
     if (m_pImage)
         return getFormatBits(m_pImage->format());
     return 0;
 }
 
-BitmapBuffer* Qt5Bitmap::AcquireBuffer(BitmapAccessMode /*nMode*/)
+BitmapBuffer* QtBitmap::AcquireBuffer(BitmapAccessMode /*nMode*/)
 {
     static const BitmapPalette aEmptyPalette;
 
@@ -152,7 +152,7 @@ BitmapBuffer* Qt5Bitmap::AcquireBuffer(BitmapAccessMode /*nMode*/)
     return pBuffer;
 }
 
-void Qt5Bitmap::ReleaseBuffer(BitmapBuffer* pBuffer, BitmapAccessMode nMode)
+void QtBitmap::ReleaseBuffer(BitmapBuffer* pBuffer, BitmapAccessMode nMode)
 {
     m_aPalette = pBuffer->maPalette;
     auto count = m_aPalette.GetEntryCount();
@@ -169,18 +169,18 @@ void Qt5Bitmap::ReleaseBuffer(BitmapBuffer* pBuffer, BitmapAccessMode nMode)
         InvalidateChecksum();
 }
 
-bool Qt5Bitmap::GetSystemData(BitmapSystemData& /*rData*/) { return false; }
+bool QtBitmap::GetSystemData(BitmapSystemData& /*rData*/) { return false; }
 
-bool Qt5Bitmap::ScalingSupported() const { return false; }
+bool QtBitmap::ScalingSupported() const { return false; }
 
-bool Qt5Bitmap::Scale(const double& /*rScaleX*/, const double& /*rScaleY*/,
-                      BmpScaleFlag /*nScaleFlag*/)
+bool QtBitmap::Scale(const double& /*rScaleX*/, const double& /*rScaleY*/,
+                     BmpScaleFlag /*nScaleFlag*/)
 {
     return false;
 }
 
-bool Qt5Bitmap::Replace(const Color& /*rSearchColor*/, const Color& /*rReplaceColor*/,
-                        sal_uInt8 /*nTol*/)
+bool QtBitmap::Replace(const Color& /*rSearchColor*/, const Color& /*rReplaceColor*/,
+                       sal_uInt8 /*nTol*/)
 {
     return false;
 }
diff --git a/vcl/qt5/Qt5Clipboard.cxx b/vcl/qt5/Qt5Clipboard.cxx
index a0fcc7ad5226..6ab93258bf09 100644
--- a/vcl/qt5/Qt5Clipboard.cxx
+++ b/vcl/qt5/Qt5Clipboard.cxx
@@ -23,7 +23,7 @@
 #include <cassert>
 #include <map>
 
-Qt5Clipboard::Qt5Clipboard(const OUString& aModeString, const QClipboard::Mode aMode)
+QtClipboard::QtClipboard(const OUString& aModeString, const QClipboard::Mode aMode)
     : cppu::WeakComponentImplHelper<css::datatransfer::clipboard::XSystemClipboard,
                                     css::datatransfer::clipboard::XFlushableClipboard,
                                     XServiceInfo>(m_aMutex)
@@ -34,15 +34,15 @@ Qt5Clipboard::Qt5Clipboard(const OUString& aModeString, const QClipboard::Mode a
 {
     assert(isSupported(m_aClipboardMode));
     // DirectConnection guarantees the changed slot runs in the same thread as the QClipboard
-    connect(QApplication::clipboard(), &QClipboard::changed, this, &Qt5Clipboard::handleChanged,
+    connect(QApplication::clipboard(), &QClipboard::changed, this, &QtClipboard::handleChanged,
             Qt::DirectConnection);
 
     // explicitly queue an event, so we can eventually ignore it
-    connect(this, &Qt5Clipboard::clearClipboard, this, &Qt5Clipboard::handleClearClipboard,
+    connect(this, &QtClipboard::clearClipboard, this, &QtClipboard::handleClearClipboard,
             Qt::QueuedConnection);
 }
 
-css::uno::Reference<css::uno::XInterface> Qt5Clipboard::create(const OUString& aModeString)
+css::uno::Reference<css::uno::XInterface> QtClipboard::create(const OUString& aModeString)
 {
     static const std::map<OUString, QClipboard::Mode> aNameToClipboardMap
         = { { "CLIPBOARD", QClipboard::Clipboard }, { "PRIMARY", QClipboard::Selection } };
@@ -51,26 +51,26 @@ css::uno::Reference<css::uno::XInterface> Qt5Clipboard::create(const OUString& a
 
     auto iter = aNameToClipboardMap.find(aModeString);
     if (iter != aNameToClipboardMap.end() && isSupported(iter->second))
-        return static_cast<cppu::OWeakObject*>(new Qt5Clipboard(aModeString, iter->second));
+        return static_cast<cppu::OWeakObject*>(new QtClipboard(aModeString, iter->second));
     SAL_WARN("vcl.qt5", "Ignoring unrecognized clipboard type: '" << aModeString << "'");
     return css::uno::Reference<css::uno::XInterface>();
 }
 
-void Qt5Clipboard::flushClipboard()
+void QtClipboard::flushClipboard()
 {
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     SolarMutexGuard g;
     pSalInst->RunInMainThread([this]() {
         if (!isOwner(m_aClipboardMode))
             return;
 
         QClipboard* pClipboard = QApplication::clipboard();
-        const Qt5MimeData* pQt5MimeData
-            = dynamic_cast<const Qt5MimeData*>(pClipboard->mimeData(m_aClipboardMode));
-        assert(pQt5MimeData);
+        const QtMimeData* pQtMimeData
+            = dynamic_cast<const QtMimeData*>(pClipboard->mimeData(m_aClipboardMode));
+        assert(pQtMimeData);
 
         QMimeData* pMimeCopy = nullptr;
-        if (pQt5MimeData && pQt5MimeData->deepCopy(&pMimeCopy))
+        if (pQtMimeData && pQtMimeData->deepCopy(&pMimeCopy))
         {
             m_bOwnClipboardChange = true;
             pClipboard->setMimeData(pMimeCopy, m_aClipboardMode);
@@ -79,7 +79,7 @@ void Qt5Clipboard::flushClipboard()
     });
 }
 
-css::uno::Reference<css::datatransfer::XTransferable> Qt5Clipboard::getContents()
+css::uno::Reference<css::datatransfer::XTransferable> QtClipboard::getContents()
 {
     osl::MutexGuard aGuard(m_aMutex);
 
@@ -89,28 +89,28 @@ css::uno::Reference<css::datatransfer::XTransferable> Qt5Clipboard::getContents(
     if (isOwner(m_aClipboardMode) && m_aContents.is())
         return m_aContents;
 
-    // check if we can still use the shared Qt5ClipboardTransferable
+    // check if we can still use the shared QtClipboardTransferable
     const QMimeData* pMimeData = QApplication::clipboard()->mimeData(m_aClipboardMode);
     if (m_aContents.is())
     {
-        const auto* pTrans = dynamic_cast<Qt5ClipboardTransferable*>(m_aContents.get());
+        const auto* pTrans = dynamic_cast<QtClipboardTransferable*>(m_aContents.get());
         assert(pTrans);
         if (pTrans && pTrans->mimeData() == pMimeData)
             return m_aContents;
     }
 
-    m_aContents = new Qt5ClipboardTransferable(m_aClipboardMode, pMimeData);
+    m_aContents = new QtClipboardTransferable(m_aClipboardMode, pMimeData);
     return m_aContents;
 }
 
-void Qt5Clipboard::handleClearClipboard()
+void QtClipboard::handleClearClipboard()
 {
     if (!m_bDoClear)
         return;
     QApplication::clipboard()->clear(m_aClipboardMode);
 }
 
-void Qt5Clipboard::setContents(
+void QtClipboard::setContents(
     const css::uno::Reference<css::datatransfer::XTransferable>& xTrans,
     const css::uno::Reference<css::datatransfer::clipboard::XClipboardOwner>& xClipboardOwner)
 {
@@ -126,7 +126,7 @@ void Qt5Clipboard::setContents(
     if (!m_bDoClear)
     {
         m_bOwnClipboardChange = true;
-        QApplication::clipboard()->setMimeData(new Qt5MimeData(m_aContents), m_aClipboardMode);
+        QApplication::clipboard()->setMimeData(new QtMimeData(m_aContents), m_aClipboardMode);
         m_bOwnClipboardChange = false;
     }
     else
@@ -143,7 +143,7 @@ void Qt5Clipboard::setContents(
         xOldOwner->lostOwnership(this, xOldContents);
 }
 
-void Qt5Clipboard::handleChanged(QClipboard::Mode aMode)
+void QtClipboard::handleChanged(QClipboard::Mode aMode)
 {
     if (aMode != m_aClipboardMode)
         return;
@@ -153,10 +153,10 @@ void Qt5Clipboard::handleChanged(QClipboard::Mode aMode)
     // QtWayland will send a second change notification (seemingly without any
     // trigger). And any C'n'P operation in the Qt file picker emits a signal,
     // with LO still holding the clipboard ownership, but internally having lost
-    // it. So ignore any signal, which still delivers the internal Qt5MimeData
+    // it. So ignore any signal, which still delivers the internal QtMimeData
     // as the clipboard content and is no "advertised" change.
     if (!m_bOwnClipboardChange && isOwner(aMode)
-        && dynamic_cast<const Qt5MimeData*>(QApplication::clipboard()->mimeData(aMode)))
+        && dynamic_cast<const QtMimeData*>(QApplication::clipboard()->mimeData(aMode)))
         return;
 
     css::uno::Reference<css::datatransfer::clipboard::XClipboardOwner> xOldOwner(m_aOwner);
@@ -181,30 +181,30 @@ void Qt5Clipboard::handleChanged(QClipboard::Mode aMode)
         listener->changedContents(aEv);
 }
 
-OUString Qt5Clipboard::getImplementationName() { return "com.sun.star.datatransfer.Qt5Clipboard"; }
+OUString QtClipboard::getImplementationName() { return "com.sun.star.datatransfer.QtClipboard"; }
 
-css::uno::Sequence<OUString> Qt5Clipboard::getSupportedServiceNames()
+css::uno::Sequence<OUString> QtClipboard::getSupportedServiceNames()
 {
     return { "com.sun.star.datatransfer.clipboard.SystemClipboard" };
 }
 
-sal_Bool Qt5Clipboard::supportsService(const OUString& ServiceName)
+sal_Bool QtClipboard::supportsService(const OUString& ServiceName)
 {
     return cppu::supportsService(this, ServiceName);
 }
 
-OUString Qt5Clipboard::getName() { return m_aClipboardName; }
+OUString QtClipboard::getName() { return m_aClipboardName; }
 
-sal_Int8 Qt5Clipboard::getRenderingCapabilities() { return 0; }
+sal_Int8 QtClipboard::getRenderingCapabilities() { return 0; }
 
-void Qt5Clipboard::addClipboardListener(
+void QtClipboard::addClipboardListener(
     const css::uno::Reference<css::datatransfer::clipboard::XClipboardListener>& listener)
 {
     osl::MutexGuard aGuard(m_aMutex);
     m_aListeners.push_back(listener);
 }
 
-void Qt5Clipboard::removeClipboardListener(
+void QtClipboard::removeClipboardListener(
     const css::uno::Reference<css::datatransfer::clipboard::XClipboardListener>& listener)
 {
     osl::MutexGuard aGuard(m_aMutex);
@@ -212,7 +212,7 @@ void Qt5Clipboard::removeClipboardListener(
                        m_aListeners.end());
 }
 
-bool Qt5Clipboard::isSupported(const QClipboard::Mode aMode)
+bool QtClipboard::isSupported(const QClipboard::Mode aMode)
 {
     const QClipboard* pClipboard = QApplication::clipboard();
     switch (aMode)
@@ -229,7 +229,7 @@ bool Qt5Clipboard::isSupported(const QClipboard::Mode aMode)
     return false;
 }
 
-bool Qt5Clipboard::isOwner(const QClipboard::Mode aMode)
+bool QtClipboard::isOwner(const QClipboard::Mode aMode)
 {
     if (!isSupported(aMode))
         return false;
diff --git a/vcl/qt5/Qt5Data.cxx b/vcl/qt5/Qt5Data.cxx
index 85efaefc1893..0b4c9dad8b00 100644
--- a/vcl/qt5/Qt5Data.cxx
+++ b/vcl/qt5/Qt5Data.cxx
@@ -155,7 +155,7 @@
 
 #include <unx/glyphcache.hxx>
 
-Qt5Data::Qt5Data(SalInstance* pInstance)
+QtData::QtData(SalInstance* pInstance)
     : GenericUnixSalData(pInstance)
 {
     ImplSVData* pSVData = ImplGetSVData();
@@ -174,7 +174,7 @@ Qt5Data::Qt5Data(SalInstance* pInstance)
 }
 
 // outline dtor b/c of FreetypeManager incomplete type
-Qt5Data::~Qt5Data() {}
+QtData::~QtData() {}
 
 static QCursor* getQCursorFromXBM(const unsigned char* pBitmap, const unsigned char* pMask,
                                   int nWidth, int nHeight, int nXHot, int nYHot)
@@ -194,7 +194,7 @@ static QCursor* getQCursorFromXBM(const unsigned char* pBitmap, const unsigned c
         pCursor = new QCursor(qt_enum);                                                            \
         break
 
-QCursor& Qt5Data::getCursor(PointerStyle ePointerStyle)
+QCursor& QtData::getCursor(PointerStyle ePointerStyle)
 {
     if (!m_aCursors[ePointerStyle])
     {
@@ -321,11 +321,11 @@ QCursor& Qt5Data::getCursor(PointerStyle ePointerStyle)
     return *m_aCursors[ePointerStyle];
 }
 
-void Qt5Data::ErrorTrapPush() {}
+void QtData::ErrorTrapPush() {}
 
-bool Qt5Data::ErrorTrapPop(bool /*bIgnoreError*/) { return false; }
+bool QtData::ErrorTrapPop(bool /*bIgnoreError*/) { return false; }
 
-bool Qt5Data::noNativeControls()
+bool QtData::noNativeControls()
 {
     static const bool bNoNative
         = ((nullptr != getenv("SAL_VCL_QT5_NO_NATIVE")) && (nullptr != ImplGetSVData())
diff --git a/vcl/qt5/Qt5DragAndDrop.cxx b/vcl/qt5/Qt5DragAndDrop.cxx
index 615b5d1f7e2a..184cf07a6c5e 100644
--- a/vcl/qt5/Qt5DragAndDrop.cxx
+++ b/vcl/qt5/Qt5DragAndDrop.cxx
@@ -23,15 +23,15 @@
 
 using namespace com::sun::star;
 
-Qt5DragSource::~Qt5DragSource() {}
+QtDragSource::~QtDragSource() {}
 
-void Qt5DragSource::deinitialize() { m_pFrame = nullptr; }
+void QtDragSource::deinitialize() { m_pFrame = nullptr; }
 
-sal_Bool Qt5DragSource::isDragImageSupported() { return true; }
+sal_Bool QtDragSource::isDragImageSupported() { return true; }
 
-sal_Int32 Qt5DragSource::getDefaultCursor(sal_Int8) { return 0; }
+sal_Int32 QtDragSource::getDefaultCursor(sal_Int8) { return 0; }
 
-void Qt5DragSource::initialize(const css::uno::Sequence<css::uno::Any>& rArguments)
+void QtDragSource::initialize(const css::uno::Sequence<css::uno::Any>& rArguments)
 {
     if (rArguments.getLength() < 2)
     {
@@ -48,11 +48,11 @@ void Qt5DragSource::initialize(const css::uno::Sequence<css::uno::Any>& rArgumen
                                     static_cast<OWeakObject*>(this));
     }
 
-    m_pFrame = reinterpret_cast<Qt5Frame*>(nFrame);
+    m_pFrame = reinterpret_cast<QtFrame*>(nFrame);
     m_pFrame->registerDragSource(this);
 }
 
-void Qt5DragSource::startDrag(
+void QtDragSource::startDrag(
     const datatransfer::dnd::DragGestureEvent& /*rEvent*/, sal_Int8 sourceActions,
     sal_Int32 /*cursor*/, sal_Int32 /*image*/,
     const css::uno::Reference<css::datatransfer::XTransferable>& rTrans,
@@ -63,7 +63,7 @@ void Qt5DragSource::startDrag(
     if (m_pFrame)
     {
         QDrag* drag = new QDrag(m_pFrame->GetQWidget());
-        drag->setMimeData(new Qt5MimeData(rTrans));
+        drag->setMimeData(new QtMimeData(rTrans));
         // just a reminder that exec starts a nested event loop, so everything after
         // this call is just executed, after D'n'D has finished!
         drag->exec(toQtDropActions(sourceActions), getPreferredDropAction(sourceActions));
@@ -76,7 +76,7 @@ void Qt5DragSource::startDrag(
     fire_dragEnd(datatransfer::dnd::DNDConstants::ACTION_NONE, false);
 }
 
-void Qt5DragSource::fire_dragEnd(sal_Int8 nAction, bool bDropSuccessful)
+void QtDragSource::fire_dragEnd(sal_Int8 nAction, bool bDropSuccessful)
 {
     if (!m_xListener.is())
         return;
@@ -90,22 +90,22 @@ void Qt5DragSource::fire_dragEnd(sal_Int8 nAction, bool bDropSuccessful)
     xListener->dragDropEnd(aEv);
 }
 
-OUString SAL_CALL Qt5DragSource::getImplementationName()
+OUString SAL_CALL QtDragSource::getImplementationName()
 {
-    return "com.sun.star.datatransfer.dnd.VclQt5DragSource";
+    return "com.sun.star.datatransfer.dnd.VclQtDragSource";
 }
 
-sal_Bool SAL_CALL Qt5DragSource::supportsService(OUString const& ServiceName)
+sal_Bool SAL_CALL QtDragSource::supportsService(OUString const& ServiceName)
 {
     return cppu::supportsService(this, ServiceName);
 }
 
-css::uno::Sequence<OUString> SAL_CALL Qt5DragSource::getSupportedServiceNames()
+css::uno::Sequence<OUString> SAL_CALL QtDragSource::getSupportedServiceNames()
 {
-    return { "com.sun.star.datatransfer.dnd.Qt5DragSource" };
+    return { "com.sun.star.datatransfer.dnd.QtDragSource" };
 }
 
-Qt5DropTarget::Qt5DropTarget()
+QtDropTarget::QtDropTarget()
     : WeakComponentImplHelper(m_aMutex)
     , m_pFrame(nullptr)
     , m_bActive(false)
@@ -113,30 +113,30 @@ Qt5DropTarget::Qt5DropTarget()
 {
 }
 
-OUString SAL_CALL Qt5DropTarget::getImplementationName()
+OUString SAL_CALL QtDropTarget::getImplementationName()
 {
-    return "com.sun.star.datatransfer.dnd.VclQt5DropTarget";
+    return "com.sun.star.datatransfer.dnd.VclQtDropTarget";
 }
 
-sal_Bool SAL_CALL Qt5DropTarget::supportsService(OUString const& ServiceName)
+sal_Bool SAL_CALL QtDropTarget::supportsService(OUString const& ServiceName)
 {
     return cppu::supportsService(this, ServiceName);
 }
 
-css::uno::Sequence<OUString> SAL_CALL Qt5DropTarget::getSupportedServiceNames()
+css::uno::Sequence<OUString> SAL_CALL QtDropTarget::getSupportedServiceNames()
 {
-    return { "com.sun.star.datatransfer.dnd.Qt5DropTarget" };
+    return { "com.sun.star.datatransfer.dnd.QtDropTarget" };
 }
 
-Qt5DropTarget::~Qt5DropTarget() {}
+QtDropTarget::~QtDropTarget() {}
 
-void Qt5DropTarget::deinitialize()
+void QtDropTarget::deinitialize()
 {
     m_pFrame = nullptr;
     m_bActive = false;
 }
 
-void Qt5DropTarget::initialize(const uno::Sequence<uno::Any>& rArguments)
+void QtDropTarget::initialize(const uno::Sequence<uno::Any>& rArguments)
 {
     if (rArguments.getLength() < 2)
     {
@@ -155,12 +155,12 @@ void Qt5DropTarget::initialize(const uno::Sequence<uno::Any>& rArguments)
 
     m_nDropAction = datatransfer::dnd::DNDConstants::ACTION_NONE;
 
-    m_pFrame = reinterpret_cast<Qt5Frame*>(nFrame);
+    m_pFrame = reinterpret_cast<QtFrame*>(nFrame);
     m_pFrame->registerDropTarget(this);
     m_bActive = true;
 }
 
-void Qt5DropTarget::addDropTargetListener(
+void QtDropTarget::addDropTargetListener(
     const uno::Reference<css::datatransfer::dnd::XDropTargetListener>& xListener)
 {
     ::osl::Guard<::osl::Mutex> aGuard(m_aMutex);
@@ -168,7 +168,7 @@ void Qt5DropTarget::addDropTargetListener(
     m_aListeners.push_back(xListener);
 }
 
-void Qt5DropTarget::removeDropTargetListener(
+void QtDropTarget::removeDropTargetListener(
     const uno::Reference<css::datatransfer::dnd::XDropTargetListener>& xListener)
 {
     ::osl::Guard<::osl::Mutex> aGuard(m_aMutex);
@@ -177,18 +177,18 @@ void Qt5DropTarget::removeDropTargetListener(
                        m_aListeners.end());
 }
 
-sal_Bool Qt5DropTarget::isActive() { return m_bActive; }
+sal_Bool QtDropTarget::isActive() { return m_bActive; }
 
-void Qt5DropTarget::setActive(sal_Bool bActive) { m_bActive = bActive; }
+void QtDropTarget::setActive(sal_Bool bActive) { m_bActive = bActive; }
 
-sal_Int8 Qt5DropTarget::getDefaultActions() { return m_nDefaultActions; }
+sal_Int8 QtDropTarget::getDefaultActions() { return m_nDefaultActions; }
 
-void Qt5DropTarget::setDefaultActions(sal_Int8 nDefaultActions)
+void QtDropTarget::setDefaultActions(sal_Int8 nDefaultActions)
 {
     m_nDefaultActions = nDefaultActions;
 }
 
-void Qt5DropTarget::fire_dragEnter(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtde)
+void QtDropTarget::fire_dragEnter(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtde)
 {
     osl::ClearableGuard<::osl::Mutex> aGuard(m_aMutex);
     std::vector<css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>> aListeners(
@@ -201,7 +201,7 @@ void Qt5DropTarget::fire_dragEnter(const css::datatransfer::dnd::DropTargetDragE
     }
 }
 
-void Qt5DropTarget::fire_dragOver(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtde)
+void QtDropTarget::fire_dragOver(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtde)
 {
     osl::ClearableGuard<::osl::Mutex> aGuard(m_aMutex);
     std::vector<css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>> aListeners(
@@ -212,7 +212,7 @@ void Qt5DropTarget::fire_dragOver(const css::datatransfer::dnd::DropTargetDragEn
         listener->dragOver(dtde);
 }
 
-void Qt5DropTarget::fire_drop(const css::datatransfer::dnd::DropTargetDropEvent& dtde)
+void QtDropTarget::fire_drop(const css::datatransfer::dnd::DropTargetDropEvent& dtde)
 {
     m_bDropSuccessful = true;
 
@@ -225,7 +225,7 @@ void Qt5DropTarget::fire_drop(const css::datatransfer::dnd::DropTargetDropEvent&
         listener->drop(dtde);
 }
 
-void Qt5DropTarget::fire_dragExit(const css::datatransfer::dnd::DropTargetEvent& dte)
+void QtDropTarget::fire_dragExit(const css::datatransfer::dnd::DropTargetEvent& dte)
 {
     osl::ClearableGuard<::osl::Mutex> aGuard(m_aMutex);
     std::vector<css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>> aListeners(
@@ -236,15 +236,15 @@ void Qt5DropTarget::fire_dragExit(const css::datatransfer::dnd::DropTargetEvent&
         listener->dragExit(dte);
 }
 
-void Qt5DropTarget::acceptDrag(sal_Int8 dragOperation) { m_nDropAction = dragOperation; }
+void QtDropTarget::acceptDrag(sal_Int8 dragOperation) { m_nDropAction = dragOperation; }
 
-void Qt5DropTarget::rejectDrag() { m_nDropAction = 0; }
+void QtDropTarget::rejectDrag() { m_nDropAction = 0; }
 
-void Qt5DropTarget::acceptDrop(sal_Int8 dropOperation) { m_nDropAction = dropOperation; }
+void QtDropTarget::acceptDrop(sal_Int8 dropOperation) { m_nDropAction = dropOperation; }
 
-void Qt5DropTarget::rejectDrop() { m_nDropAction = 0; }
+void QtDropTarget::rejectDrop() { m_nDropAction = 0; }
 
-void Qt5DropTarget::dropComplete(sal_Bool success)
+void QtDropTarget::dropComplete(sal_Bool success)
 {
     m_bDropSuccessful = (m_bDropSuccessful && success);
 }
diff --git a/vcl/qt5/Qt5FilePicker.cxx b/vcl/qt5/Qt5FilePicker.cxx
index 9a174a08c0c6..e2f733ca4fca 100644
--- a/vcl/qt5/Qt5FilePicker.cxx
+++ b/vcl/qt5/Qt5FilePicker.cxx
@@ -79,13 +79,13 @@ namespace
 uno::Sequence<OUString> FilePicker_getSupportedServiceNames()
 {
     return { "com.sun.star.ui.dialogs.FilePicker", "com.sun.star.ui.dialogs.SystemFilePicker",
-             "com.sun.star.ui.dialogs.Qt5FilePicker" };
+             "com.sun.star.ui.dialogs.QtFilePicker" };
 }
 }
 
-Qt5FilePicker::Qt5FilePicker(css::uno::Reference<css::uno::XComponentContext> const& context,
-                             QFileDialog::FileMode eMode, bool bUseNative)
-    : Qt5FilePicker_Base(m_aHelperMutex)
+QtFilePicker::QtFilePicker(css::uno::Reference<css::uno::XComponentContext> const& context,
+                           QFileDialog::FileMode eMode, bool bUseNative)
+    : QtFilePicker_Base(m_aHelperMutex)
     , m_context(context)
     , m_bIsFolderPicker(eMode == QFileDialog::Directory)
     , m_pParentWidget(nullptr)
@@ -118,10 +118,10 @@ Qt5FilePicker::Qt5FilePicker(css::uno::Reference<css::uno::XComponentContext> co
             SLOT(updateAutomaticFileExtension()));
 }
 
-Qt5FilePicker::~Qt5FilePicker()
+QtFilePicker::~QtFilePicker()
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this]() {
         // must delete it in main thread, otherwise
@@ -131,31 +131,31 @@ Qt5FilePicker::~Qt5FilePicker()
 }
 
 void SAL_CALL
-Qt5FilePicker::addFilePickerListener(const uno::Reference<XFilePickerListener>& xListener)
+QtFilePicker::addFilePickerListener(const uno::Reference<XFilePickerListener>& xListener)
 {
     SolarMutexGuard aGuard;
     m_xListener = xListener;
 }
 
-void SAL_CALL Qt5FilePicker::removeFilePickerListener(const uno::Reference<XFilePickerListener>&)
+void SAL_CALL QtFilePicker::removeFilePickerListener(const uno::Reference<XFilePickerListener>&)
 {
     SolarMutexGuard aGuard;
     m_xListener.clear();
 }
 
-void SAL_CALL Qt5FilePicker::setTitle(const OUString& title)
+void SAL_CALL QtFilePicker::setTitle(const OUString& title)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread(
         [this, &title]() { m_pFileDialog->setWindowTitle(toQString(title)); });
 }
 
-sal_Int16 SAL_CALL Qt5FilePicker::execute()
+sal_Int16 SAL_CALL QtFilePicker::execute()
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -170,7 +170,7 @@ sal_Int16 SAL_CALL Qt5FilePicker::execute()
         vcl::Window* pWindow = ::Application::GetActiveTopWindow();
         if (pWindow)
         {
-            Qt5Frame* pFrame = dynamic_cast<Qt5Frame*>(pWindow->ImplGetFrame());
+            QtFrame* pFrame = dynamic_cast<QtFrame*>(pWindow->ImplGetFrame());
             assert(pFrame);
             if (pFrame)
                 pTransientParent = pFrame->asChild();
@@ -200,10 +200,10 @@ sal_Int16 SAL_CALL Qt5FilePicker::execute()
     return ExecutableDialogResults::OK;
 }
 
-void SAL_CALL Qt5FilePicker::setMultiSelectionMode(sal_Bool multiSelect)
+void SAL_CALL QtFilePicker::setMultiSelectionMode(sal_Bool multiSelect)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, multiSelect]() {
         if (m_bIsFolderPicker || m_pFileDialog->acceptMode() == QFileDialog::AcceptSave)
@@ -214,18 +214,18 @@ void SAL_CALL Qt5FilePicker::setMultiSelectionMode(sal_Bool multiSelect)
     });
 }
 
-void SAL_CALL Qt5FilePicker::setDefaultName(const OUString& name)
+void SAL_CALL QtFilePicker::setDefaultName(const OUString& name)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, &name]() { m_pFileDialog->selectFile(toQString(name)); });
 }
 
-void SAL_CALL Qt5FilePicker::setDisplayDirectory(const OUString& dir)
+void SAL_CALL QtFilePicker::setDisplayDirectory(const OUString& dir)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, &dir]() {
         QString qDir(toQString(dir));
@@ -233,18 +233,18 @@ void SAL_CALL Qt5FilePicker::setDisplayDirectory(const OUString& dir)
     });
 }
 
-OUString SAL_CALL Qt5FilePicker::getDisplayDirectory()
+OUString SAL_CALL QtFilePicker::getDisplayDirectory()
 {
     SolarMutexGuard g;
     OUString ret;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread(
         [&ret, this]() { ret = toOUString(m_pFileDialog->directoryUrl().toString()); });
     return ret;
 }
 
-uno::Sequence<OUString> SAL_CALL Qt5FilePicker::getFiles()
+uno::Sequence<OUString> SAL_CALL QtFilePicker::getFiles()
 {
     uno::Sequence<OUString> seq = getSelectedFiles();
     if (seq.getLength() > 1)
@@ -252,11 +252,11 @@ uno::Sequence<OUString> SAL_CALL Qt5FilePicker::getFiles()
     return seq;
 }
 
-uno::Sequence<OUString> SAL_CALL Qt5FilePicker::getSelectedFiles()
+uno::Sequence<OUString> SAL_CALL QtFilePicker::getSelectedFiles()
 {
     SolarMutexGuard g;
     QList<QUrl> urls;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([&urls, this]() { urls = m_pFileDialog->selectedUrls(); });
 
@@ -289,10 +289,10 @@ uno::Sequence<OUString> SAL_CALL Qt5FilePicker::getSelectedFiles()
     return seq;
 }
 
-void SAL_CALL Qt5FilePicker::appendFilter(const OUString& title, const OUString& filter)
+void SAL_CALL QtFilePicker::appendFilter(const OUString& title, const OUString& filter)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -304,7 +304,7 @@ void SAL_CALL Qt5FilePicker::appendFilter(const OUString& title, const OUString&
     QString sTitle = toQString(title).replace("/", "\\/");
 
     QString sFilterName = sTitle;
-    // the Qt5 non-native file picker adds the extensions to the filter title, so strip them
+    // the Qt non-native file picker adds the extensions to the filter title, so strip them
     if (m_pFileDialog->testOption(QFileDialog::DontUseNativeDialog))
     {
         int pos = sFilterName.indexOf(" (");
@@ -325,21 +325,21 @@ void SAL_CALL Qt5FilePicker::appendFilter(const OUString& title, const OUString&
     m_aNamedFilterToExtensionMap[m_aNamedFilterList.constLast()] = sGlobFilter;
 }
 
-void SAL_CALL Qt5FilePicker::setCurrentFilter(const OUString& title)
+void SAL_CALL QtFilePicker::setCurrentFilter(const OUString& title)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, &title]() {
         m_aCurrentFilter = m_aTitleToFilterMap.value(toQString(title).replace("/", "\\/"));
     });
 }
 
-OUString SAL_CALL Qt5FilePicker::getCurrentFilter()
+OUString SAL_CALL QtFilePicker::getCurrentFilter()
 {
     SolarMutexGuard g;
     QString filter;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([&filter, this]() {
         filter = m_aTitleToFilterMap.key(m_pFileDialog->selectedNameFilter());
@@ -350,11 +350,11 @@ OUString SAL_CALL Qt5FilePicker::getCurrentFilter()
     return toOUString(filter);
 }
 
-void SAL_CALL Qt5FilePicker::appendFilterGroup(const OUString& rGroupTitle,
-                                               const uno::Sequence<beans::StringPair>& filters)
+void SAL_CALL QtFilePicker::appendFilterGroup(const OUString& rGroupTitle,
+                                              const uno::Sequence<beans::StringPair>& filters)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -371,7 +371,7 @@ void SAL_CALL Qt5FilePicker::appendFilterGroup(const OUString& rGroupTitle,
     }
 }
 
-uno::Any Qt5FilePicker::handleGetListValue(const QComboBox* pWidget, sal_Int16 nControlAction)
+uno::Any QtFilePicker::handleGetListValue(const QComboBox* pWidget, sal_Int16 nControlAction)
 {
     uno::Any aAny;
     switch (nControlAction)
@@ -404,8 +404,8 @@ uno::Any Qt5FilePicker::handleGetListValue(const QComboBox* pWidget, sal_Int16 n
     return aAny;
 }
 
-void Qt5FilePicker::handleSetListValue(QComboBox* pWidget, sal_Int16 nControlAction,
-                                       const uno::Any& rValue)
+void QtFilePicker::handleSetListValue(QComboBox* pWidget, sal_Int16 nControlAction,
+                                      const uno::Any& rValue)
 {
     switch (nControlAction)
     {
@@ -452,11 +452,11 @@ void Qt5FilePicker::handleSetListValue(QComboBox* pWidget, sal_Int16 nControlAct
     pWidget->setEnabled(pWidget->count() > 0);
 }
 
-void SAL_CALL Qt5FilePicker::setValue(sal_Int16 controlId, sal_Int16 nControlAction,
-                                      const uno::Any& value)
+void SAL_CALL QtFilePicker::setValue(sal_Int16 controlId, sal_Int16 nControlAction,
+                                     const uno::Any& value)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -483,10 +483,10 @@ void SAL_CALL Qt5FilePicker::setValue(sal_Int16 controlId, sal_Int16 nControlAct
         SAL_WARN("vcl.qt5", "set value on unknown control " << controlId);
 }
 
-uno::Any SAL_CALL Qt5FilePicker::getValue(sal_Int16 controlId, sal_Int16 nControlAction)
+uno::Any SAL_CALL QtFilePicker::getValue(sal_Int16 controlId, sal_Int16 nControlAction)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -517,10 +517,10 @@ uno::Any SAL_CALL Qt5FilePicker::getValue(sal_Int16 controlId, sal_Int16 nContro
     return res;
 }
 
-void SAL_CALL Qt5FilePicker::enableControl(sal_Int16 controlId, sal_Bool enable)
+void SAL_CALL QtFilePicker::enableControl(sal_Int16 controlId, sal_Bool enable)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, controlId, enable]() {
         if (m_aCustomWidgetsMap.contains(controlId))
@@ -530,10 +530,10 @@ void SAL_CALL Qt5FilePicker::enableControl(sal_Int16 controlId, sal_Bool enable)
     });
 }
 
-void SAL_CALL Qt5FilePicker::setLabel(sal_Int16 controlId, const OUString& label)
+void SAL_CALL QtFilePicker::setLabel(sal_Int16 controlId, const OUString& label)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -551,10 +551,10 @@ void SAL_CALL Qt5FilePicker::setLabel(sal_Int16 controlId, const OUString& label
         SAL_WARN("vcl.qt5", "set label on unknown control " << controlId);
 }
 
-OUString SAL_CALL Qt5FilePicker::getLabel(sal_Int16 controlId)
+OUString SAL_CALL QtFilePicker::getLabel(sal_Int16 controlId)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -576,7 +576,7 @@ OUString SAL_CALL Qt5FilePicker::getLabel(sal_Int16 controlId)
     return toOUString(label);
 }
 
-QString Qt5FilePicker::getResString(TranslateId pResId)
+QString QtFilePicker::getResString(TranslateId pResId)
 {
     QString aResString;
 
@@ -588,7 +588,7 @@ QString Qt5FilePicker::getResString(TranslateId pResId)
     return aResString.replace('~', '&');
 }
 
-void Qt5FilePicker::addCustomControl(sal_Int16 controlId)
+void QtFilePicker::addCustomControl(sal_Int16 controlId)
 {
     QWidget* widget = nullptr;
     QLabel* label = nullptr;
@@ -690,7 +690,7 @@ void Qt5FilePicker::addCustomControl(sal_Int16 controlId)
     }
 }
 
-void SAL_CALL Qt5FilePicker::initialize(const uno::Sequence<uno::Any>& args)
+void SAL_CALL QtFilePicker::initialize(const uno::Sequence<uno::Any>& args)
 {
     // parameter checking
     uno::Any arg;
@@ -707,7 +707,7 @@ void SAL_CALL Qt5FilePicker::initialize(const uno::Sequence<uno::Any>& args)
     }
 
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -847,12 +847,12 @@ void SAL_CALL Qt5FilePicker::initialize(const uno::Sequence<uno::Any>& args)
               return pData && tools::Long(pData->GetWindowHandle(pFrame)) == aWindowHandle;
           });
     if (it != pFrames.end())
-        m_pParentWidget = static_cast<Qt5Frame*>(*it)->asChild();
+        m_pParentWidget = static_cast<QtFrame*>(*it)->asChild();
 }
 
-void SAL_CALL Qt5FilePicker::cancel() { m_pFileDialog->reject(); }
+void SAL_CALL QtFilePicker::cancel() { m_pFileDialog->reject(); }
 
-void SAL_CALL Qt5FilePicker::disposing(const lang::EventObject& rEvent)
+void SAL_CALL QtFilePicker::disposing(const lang::EventObject& rEvent)
 {
     uno::Reference<XFilePickerListener> xFilePickerListener(rEvent.Source, uno::UNO_QUERY);
 
@@ -862,33 +862,33 @@ void SAL_CALL Qt5FilePicker::disposing(const lang::EventObject& rEvent)
     }
 }
 
-void SAL_CALL Qt5FilePicker::queryTermination(const css::lang::EventObject&)
+void SAL_CALL QtFilePicker::queryTermination(const css::lang::EventObject&)
 {
     throw css::frame::TerminationVetoException();
 }
 
-void SAL_CALL Qt5FilePicker::notifyTermination(const css::lang::EventObject&)
+void SAL_CALL QtFilePicker::notifyTermination(const css::lang::EventObject&)
 {
     SolarMutexGuard aGuard;
     m_pFileDialog->reject();
 }
 
-OUString SAL_CALL Qt5FilePicker::getImplementationName()
+OUString SAL_CALL QtFilePicker::getImplementationName()
 {
-    return "com.sun.star.ui.dialogs.Qt5FilePicker";
+    return "com.sun.star.ui.dialogs.QtFilePicker";
 }
 
-sal_Bool SAL_CALL Qt5FilePicker::supportsService(const OUString& ServiceName)
+sal_Bool SAL_CALL QtFilePicker::supportsService(const OUString& ServiceName)
 {
     return cppu::supportsService(this, ServiceName);
 }
 
-uno::Sequence<OUString> SAL_CALL Qt5FilePicker::getSupportedServiceNames()
+uno::Sequence<OUString> SAL_CALL QtFilePicker::getSupportedServiceNames()
 {
     return FilePicker_getSupportedServiceNames();
 }
 
-void Qt5FilePicker::updateAutomaticFileExtension()
+void QtFilePicker::updateAutomaticFileExtension()
 {
     bool bSetAutoExtension
         = getValue(CHECKBOX_AUTOEXTENSION, ControlActions::GET_SELECTED_ITEM).get<bool>();
@@ -915,7 +915,7 @@ void Qt5FilePicker::updateAutomaticFileExtension()
         m_pFileDialog->setDefaultSuffix("");
 }
 
-void Qt5FilePicker::filterSelected(const QString&)
+void QtFilePicker::filterSelected(const QString&)
 {
     FilePickerEvent aEvent;
     aEvent.ElementId = LISTBOX_FILTER;
@@ -924,7 +924,7 @@ void Qt5FilePicker::filterSelected(const QString&)
         m_xListener->controlStateChanged(aEvent);
 }
 
-void Qt5FilePicker::currentChanged(const QString&)
+void QtFilePicker::currentChanged(const QString&)
 {
     FilePickerEvent aEvent;
     SAL_INFO("vcl.qt5", "file selection changed");
@@ -932,7 +932,7 @@ void Qt5FilePicker::currentChanged(const QString&)
         m_xListener->fileSelectionChanged(aEvent);
 }
 
-OUString Qt5FilePicker::getDirectory()
+OUString QtFilePicker::getDirectory()
 {
     uno::Sequence<OUString> seq = getSelectedFiles();
     if (seq.getLength() > 1)
@@ -940,6 +940,6 @@ OUString Qt5FilePicker::getDirectory()
     return seq[0];
 }
 
-void Qt5FilePicker::setDescription(const OUString&) {}
+void QtFilePicker::setDescription(const OUString&) {}
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5Font.cxx b/vcl/qt5/Qt5Font.cxx
index bbf99f92ef61..a230ea1560e7 100644
--- a/vcl/qt5/Qt5Font.cxx
+++ b/vcl/qt5/Qt5Font.cxx
@@ -25,7 +25,7 @@
 #include <QtGui/QFont>
 #include <QtGui/QRawFont>
 
-static inline void applyWeight(Qt5Font& rFont, FontWeight eWeight)
+static inline void applyWeight(QtFont& rFont, FontWeight eWeight)
 {
     switch (eWeight)
     {
@@ -63,7 +63,7 @@ static inline void applyWeight(Qt5Font& rFont, FontWeight eWeight)
     }
 }
 
-static inline void applyStretch(Qt5Font& rFont, FontWidth eWidthType)
+static inline void applyStretch(QtFont& rFont, FontWidth eWidthType)
 {
     switch (eWidthType)
     {
@@ -102,7 +102,7 @@ static inline void applyStretch(Qt5Font& rFont, FontWidth eWidthType)
     }
 }
 
-static inline void applyStyle(Qt5Font& rFont, FontItalic eItalic)
+static inline void applyStyle(QtFont& rFont, FontItalic eItalic)
 {
     switch (eItalic)
     {
@@ -120,7 +120,7 @@ static inline void applyStyle(Qt5Font& rFont, FontItalic eItalic)
     }
 }
 
-Qt5Font::Qt5Font(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
+QtFont::QtFont(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
     : LogicalFontInstance(rPFF, rFSP)
 {
     setFamily(toQString(rPFF.GetFamilyName()));
@@ -135,7 +135,7 @@ static hb_blob_t* getFontTable(hb_face_t*, hb_tag_t nTableTag, void* pUserData)
     char pTagName[5];
     LogicalFontInstance::DecodeOpenTypeTag(nTableTag, pTagName);
 
-    Qt5Font* pFont = static_cast<Qt5Font*>(pUserData);
+    QtFont* pFont = static_cast<QtFont*>(pUserData);
     QRawFont aRawFont(QRawFont::fromFont(*pFont));
     QByteArray aTable = aRawFont.fontTable(pTagName);
     const sal_uInt32 nLength = aTable.size();
@@ -146,14 +146,14 @@ static hb_blob_t* getFontTable(hb_face_t*, hb_tag_t nTableTag, void* pUserData)
     return pBlob;
 }
 
-hb_font_t* Qt5Font::ImplInitHbFont()
+hb_font_t* QtFont::ImplInitHbFont()
 {
     return InitHbFont(hb_face_create_for_tables(getFontTable, this, nullptr));
 }
 
-bool Qt5Font::GetGlyphOutline(sal_GlyphId, basegfx::B2DPolyPolygon&, bool) const { return false; }
+bool QtFont::GetGlyphOutline(sal_GlyphId, basegfx::B2DPolyPolygon&, bool) const { return false; }
 
-bool Qt5Font::ImplGetGlyphBoundRect(sal_GlyphId nId, tools::Rectangle& rRect, bool) const
+bool QtFont::ImplGetGlyphBoundRect(sal_GlyphId nId, tools::Rectangle& rRect, bool) const
 {
     QRawFont aRawFont(QRawFont::fromFont(*this));
     rRect = toRectangle(aRawFont.boundingRect(nId).toAlignedRect());
diff --git a/vcl/qt5/Qt5FontFace.cxx b/vcl/qt5/Qt5FontFace.cxx
index 6168811daea8..b690c6abcf4f 100644
--- a/vcl/qt5/Qt5FontFace.cxx
+++ b/vcl/qt5/Qt5FontFace.cxx
@@ -38,7 +38,7 @@
 
 using namespace vcl;
 
-Qt5FontFace::Qt5FontFace(const Qt5FontFace& rSrc)
+QtFontFace::QtFontFace(const QtFontFace& rSrc)
     : PhysicalFontFace(rSrc)
     , m_aFontId(rSrc.m_aFontId)
     , m_eFontIdType(rSrc.m_eFontIdType)
@@ -47,7 +47,7 @@ Qt5FontFace::Qt5FontFace(const Qt5FontFace& rSrc)
         m_xCharMap = rSrc.m_xCharMap;
 }
 
-FontWeight Qt5FontFace::toFontWeight(const int nWeight)
+FontWeight QtFontFace::toFontWeight(const int nWeight)
 {
     if (nWeight <= QFont::Thin)
         return WEIGHT_THIN;
@@ -68,7 +68,7 @@ FontWeight Qt5FontFace::toFontWeight(const int nWeight)
     return WEIGHT_BLACK;
 }
 
-FontWidth Qt5FontFace::toFontWidth(const int nStretch)
+FontWidth QtFontFace::toFontWidth(const int nStretch)
 {
     if (nStretch == 0) // QFont::AnyStretch since Qt 5.8
         return WIDTH_DONTKNOW;
@@ -91,7 +91,7 @@ FontWidth Qt5FontFace::toFontWidth(const int nStretch)
     return WIDTH_ULTRA_EXPANDED;
 }
 
-FontItalic Qt5FontFace::toFontItalic(const QFont::Style eStyle)
+FontItalic QtFontFace::toFontItalic(const QFont::Style eStyle)
 {
     switch (eStyle)
     {
@@ -106,7 +106,7 @@ FontItalic Qt5FontFace::toFontItalic(const QFont::Style eStyle)
     return ITALIC_NONE;
 }
 
-void Qt5FontFace::fillAttributesFromQFont(const QFont& rFont, FontAttributes& rFA)
+void QtFontFace::fillAttributesFromQFont(const QFont& rFont, FontAttributes& rFA)
 {
     QFontInfo aFontInfo(rFont);
 
@@ -115,19 +115,19 @@ void Qt5FontFace::fillAttributesFromQFont(const QFont& rFont, FontAttributes& rF
         rFA.SetSymbolFlag(true);
     rFA.SetStyleName(toOUString(aFontInfo.styleName()));
     rFA.SetPitch(aFontInfo.fixedPitch() ? PITCH_FIXED : PITCH_VARIABLE);
-    rFA.SetWeight(Qt5FontFace::toFontWeight(aFontInfo.weight()));
-    rFA.SetItalic(Qt5FontFace::toFontItalic(aFontInfo.style()));
-    rFA.SetWidthType(Qt5FontFace::toFontWidth(rFont.stretch()));
+    rFA.SetWeight(QtFontFace::toFontWeight(aFontInfo.weight()));
+    rFA.SetItalic(QtFontFace::toFontItalic(aFontInfo.style()));
+    rFA.SetWidthType(QtFontFace::toFontWidth(rFont.stretch()));
 }
 
-Qt5FontFace* Qt5FontFace::fromQFont(const QFont& rFont)
+QtFontFace* QtFontFace::fromQFont(const QFont& rFont)
 {
     FontAttributes aFA;
     fillAttributesFromQFont(rFont, aFA);
-    return new Qt5FontFace(aFA, rFont.toString(), FontIdType::Font);
+    return new QtFontFace(aFA, rFont.toString(), FontIdType::Font);
 }
 
-Qt5FontFace* Qt5FontFace::fromQFontDatabase(const QString& aFamily, const QString& aStyle)
+QtFontFace* QtFontFace::fromQFontDatabase(const QString& aFamily, const QString& aStyle)
 {
     QFontDatabase aFDB;
     FontAttributes aFA;
@@ -137,7 +137,7 @@ Qt5FontFace* Qt5FontFace::fromQFontDatabase(const QString& aFamily, const QStrin
         aFA.SetSymbolFlag(true);
     aFA.SetStyleName(toOUString(aStyle));
     aFA.SetPitch(aFDB.isFixedPitch(aFamily, aStyle) ? PITCH_FIXED : PITCH_VARIABLE);
-    aFA.SetWeight(Qt5FontFace::toFontWeight(aFDB.weight(aFamily, aStyle)));
+    aFA.SetWeight(QtFontFace::toFontWeight(aFDB.weight(aFamily, aStyle)));
     aFA.SetItalic(aFDB.italic(aFamily, aStyle) ? ITALIC_NORMAL : ITALIC_NONE);
 
     int nPointSize = 0;
@@ -145,12 +145,12 @@ Qt5FontFace* Qt5FontFace::fromQFontDatabase(const QString& aFamily, const QStrin
     if (!aPointList.empty())
         nPointSize = aPointList[0];
 
-    return new Qt5FontFace(aFA, aFamily + "," + aStyle + "," + QString::number(nPointSize),
-                           FontIdType::FontDB);
+    return new QtFontFace(aFA, aFamily + "," + aStyle + "," + QString::number(nPointSize),
+                          FontIdType::FontDB);
 }
 
-Qt5FontFace::Qt5FontFace(const FontAttributes& rFA, const QString& rFontID,
-                         const FontIdType eFontIdType)
+QtFontFace::QtFontFace(const FontAttributes& rFA, const QString& rFontID,
+                       const FontIdType eFontIdType)
     : PhysicalFontFace(rFA)
     , m_aFontId(rFontID)
     , m_eFontIdType(eFontIdType)
@@ -158,9 +158,9 @@ Qt5FontFace::Qt5FontFace(const FontAttributes& rFA, const QString& rFontID,
 {
 }
 
-sal_IntPtr Qt5FontFace::GetFontId() const { return reinterpret_cast<sal_IntPtr>(&m_aFontId); }
+sal_IntPtr QtFontFace::GetFontId() const { return reinterpret_cast<sal_IntPtr>(&m_aFontId); }
 
-QFont Qt5FontFace::CreateFont() const
+QFont QtFontFace::CreateFont() const
 {
     QFont aFont;
     switch (m_eFontIdType)
@@ -185,12 +185,12 @@ QFont Qt5FontFace::CreateFont() const
 }
 
 rtl::Reference<LogicalFontInstance>
-Qt5FontFace::CreateFontInstance(const vcl::font::FontSelectPattern& rFSD) const
+QtFontFace::CreateFontInstance(const vcl::font::FontSelectPattern& rFSD) const
 {
-    return new Qt5Font(*this, rFSD);
+    return new QtFont(*this, rFSD);
 }
 
-FontCharMapRef Qt5FontFace::GetFontCharMap() const
+FontCharMapRef QtFontFace::GetFontCharMap() const
 {
     if (m_xCharMap.is())
         return m_xCharMap;
@@ -212,7 +212,7 @@ FontCharMapRef Qt5FontFace::GetFontCharMap() const
     return m_xCharMap;
 }
 
-bool Qt5FontFace::GetFontCapabilities(vcl::FontCapabilities& rFontCapabilities) const
+bool QtFontFace::GetFontCapabilities(vcl::FontCapabilities& rFontCapabilities) const
 {
     // read this only once per font
     if (m_bFontCapabilitiesRead)
diff --git a/vcl/qt5/Qt5Frame.cxx b/vcl/qt5/Qt5Frame.cxx
index 43ca9cdbf802..7f1bf041ae20 100644
--- a/vcl/qt5/Qt5Frame.cxx
+++ b/vcl/qt5/Qt5Frame.cxx
@@ -76,7 +76,7 @@ static xcb_atom_t g_aXcbClientLeaderAtom = 0;
 static void SvpDamageHandler(void* handle, sal_Int32 nExtentsX, sal_Int32 nExtentsY,
                              sal_Int32 nExtentsWidth, sal_Int32 nExtentsHeight)
 {
-    Qt5Frame* pThis = static_cast<Qt5Frame*>(handle);
+    QtFrame* pThis = static_cast<QtFrame*>(handle);
     pThis->Damage(nExtentsX, nExtentsY, nExtentsWidth, nExtentsHeight);
 }
 
@@ -102,7 +102,7 @@ sal_Int32 screenNumber(const QScreen* pScreen)
 }
 }
 
-Qt5Frame::Qt5Frame(Qt5Frame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
+QtFrame::QtFrame(QtFrame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
     : m_pTopLevel(nullptr)
     , m_bUseCairo(bUseCairo)
     , m_bNullRegion(true)
@@ -120,7 +120,7 @@ Qt5Frame::Qt5Frame(Qt5Frame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
 #endif
     , m_nInputLanguage(LANGUAGE_DONTKNOW)
 {
-    Qt5Instance* pInst = static_cast<Qt5Instance*>(GetSalData()->m_pInstance);
+    QtInstance* pInst = static_cast<QtInstance*>(GetSalData()->m_pInstance);
     pInst->insertFrame(this);
 
     m_aDamageHandler.handle = this;
@@ -166,13 +166,13 @@ Qt5Frame::Qt5Frame(Qt5Frame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
 
     if (aWinFlags == Qt::Window)
     {
-        m_pTopLevel = new Qt5MainWindow(*this, aWinFlags);
-        m_pQWidget = new Qt5Widget(*this, aWinFlags);
+        m_pTopLevel = new QtMainWindow(*this, aWinFlags);
+        m_pQWidget = new QtWidget(*this, aWinFlags);
         m_pTopLevel->setCentralWidget(m_pQWidget);
         m_pTopLevel->setFocusProxy(m_pQWidget);
     }
     else
-        m_pQWidget = new Qt5Widget(*this, aWinFlags);
+        m_pQWidget = new QtWidget(*this, aWinFlags);
 
     if (pParent && !(pParent->m_nStyle & SalFrameStyleFlags::PLUG))
     {
@@ -215,7 +215,7 @@ Qt5Frame::Qt5Frame(Qt5Frame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo)
     fixICCCMwindowGroup();
 }
 
-void Qt5Frame::fixICCCMwindowGroup()
+void QtFrame::fixICCCMwindowGroup()
 {
 #if QT5_USING_X11 && QT5_HAVE_XCB_ICCCM
     // older Qt5 just sets WM_CLIENT_LEADER, but not the XCB_ICCCM_WM_HINT_WINDOW_GROUP
@@ -278,22 +278,22 @@ void Qt5Frame::fixICCCMwindowGroup()
 #endif
 }
 
-Qt5Frame::~Qt5Frame()
+QtFrame::~QtFrame()
 {
-    Qt5Instance* pInst = static_cast<Qt5Instance*>(GetSalData()->m_pInstance);
+    QtInstance* pInst = static_cast<QtInstance*>(GetSalData()->m_pInstance);
     pInst->eraseFrame(this);
     delete asChild();
     m_aSystemData.aShellWindow = 0;
 }
 
-void Qt5Frame::Damage(sal_Int32 nExtentsX, sal_Int32 nExtentsY, sal_Int32 nExtentsWidth,
-                      sal_Int32 nExtentsHeight) const
+void QtFrame::Damage(sal_Int32 nExtentsX, sal_Int32 nExtentsY, sal_Int32 nExtentsWidth,
+                     sal_Int32 nExtentsHeight) const
 {
     m_pQWidget->update(scaledQRect(QRect(nExtentsX, nExtentsY, nExtentsWidth, nExtentsHeight),
                                    1 / devicePixelRatioF()));
 }
 
-SalGraphics* Qt5Frame::AcquireGraphics()
+SalGraphics* QtFrame::AcquireGraphics()
 {
     if (m_bGraphicsInUse)
         return nullptr;
@@ -305,54 +305,54 @@ SalGraphics* Qt5Frame::AcquireGraphics()
         if (!m_pSvpGraphics)
         {
             QSize aSize = m_pQWidget->size() * devicePixelRatioF();
-            m_pSvpGraphics.reset(new Qt5SvpGraphics(this));
+            m_pSvpGraphics.reset(new QtSvpGraphics(this));
             m_pSurface.reset(
                 cairo_image_surface_create(CAIRO_FORMAT_ARGB32, aSize.width(), aSize.height()));
             m_pSvpGraphics->setSurface(m_pSurface.get(),
                                        basegfx::B2IVector(aSize.width(), aSize.height()));
-            cairo_surface_set_user_data(m_pSurface.get(), Qt5SvpGraphics::getDamageKey(),
+            cairo_surface_set_user_data(m_pSurface.get(), QtSvpGraphics::getDamageKey(),
                                         &m_aDamageHandler, nullptr);
         }
         return m_pSvpGraphics.get();
     }
     else
     {
-        if (!m_pQt5Graphics)
+        if (!m_pQtGraphics)
         {
-            m_pQt5Graphics.reset(new Qt5Graphics(this));
+            m_pQtGraphics.reset(new QtGraphics(this));
             m_pQImage.reset(
-                new QImage(m_pQWidget->size() * devicePixelRatioF(), Qt5_DefaultFormat32));
+                new QImage(m_pQWidget->size() * devicePixelRatioF(), Qt_DefaultFormat32));
             m_pQImage->fill(Qt::transparent);
-            m_pQt5Graphics->ChangeQImage(m_pQImage.get());
+            m_pQtGraphics->ChangeQImage(m_pQImage.get());
         }
-        return m_pQt5Graphics.get();
+        return m_pQtGraphics.get();
     }
 }
 
-void Qt5Frame::ReleaseGraphics(SalGraphics* pSalGraph)
+void QtFrame::ReleaseGraphics(SalGraphics* pSalGraph)
 {
     (void)pSalGraph;
     if (m_bUseCairo)
         assert(pSalGraph == m_pSvpGraphics.get());
     else
-        assert(pSalGraph == m_pQt5Graphics.get());
+        assert(pSalGraph == m_pQtGraphics.get());
     m_bGraphicsInUse = false;
 }
 
-bool Qt5Frame::PostEvent(std::unique_ptr<ImplSVEvent> pData)
+bool QtFrame::PostEvent(std::unique_ptr<ImplSVEvent> pData)
 {
-    Qt5Instance* pInst = static_cast<Qt5Instance*>(GetSalData()->m_pInstance);
+    QtInstance* pInst = static_cast<QtInstance*>(GetSalData()->m_pInstance);
     pInst->PostEvent(this, pData.release(), SalEvent::UserEvent);
     return true;
 }
 
-QWidget* Qt5Frame::asChild() const { return m_pTopLevel ? m_pTopLevel : m_pQWidget; }
+QWidget* QtFrame::asChild() const { return m_pTopLevel ? m_pTopLevel : m_pQWidget; }
 
-qreal Qt5Frame::devicePixelRatioF() const { return asChild()->devicePixelRatioF(); }
+qreal QtFrame::devicePixelRatioF() const { return asChild()->devicePixelRatioF(); }
 
-bool Qt5Frame::isWindow() const { return asChild()->isWindow(); }
+bool QtFrame::isWindow() const { return asChild()->isWindow(); }
 
-QWindow* Qt5Frame::windowHandle() const
+QWindow* QtFrame::windowHandle() const
 {
     // set attribute 'Qt::WA_NativeWindow' first to make sure a window handle actually exists
     QWidget* pChild = asChild();
@@ -360,27 +360,27 @@ QWindow* Qt5Frame::windowHandle() const
     return pChild->windowHandle();
 }
 
-QScreen* Qt5Frame::screen() const
+QScreen* QtFrame::screen() const
 {
     QWindow* const pWindow = windowHandle();
     return pWindow ? pWindow->screen() : nullptr;
 }
 
-bool Qt5Frame::isMinimized() const { return asChild()->isMinimized(); }
+bool QtFrame::isMinimized() const { return asChild()->isMinimized(); }
 
-bool Qt5Frame::isMaximized() const { return asChild()->isMaximized(); }
+bool QtFrame::isMaximized() const { return asChild()->isMaximized(); }
 
-void Qt5Frame::SetWindowStateImpl(Qt::WindowStates eState)
+void QtFrame::SetWindowStateImpl(Qt::WindowStates eState)
 {
     return asChild()->setWindowState(eState);
 }
 
-void Qt5Frame::SetTitle(const OUString& rTitle)
+void QtFrame::SetTitle(const OUString& rTitle)
 {
     m_pQWidget->window()->setWindowTitle(toQString(rTitle));
 }
 
-void Qt5Frame::SetIcon(sal_uInt16 nIcon)
+void QtFrame::SetIcon(sal_uInt16 nIcon)
 {
     if (m_nStyle
             & (SalFrameStyleFlags::PLUG | SalFrameStyleFlags::SYSTEMCHILD
@@ -410,13 +410,13 @@ void Qt5Frame::SetIcon(sal_uInt16 nIcon)
     m_pQWidget->window()->setWindowIcon(aIcon);
 }
 
-void Qt5Frame::SetMenu(SalMenu*) {}
+void QtFrame::SetMenu(SalMenu*) {}
 
-void Qt5Frame::DrawMenuBar() { /* not needed */}
+void QtFrame::DrawMenuBar() { /* not needed */}
 
-void Qt5Frame::SetExtendedFrameStyle(SalExtStyle /*nExtStyle*/) { /* not needed */}
+void QtFrame::SetExtendedFrameStyle(SalExtStyle /*nExtStyle*/) { /* not needed */}
 
-void Qt5Frame::Show(bool bVisible, bool bNoActivate)
+void QtFrame::Show(bool bVisible, bool bNoActivate)
 {
     assert(m_pQWidget);
     if (bVisible == asChild()->isVisible())
@@ -425,7 +425,7 @@ void Qt5Frame::Show(bool bVisible, bool bNoActivate)
     SetDefaultSize();
     SetDefaultPos();
 
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, bVisible, bNoActivate]() {
         asChild()->setVisible(bVisible);
@@ -438,7 +438,7 @@ void Qt5Frame::Show(bool bVisible, bool bNoActivate)
     });
 }
 
-void Qt5Frame::SetMinClientSize(tools::Long nWidth, tools::Long nHeight)
+void QtFrame::SetMinClientSize(tools::Long nWidth, tools::Long nHeight)
 {
     if (!isChild())
     {
@@ -447,7 +447,7 @@ void Qt5Frame::SetMinClientSize(tools::Long nWidth, tools::Long nHeight)
     }
 }
 
-void Qt5Frame::SetMaxClientSize(tools::Long nWidth, tools::Long nHeight)
+void QtFrame::SetMaxClientSize(tools::Long nWidth, tools::Long nHeight)
 {
     if (!isChild())
     {
@@ -456,7 +456,7 @@ void Qt5Frame::SetMaxClientSize(tools::Long nWidth, tools::Long nHeight)
     }
 }
 
-void Qt5Frame::SetDefaultPos()
+void QtFrame::SetDefaultPos()
 {
     if (!m_bDefaultPos)
         return;
@@ -476,7 +476,7 @@ void Qt5Frame::SetDefaultPos()
         m_bDefaultPos = false;
 }
 
-Size Qt5Frame::CalcDefaultSize()
+Size QtFrame::CalcDefaultSize()
 {
     assert(isWindow());
 
@@ -510,7 +510,7 @@ Size Qt5Frame::CalcDefaultSize()
     return aSize;
 }
 
-void Qt5Frame::SetDefaultSize()
+void QtFrame::SetDefaultSize()
 {
     if (!m_bDefaultSize)
         return;
@@ -521,8 +521,8 @@ void Qt5Frame::SetDefaultSize()
     assert(!m_bDefaultSize);
 }
 
-void Qt5Frame::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
-                          sal_uInt16 nFlags)
+void QtFrame::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
+                         sal_uInt16 nFlags)
 {
     if (!isWindow() || isChild(true, false))
         return;
@@ -568,7 +568,7 @@ void Qt5Frame::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, to
             nX += aParentGeometry.nX;
         nY += aParentGeometry.nY;
 
-        Qt5MainWindow* pTopLevel = m_pParent->GetTopLevelWindow();
+        QtMainWindow* pTopLevel = m_pParent->GetTopLevelWindow();
         if (pTopLevel && pTopLevel->menuBar() && pTopLevel->menuBar()->isVisible())
             nY += round(pTopLevel->menuBar()->geometry().height() * devicePixelRatioF());
     }
@@ -587,13 +587,13 @@ void Qt5Frame::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, to
     asChild()->move(round(nX / devicePixelRatioF()), round(nY / devicePixelRatioF()));
 }
 
-void Qt5Frame::GetClientSize(tools::Long& rWidth, tools::Long& rHeight)
+void QtFrame::GetClientSize(tools::Long& rWidth, tools::Long& rHeight)
 {
     rWidth = round(m_pQWidget->width() * devicePixelRatioF());
     rHeight = round(m_pQWidget->height() * devicePixelRatioF());
 }
 
-void Qt5Frame::GetWorkArea(tools::Rectangle& rRect)
+void QtFrame::GetWorkArea(tools::Rectangle& rRect)
 {
     if (!isWindow())
         return;
@@ -605,14 +605,14 @@ void Qt5Frame::GetWorkArea(tools::Rectangle& rRect)
     rRect = tools::Rectangle(0, 0, aSize.width(), aSize.height());
 }
 
-SalFrame* Qt5Frame::GetParent() const { return m_pParent; }
+SalFrame* QtFrame::GetParent() const { return m_pParent; }
 
-void Qt5Frame::SetModal(bool bModal)
+void QtFrame::SetModal(bool bModal)
 {
     if (!isWindow())
         return;
 
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     pSalInst->RunInMainThread([this, bModal]() {
 
@@ -630,9 +630,9 @@ void Qt5Frame::SetModal(bool bModal)
     });
 }
 
-bool Qt5Frame::GetModal() const { return isWindow() && windowHandle()->isModal(); }
+bool QtFrame::GetModal() const { return isWindow() && windowHandle()->isModal(); }
 
-void Qt5Frame::SetWindowState(const SalFrameState* pState)
+void QtFrame::SetWindowState(const SalFrameState* pState)
 {
     if (!isWindow() || !pState || isChild(true, false))
         return;
@@ -677,7 +677,7 @@ void Qt5Frame::SetWindowState(const SalFrameState* pState)
     }
 }
 
-bool Qt5Frame::GetWindowState(SalFrameState* pState)
+bool QtFrame::GetWindowState(SalFrameState* pState)
 {
     pState->mnState = WindowStateState::Normal;
     pState->mnMask = WindowStateMask::State;
@@ -702,7 +702,7 @@ bool Qt5Frame::GetWindowState(SalFrameState* pState)
     return true;
 }
 
-void Qt5Frame::ShowFullScreen(bool bFullScreen, sal_Int32 nScreen)
+void QtFrame::ShowFullScreen(bool bFullScreen, sal_Int32 nScreen)
 {
     // only top-level windows can go fullscreen
     assert(m_pTopLevel);
@@ -735,7 +735,7 @@ void Qt5Frame::ShowFullScreen(bool bFullScreen, sal_Int32 nScreen)
     }
 }
 
-void Qt5Frame::StartPresentation(bool bStart)
+void QtFrame::StartPresentation(bool bStart)
 {
 // meh - so there's no Qt platform independent solution
 // https://forum.qt.io/topic/38504/solved-qdialog-in-fullscreen-disable-os-screensaver
@@ -756,7 +756,7 @@ void Qt5Frame::StartPresentation(bool bStart)
 #endif
 }
 
-void Qt5Frame::SetAlwaysOnTop(bool bOnTop)
+void QtFrame::SetAlwaysOnTop(bool bOnTop)
 {
     QWidget* const pWidget = asChild();
     const Qt::WindowFlags flags = pWidget->windowFlags();
@@ -766,7 +766,7 @@ void Qt5Frame::SetAlwaysOnTop(bool bOnTop)
         pWidget->setWindowFlags(flags & ~(Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint));
 }
 
-void Qt5Frame::ToTop(SalFrameToTop nFlags)
+void QtFrame::ToTop(SalFrameToTop nFlags)
 {
     QWidget* const pWidget = asChild();
     if (isWindow() && !(nFlags & SalFrameToTop::GrabFocusOnly))
@@ -780,7 +780,7 @@ void Qt5Frame::ToTop(SalFrameToTop nFlags)
     }
 }
 
-void Qt5Frame::SetPointer(PointerStyle ePointerStyle)
+void QtFrame::SetPointer(PointerStyle ePointerStyle)
 {
     QWindow* pWindow = m_pQWidget->window()->windowHandle();
     if (!pWindow)
@@ -789,10 +789,10 @@ void Qt5Frame::SetPointer(PointerStyle ePointerStyle)
         return;
     m_ePointerStyle = ePointerStyle;
 
-    pWindow->setCursor(static_cast<Qt5Data*>(GetSalData())->getCursor(ePointerStyle));
+    pWindow->setCursor(static_cast<QtData*>(GetSalData())->getCursor(ePointerStyle));
 }
 
-void Qt5Frame::CaptureMouse(bool bMouse)
+void QtFrame::CaptureMouse(bool bMouse)
 {
     static const char* pEnv = getenv("SAL_NO_MOUSEGRABS");
     if (pEnv && *pEnv)
@@ -804,24 +804,24 @@ void Qt5Frame::CaptureMouse(bool bMouse)
         m_pQWidget->releaseMouse();
 }
 
-void Qt5Frame::SetPointerPos(tools::Long nX, tools::Long nY)
+void QtFrame::SetPointerPos(tools::Long nX, tools::Long nY)
 {
     // some cursor already exists (and it has m_ePointerStyle shape)
     // so here we just reposition it
     QCursor::setPos(m_pQWidget->mapToGlobal(QPoint(nX, nY)));
 }
 
-void Qt5Frame::Flush()
+void QtFrame::Flush()
 {
     // was: QGuiApplication::sync();
     // but FIXME it causes too many issues, figure out sth better
 
     // unclear if we need to also flush cairo surface - gtk3 backend
-    // does not do it. QPainter in Qt5Widget::paintEvent() is
+    // does not do it. QPainter in QtWidget::paintEvent() is
     // destroyed, so that state should be safely flushed.
 }
 
-bool Qt5Frame::ShowTooltip(const OUString& rText, const tools::Rectangle& rHelpArea)
+bool QtFrame::ShowTooltip(const OUString& rText, const tools::Rectangle& rHelpArea)
 {
     QRect aHelpArea(toQRect(rHelpArea));
     if (QGuiApplication::isRightToLeft())
@@ -830,7 +830,7 @@ bool Qt5Frame::ShowTooltip(const OUString& rText, const tools::Rectangle& rHelpA
     return true;
 }
 
-void Qt5Frame::SetInputContext(SalInputContext* pContext)
+void QtFrame::SetInputContext(SalInputContext* pContext)
 {
     if (!pContext)
         return;
@@ -841,14 +841,14 @@ void Qt5Frame::SetInputContext(SalInputContext* pContext)
     m_pQWidget->setAttribute(Qt::WA_InputMethodEnabled);
 }
 
-void Qt5Frame::EndExtTextInput(EndExtTextInputFlags /*nFlags*/)
+void QtFrame::EndExtTextInput(EndExtTextInputFlags /*nFlags*/)
 {
-    Qt5Widget* pQt5Widget = static_cast<Qt5Widget*>(m_pQWidget);
-    if (pQt5Widget)
-        pQt5Widget->endExtTextInput();
+    QtWidget* pQtWidget = static_cast<QtWidget*>(m_pQWidget);
+    if (pQtWidget)
+        pQtWidget->endExtTextInput();
 }
 
-OUString Qt5Frame::GetKeyName(sal_uInt16 nKeyCode)
+OUString QtFrame::GetKeyName(sal_uInt16 nKeyCode)
 {
     vcl::KeyCode vclKeyCode(nKeyCode);
     int nCode = vclKeyCode.GetCode();
@@ -996,16 +996,16 @@ OUString Qt5Frame::GetKeyName(sal_uInt16 nKeyCode)
     return sKeyName;
 }
 
-bool Qt5Frame::MapUnicodeToKeyCode(sal_Unicode /*aUnicode*/, LanguageType /*aLangType*/,
-                                   vcl::KeyCode& /*rKeyCode*/)
+bool QtFrame::MapUnicodeToKeyCode(sal_Unicode /*aUnicode*/, LanguageType /*aLangType*/,
+                                  vcl::KeyCode& /*rKeyCode*/)
 {
     // not supported yet
     return false;
 }
 
-LanguageType Qt5Frame::GetInputLanguage() { return m_nInputLanguage; }
+LanguageType QtFrame::GetInputLanguage() { return m_nInputLanguage; }
 
-void Qt5Frame::setInputLanguage(LanguageType nInputLanguage)
+void QtFrame::setInputLanguage(LanguageType nInputLanguage)
 {
     if (nInputLanguage == m_nInputLanguage)
         return;
@@ -1018,9 +1018,9 @@ static Color toColor(const QColor& rColor)
     return Color(rColor.red(), rColor.green(), rColor.blue());
 }
 
-void Qt5Frame::UpdateSettings(AllSettings& rSettings)
+void QtFrame::UpdateSettings(AllSettings& rSettings)
 {
-    if (Qt5Data::noNativeControls())
+    if (QtData::noNativeControls())
         return;
 
     StyleSettings style(rSettings.GetStyleSettings());
@@ -1160,9 +1160,9 @@ void Qt5Frame::UpdateSettings(AllSettings& rSettings)
     rSettings.SetStyleSettings(style);
 }
 
-void Qt5Frame::Beep() { QApplication::beep(); }
+void QtFrame::Beep() { QApplication::beep(); }
 
-SalFrame::SalPointerState Qt5Frame::GetPointerState()
+SalFrame::SalPointerState QtFrame::GetPointerState()
 {
     SalPointerState aState;
     aState.maPos = toPoint(QCursor::pos() * devicePixelRatioF());
@@ -1172,37 +1172,37 @@ SalFrame::SalPointerState Qt5Frame::GetPointerState()
     return aState;
 }
 
-KeyIndicatorState Qt5Frame::GetIndicatorState() { return KeyIndicatorState(); }
+KeyIndicatorState QtFrame::GetIndicatorState() { return KeyIndicatorState(); }
 
-void Qt5Frame::SimulateKeyPress(sal_uInt16 nKeyCode)
+void QtFrame::SimulateKeyPress(sal_uInt16 nKeyCode)
 {
     SAL_WARN("vcl.qt5", "missing simulate keypress " << nKeyCode);
 }
 
-void Qt5Frame::SetParent(SalFrame* pNewParent) { m_pParent = static_cast<Qt5Frame*>(pNewParent); }
+void QtFrame::SetParent(SalFrame* pNewParent) { m_pParent = static_cast<QtFrame*>(pNewParent); }
 
-void Qt5Frame::SetPluginParent(SystemParentData* /*pNewParent*/)
+void QtFrame::SetPluginParent(SystemParentData* /*pNewParent*/)
 {
     //FIXME: no SetPluginParent impl. for qt5
 }
 
-void Qt5Frame::ResetClipRegion() { m_bNullRegion = true; }
+void QtFrame::ResetClipRegion() { m_bNullRegion = true; }
 
-void Qt5Frame::BeginSetClipRegion(sal_uInt32)
+void QtFrame::BeginSetClipRegion(sal_uInt32)
 {
     m_aRegion = QRegion(QRect(QPoint(0, 0), m_pQWidget->size()));
 }
 
-void Qt5Frame::UnionClipRegion(tools::Long nX, tools::Long nY, tools::Long nWidth,
-                               tools::Long nHeight)
+void QtFrame::UnionClipRegion(tools::Long nX, tools::Long nY, tools::Long nWidth,
+                              tools::Long nHeight)
 {
     m_aRegion
         = m_aRegion.united(scaledQRect(QRect(nX, nY, nWidth, nHeight), 1 / devicePixelRatioF()));
 }
 
-void Qt5Frame::EndSetClipRegion() { m_bNullRegion = false; }
+void QtFrame::EndSetClipRegion() { m_bNullRegion = false; }
 
-void Qt5Frame::SetScreenNumber(unsigned int nScreen)
+void QtFrame::SetScreenNumber(unsigned int nScreen)
 {
     if (!isWindow())
         return;
@@ -1254,7 +1254,7 @@ void Qt5Frame::SetScreenNumber(unsigned int nScreen)
     maGeometry.nDisplayScreenNumber = nScreen;
 }
 
-void Qt5Frame::SetApplicationID(const OUString& rWMClass)
+void QtFrame::SetApplicationID(const OUString& rWMClass)
 {
 #if QT5_USING_X11
     if (QGuiApplication::platformName() != "xcb" || !m_pTopLevel)
@@ -1281,27 +1281,27 @@ void Qt5Frame::SetApplicationID(const OUString& rWMClass)
 
 // Drag'n'drop foo
 
-void Qt5Frame::registerDragSource(Qt5DragSource* pDragSource)
+void QtFrame::registerDragSource(QtDragSource* pDragSource)
 {
     assert(!m_pDragSource);
     m_pDragSource = pDragSource;
 }
 
-void Qt5Frame::deregisterDragSource(Qt5DragSource const* pDragSource)
+void QtFrame::deregisterDragSource(QtDragSource const* pDragSource)
 {
     assert(m_pDragSource == pDragSource);
     (void)pDragSource;
     m_pDragSource = nullptr;
 }
 
-void Qt5Frame::registerDropTarget(Qt5DropTarget* pDropTarget)
+void QtFrame::registerDropTarget(QtDropTarget* pDropTarget)
 {
     assert(!m_pDropTarget);
     m_pDropTarget = pDropTarget;
     m_pQWidget->setAcceptDrops(true);
 }
 
-void Qt5Frame::deregisterDropTarget(Qt5DropTarget const* pDropTarget)
+void QtFrame::deregisterDropTarget(QtDropTarget const* pDropTarget)
 {
     assert(m_pDropTarget == pDropTarget);
     (void)pDropTarget;
@@ -1312,11 +1312,11 @@ static css::uno::Reference<css::datatransfer::XTransferable>
 lcl_getXTransferable(const QMimeData* pMimeData)
 {
     css::uno::Reference<css::datatransfer::XTransferable> xTransferable;
-    const Qt5MimeData* pQt5MimeData = dynamic_cast<const Qt5MimeData*>(pMimeData);
-    if (!pQt5MimeData)
-        xTransferable = new Qt5DnDTransferable(pMimeData);
+    const QtMimeData* pQtMimeData = dynamic_cast<const QtMimeData*>(pMimeData);
+    if (!pQtMimeData)
+        xTransferable = new QtDnDTransferable(pMimeData);
     else
-        xTransferable = pQt5MimeData->xTransferable();
+        xTransferable = pQtMimeData->xTransferable();
     return xTransferable;
 }
 
@@ -1341,7 +1341,7 @@ static sal_Int8 lcl_getUserDropAction(const QDropEvent* pEvent, const sal_Int8 n
     if (0 == nUserDropAction)
     {
         // default LO internal action is move, but default external action is copy
-        nUserDropAction = dynamic_cast<const Qt5MimeData*>(pMimeData)
+        nUserDropAction = dynamic_cast<const QtMimeData*>(pMimeData)
                               ? css::datatransfer::dnd::DNDConstants::ACTION_MOVE
                               : css::datatransfer::dnd::DNDConstants::ACTION_COPY;
         nUserDropAction &= nSourceActions;
@@ -1358,7 +1358,7 @@ static sal_Int8 lcl_getUserDropAction(const QDropEvent* pEvent, const sal_Int8 n
     return nUserDropAction;
 }
 
-void Qt5Frame::handleDragMove(QDragMoveEvent* pEvent)
+void QtFrame::handleDragMove(QDragMoveEvent* pEvent)
 {
     assert(m_pDropTarget);
 
@@ -1396,7 +1396,7 @@ void Qt5Frame::handleDragMove(QDragMoveEvent* pEvent)
         pEvent->ignore();
 }
 
-void Qt5Frame::handleDrop(QDropEvent* pEvent)
+void QtFrame::handleDrop(QDropEvent* pEvent)
 {
     assert(m_pDropTarget);
 
@@ -1425,7 +1425,7 @@ void Qt5Frame::handleDrop(QDropEvent* pEvent)
     // inform the drag source of the drag-origin frame of the drop result
     if (pEvent->source())
     {
-        Qt5Widget* pWidget = dynamic_cast<Qt5Widget*>(pEvent->source());
+        QtWidget* pWidget = dynamic_cast<QtWidget*>(pEvent->source());
         assert(pWidget); // AFAIK there shouldn't be any non-Qt5Widget as source in LO itself
         if (pWidget)
             pWidget->frame().m_pDragSource->fire_dragEnd(nDropAction, bDropSuccessful);
@@ -1441,7 +1441,7 @@ void Qt5Frame::handleDrop(QDropEvent* pEvent)
         pEvent->ignore();
 }
 
-void Qt5Frame::handleDragLeave()
+void QtFrame::handleDragLeave()
 {
     css::datatransfer::dnd::DropTargetEvent aEvent;
     aEvent.Source = static_cast<css::datatransfer::dnd::XDropTarget*>(m_pDropTarget);
diff --git a/vcl/qt5/Qt5Graphics.cxx b/vcl/qt5/Qt5Graphics.cxx
index 5fb512b98447..1e6197c4fa5d 100644
--- a/vcl/qt5/Qt5Graphics.cxx
+++ b/vcl/qt5/Qt5Graphics.cxx
@@ -30,75 +30,75 @@
 #include <QtWidgets/QPushButton>
 #include <QtWidgets/QWidget>
 
-Qt5Graphics::Qt5Graphics( Qt5Frame *pFrame, QImage *pQImage )
+QtGraphics::QtGraphics( QtFrame *pFrame, QImage *pQImage )
     : m_pFrame( pFrame )
     , m_pTextStyle{ nullptr, }
     , m_aTextColor( 0x00, 0x00, 0x00 )
 {
-    m_pBackend = std::make_unique<Qt5GraphicsBackend>(m_pFrame, pQImage);
+    m_pBackend = std::make_unique<QtGraphicsBackend>(m_pFrame, pQImage);
 
     if (!initWidgetDrawBackends(false))
     {
-        if (!Qt5Data::noNativeControls())
-            m_pWidgetDraw.reset(new Qt5Graphics_Controls(*this));
+        if (!QtData::noNativeControls())
+            m_pWidgetDraw.reset(new QtGraphics_Controls(*this));
     }
     if (m_pFrame)
         setDevicePixelRatioF(m_pFrame->devicePixelRatioF());
 }
 
-Qt5Graphics::~Qt5Graphics() { ReleaseFonts(); }
+QtGraphics::~QtGraphics() { ReleaseFonts(); }
 
-void Qt5Graphics::ChangeQImage(QImage* pQImage)
+void QtGraphics::ChangeQImage(QImage* pQImage)
 {
     m_pBackend->setQImage(pQImage);
     m_pBackend->ResetClipRegion();
 }
 
-SalGraphicsImpl* Qt5Graphics::GetImpl() const { return m_pBackend.get(); }
+SalGraphicsImpl* QtGraphics::GetImpl() const { return m_pBackend.get(); }
 
-SystemGraphicsData Qt5Graphics::GetGraphicsData() const { return SystemGraphicsData(); }
+SystemGraphicsData QtGraphics::GetGraphicsData() const { return SystemGraphicsData(); }
 
 #if ENABLE_CAIRO_CANVAS
 
-bool Qt5Graphics::SupportsCairo() const { return false; }
+bool QtGraphics::SupportsCairo() const { return false; }
 
 cairo::SurfaceSharedPtr
-Qt5Graphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& /*rSurface*/) const
+QtGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& /*rSurface*/) const
 {
     return nullptr;
 }
 
-cairo::SurfaceSharedPtr Qt5Graphics::CreateSurface(const OutputDevice& /*rRefDevice*/, int /*x*/,
-                                                   int /*y*/, int /*width*/, int /*height*/) const
+cairo::SurfaceSharedPtr QtGraphics::CreateSurface(const OutputDevice& /*rRefDevice*/, int /*x*/,
+                                                  int /*y*/, int /*width*/, int /*height*/) const
 {
     return nullptr;
 }
 
-cairo::SurfaceSharedPtr Qt5Graphics::CreateBitmapSurface(const OutputDevice& /*rRefDevice*/,
-                                                         const BitmapSystemData& /*rData*/,
-                                                         const Size& /*rSize*/) const
+cairo::SurfaceSharedPtr QtGraphics::CreateBitmapSurface(const OutputDevice& /*rRefDevice*/,
+                                                        const BitmapSystemData& /*rData*/,
+                                                        const Size& /*rSize*/) const
 {
     return nullptr;
 }
 
-css::uno::Any Qt5Graphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& /*rSurface*/,
-                                                  const basegfx::B2ISize& /*rSize*/) const
+css::uno::Any QtGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& /*rSurface*/,
+                                                 const basegfx::B2ISize& /*rSize*/) const
 {
     return css::uno::Any();
 }
 
 #endif
 
-void Qt5Graphics::handleDamage(const tools::Rectangle& rDamagedRegion)
+void QtGraphics::handleDamage(const tools::Rectangle& rDamagedRegion)
 {
     assert(m_pWidgetDraw);
-    assert(dynamic_cast<Qt5Graphics_Controls*>(m_pWidgetDraw.get()));
+    assert(dynamic_cast<QtGraphics_Controls*>(m_pWidgetDraw.get()));
     assert(!rDamagedRegion.IsEmpty());
 
-    QImage* pImage = static_cast<Qt5Graphics_Controls*>(m_pWidgetDraw.get())->getImage();
+    QImage* pImage = static_cast<QtGraphics_Controls*>(m_pWidgetDraw.get())->getImage();
     QImage blit(*pImage);
     blit.setDevicePixelRatio(1);
-    Qt5Painter aPainter(*m_pBackend);
+    QtPainter aPainter(*m_pBackend);
     aPainter.drawImage(QPoint(rDamagedRegion.Left(), rDamagedRegion.Top()), blit);
     aPainter.update(toQRect(rDamagedRegion));
 }
diff --git a/vcl/qt5/Qt5Graphics_Controls.cxx b/vcl/qt5/Qt5Graphics_Controls.cxx
index b7ab8d38ccc1..077b92e54422 100644
--- a/vcl/qt5/Qt5Graphics_Controls.cxx
+++ b/vcl/qt5/Qt5Graphics_Controls.cxx
@@ -74,12 +74,12 @@ static void lcl_ApplyBackgroundColorToStyleOption(QStyleOption& rOption,
     }
 }
 
-Qt5Graphics_Controls::Qt5Graphics_Controls(const Qt5GraphicsBase& rGraphics)
+QtGraphics_Controls::QtGraphics_Controls(const QtGraphicsBase& rGraphics)
     : m_rGraphics(rGraphics)
 {
 }
 
-bool Qt5Graphics_Controls::isNativeControlSupported(ControlType type, ControlPart part)
+bool QtGraphics_Controls::isNativeControlSupported(ControlType type, ControlPart part)
 {
     switch (type)
     {
@@ -129,34 +129,33 @@ bool Qt5Graphics_Controls::isNativeControlSupported(ControlType type, ControlPar
     return false;
 }
 
-inline int Qt5Graphics_Controls::pixelMetric(QStyle::PixelMetric metric, const QStyleOption* option)
+inline int QtGraphics_Controls::pixelMetric(QStyle::PixelMetric metric, const QStyleOption* option)
 {
     return QApplication::style()->pixelMetric(metric, option);
 }
 
-inline QSize Qt5Graphics_Controls::sizeFromContents(QStyle::ContentsType type,
-                                                    const QStyleOption* option,
-                                                    const QSize& contentsSize)
+inline QSize QtGraphics_Controls::sizeFromContents(QStyle::ContentsType type,
+                                                   const QStyleOption* option,
+                                                   const QSize& contentsSize)
 {
     return QApplication::style()->sizeFromContents(type, option, contentsSize);
 }
 
-inline QRect Qt5Graphics_Controls::subControlRect(QStyle::ComplexControl control,
-                                                  const QStyleOptionComplex* option,
-                                                  QStyle::SubControl subControl)
+inline QRect QtGraphics_Controls::subControlRect(QStyle::ComplexControl control,
+                                                 const QStyleOptionComplex* option,
+                                                 QStyle::SubControl subControl)
 {
     return QApplication::style()->subControlRect(control, option, subControl);
 }
 
-inline QRect Qt5Graphics_Controls::subElementRect(QStyle::SubElement element,
-                                                  const QStyleOption* option)
+inline QRect QtGraphics_Controls::subElementRect(QStyle::SubElement element,
+                                                 const QStyleOption* option)
 {
     return QApplication::style()->subElementRect(element, option);
 }
 
-void Qt5Graphics_Controls::draw(QStyle::ControlElement element, QStyleOption& rOption,
-                                QImage* image, const Color& rBackgroundColor,
-                                QStyle::State const state, QRect rect)
+void QtGraphics_Controls::draw(QStyle::ControlElement element, QStyleOption& rOption, QImage* image,
+                               const Color& rBackgroundColor, QStyle::State const state, QRect rect)
 {
     const QRect& targetRect = !rect.isNull() ? rect : image->rect();
 
@@ -169,9 +168,9 @@ void Qt5Graphics_Controls::draw(QStyle::ControlElement element, QStyleOption& rO
     QApplication::style()->drawControl(element, &rOption, &painter);
 }
 
-void Qt5Graphics_Controls::draw(QStyle::PrimitiveElement element, QStyleOption& rOption,
-                                QImage* image, const Color& rBackgroundColor,
-                                QStyle::State const state, QRect rect)
+void QtGraphics_Controls::draw(QStyle::PrimitiveElement element, QStyleOption& rOption,
+                               QImage* image, const Color& rBackgroundColor,
+                               QStyle::State const state, QRect rect)
 {
     const QRect& targetRect = !rect.isNull() ? rect : image->rect();
 
@@ -184,9 +183,9 @@ void Qt5Graphics_Controls::draw(QStyle::PrimitiveElement element, QStyleOption&
     QApplication::style()->drawPrimitive(element, &rOption, &painter);
 }
 
-void Qt5Graphics_Controls::draw(QStyle::ComplexControl element, QStyleOptionComplex& rOption,
-                                QImage* image, const Color& rBackgroundColor,
-                                QStyle::State const state)
+void QtGraphics_Controls::draw(QStyle::ComplexControl element, QStyleOptionComplex& rOption,
+                               QImage* image, const Color& rBackgroundColor,
+                               QStyle::State const state)
 {
     const QRect& targetRect = image->rect();
 
@@ -199,9 +198,9 @@ void Qt5Graphics_Controls::draw(QStyle::ComplexControl element, QStyleOptionComp
     QApplication::style()->drawComplexControl(element, &rOption, &painter);
 }
 
-void Qt5Graphics_Controls::drawFrame(QStyle::PrimitiveElement element, QImage* image,
-                                     const Color& rBackgroundColor, QStyle::State const& state,
-                                     bool bClip, QStyle::PixelMetric eLineMetric)
+void QtGraphics_Controls::drawFrame(QStyle::PrimitiveElement element, QImage* image,
+                                    const Color& rBackgroundColor, QStyle::State const& state,
+                                    bool bClip, QStyle::PixelMetric eLineMetric)
 {
     const int fw = pixelMetric(eLineMetric);
     QStyleOptionFrame option;
@@ -220,7 +219,7 @@ void Qt5Graphics_Controls::drawFrame(QStyle::PrimitiveElement element, QImage* i
     QApplication::style()->drawPrimitive(element, &option, &painter);
 }
 
-void Qt5Graphics_Controls::fillQStyleOptionTab(const ImplControlValue& value, QStyleOptionTab& sot)
+void QtGraphics_Controls::fillQStyleOptionTab(const ImplControlValue& value, QStyleOptionTab& sot)
 {
     const TabitemValue& rValue = static_cast<const TabitemValue&>(value);
     if (rValue.isFirst())
@@ -231,8 +230,8 @@ void Qt5Graphics_Controls::fillQStyleOptionTab(const ImplControlValue& value, QS
         sot.position = QStyleOptionTab::Middle;
 }
 
-void Qt5Graphics_Controls::fullQStyleOptionTabWidgetFrame(QStyleOptionTabWidgetFrame& option,
-                                                          bool bDownscale)
+void QtGraphics_Controls::fullQStyleOptionTabWidgetFrame(QStyleOptionTabWidgetFrame& option,
+                                                         bool bDownscale)
 {
     option.state = QStyle::State_Enabled;
     option.rightCornerWidgetSize = QSize(0, 0);
@@ -243,11 +242,11 @@ void Qt5Graphics_Controls::fullQStyleOptionTabWidgetFrame(QStyleOptionTabWidgetF
     option.shape = QTabBar::RoundedNorth;
 }
 
-bool Qt5Graphics_Controls::drawNativeControl(ControlType type, ControlPart part,
-                                             const tools::Rectangle& rControlRegion,
-                                             ControlState nControlState,
-                                             const ImplControlValue& value, const OUString&,
-                                             const Color& rBackgroundColor)
+bool QtGraphics_Controls::drawNativeControl(ControlType type, ControlPart part,
+                                            const tools::Rectangle& rControlRegion,
+                                            ControlState nControlState,
+                                            const ImplControlValue& value, const OUString&,
+                                            const Color& rBackgroundColor)
 {
     bool nativeSupport = isNativeControlSupported(type, part);
     if (!nativeSupport)
@@ -708,12 +707,12 @@ bool Qt5Graphics_Controls::drawNativeControl(ControlType type, ControlPart part,
     return returnVal;
 }
 
-bool Qt5Graphics_Controls::getNativeControlRegion(ControlType type, ControlPart part,
-                                                  const tools::Rectangle& controlRegion,
-                                                  ControlState controlState,
-                                                  const ImplControlValue& val, const OUString&,
-                                                  tools::Rectangle& nativeBoundingRegion,
-                                                  tools::Rectangle& nativeContentRegion)
+bool QtGraphics_Controls::getNativeControlRegion(ControlType type, ControlPart part,
+                                                 const tools::Rectangle& controlRegion,
+                                                 ControlState controlState,
+                                                 const ImplControlValue& val, const OUString&,
+                                                 tools::Rectangle& nativeBoundingRegion,
+                                                 tools::Rectangle& nativeContentRegion)
 {
     bool retVal = false;
 
@@ -1049,9 +1048,9 @@ bool Qt5Graphics_Controls::getNativeControlRegion(ControlType type, ControlPart
     aPos was or was not inside the native widget specified by the
     nType/nPart combination.
 */
-bool Qt5Graphics_Controls::hitTestNativeControl(ControlType nType, ControlPart nPart,
-                                                const tools::Rectangle& rControlRegion,
-                                                const Point& rPos, bool& rIsInside)
+bool QtGraphics_Controls::hitTestNativeControl(ControlType nType, ControlPart nPart,
+                                               const tools::Rectangle& rControlRegion,
+                                               const Point& rPos, bool& rIsInside)
 {
     if (nType == ControlType::Scrollbar)
     {
@@ -1093,41 +1092,41 @@ bool Qt5Graphics_Controls::hitTestNativeControl(ControlType nType, ControlPart n
     return false;
 }
 
-inline int Qt5Graphics_Controls::downscale(int size, Round eRound)
+inline int QtGraphics_Controls::downscale(int size, Round eRound)
 {
     return static_cast<int>(eRound == Round::Ceil ? ceil(size / m_rGraphics.devicePixelRatioF())
                                                   : floor(size / m_rGraphics.devicePixelRatioF()));
 }
 
-inline int Qt5Graphics_Controls::upscale(int size, Round eRound)
+inline int QtGraphics_Controls::upscale(int size, Round eRound)
 {
     return static_cast<int>(eRound == Round::Ceil ? ceil(size * m_rGraphics.devicePixelRatioF())
                                                   : floor(size * m_rGraphics.devicePixelRatioF()));
 }
 
-inline QRect Qt5Graphics_Controls::downscale(const QRect& rect)
+inline QRect QtGraphics_Controls::downscale(const QRect& rect)
 {
     return QRect(downscale(rect.x(), Round::Floor), downscale(rect.y(), Round::Floor),
                  downscale(rect.width(), Round::Ceil), downscale(rect.height(), Round::Ceil));
 }
 
-inline QRect Qt5Graphics_Controls::upscale(const QRect& rect)
+inline QRect QtGraphics_Controls::upscale(const QRect& rect)
 {
     return QRect(upscale(rect.x(), Round::Floor), upscale(rect.y(), Round::Floor),
                  upscale(rect.width(), Round::Ceil), upscale(rect.height(), Round::Ceil));
 }
 
-inline QSize Qt5Graphics_Controls::downscale(const QSize& size, Round eRound)
+inline QSize QtGraphics_Controls::downscale(const QSize& size, Round eRound)
 {
     return QSize(downscale(size.width(), eRound), downscale(size.height(), eRound));
 }
 
-inline QSize Qt5Graphics_Controls::upscale(const QSize& size, Round eRound)
+inline QSize QtGraphics_Controls::upscale(const QSize& size, Round eRound)
 {
     return QSize(upscale(size.width(), eRound), upscale(size.height(), eRound));
 }
 
-inline QPoint Qt5Graphics_Controls::upscale(const QPoint& point, Round eRound)
+inline QPoint QtGraphics_Controls::upscale(const QPoint& point, Round eRound)
 {
     return QPoint(upscale(point.x(), eRound), upscale(point.y(), eRound));
 }
diff --git a/vcl/qt5/Qt5Graphics_GDI.cxx b/vcl/qt5/Qt5Graphics_GDI.cxx
index a2730be5ad4e..b375f77ce92a 100644
--- a/vcl/qt5/Qt5Graphics_GDI.cxx
+++ b/vcl/qt5/Qt5Graphics_GDI.cxx
@@ -33,7 +33,7 @@
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <basegfx/polygon/b2dpolypolygontools.hxx>
 
-Qt5GraphicsBackend::Qt5GraphicsBackend(Qt5Frame* pFrame, QImage* pQImage)
+QtGraphicsBackend::QtGraphicsBackend(QtFrame* pFrame, QImage* pQImage)
     : m_pFrame(pFrame)
     , m_pQImage(pQImage)
     , m_aLineColor(0x00, 0x00, 0x00)
@@ -43,7 +43,7 @@ Qt5GraphicsBackend::Qt5GraphicsBackend(Qt5Frame* pFrame, QImage* pQImage)
     ResetClipRegion();
 }
 
-Qt5GraphicsBackend::~Qt5GraphicsBackend() {}
+QtGraphicsBackend::~QtGraphicsBackend() {}
 
 const basegfx::B2DPoint aHalfPointOfs(0.5, 0.5);
 
@@ -125,7 +125,7 @@ static bool AddPolyPolygonToPath(QPainterPath& rPath, const basegfx::B2DPolyPoly
     return true;
 }
 
-bool Qt5GraphicsBackend::setClipRegion(const vcl::Region& rRegion)
+bool QtGraphicsBackend::setClipRegion(const vcl::Region& rRegion)
 {
     if (rRegion.IsRectangle())
     {
@@ -165,7 +165,7 @@ bool Qt5GraphicsBackend::setClipRegion(const vcl::Region& rRegion)
     return true;
 }
 
-void Qt5GraphicsBackend::ResetClipRegion()
+void QtGraphicsBackend::ResetClipRegion()
 {
     if (m_pQImage)
         m_aClipRegion = QRegion(m_pQImage->rect());
@@ -178,26 +178,25 @@ void Qt5GraphicsBackend::ResetClipRegion()
     }
 }
 
-void Qt5GraphicsBackend::drawPixel(tools::Long nX, tools::Long nY)
+void QtGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY)
 {
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     aPainter.drawPoint(nX, nY);
     aPainter.update(nX, nY, 1, 1);
 }
 
-void Qt5GraphicsBackend::drawPixel(tools::Long nX, tools::Long nY, Color nColor)
+void QtGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY, Color nColor)
 {
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     aPainter.setPen(toQColor(nColor));
     aPainter.setPen(Qt::SolidLine);
     aPainter.drawPoint(nX, nY);
     aPainter.update(nX, nY, 1, 1);
 }
 
-void Qt5GraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2,
-                                  tools::Long nY2)
+void QtGraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2)
 {
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     aPainter.drawLine(nX1, nY1, nX2, nY2);
 
     tools::Long tmp;
@@ -216,13 +215,13 @@ void Qt5GraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long
     aPainter.update(nX1, nY1, nX2 - nX1 + 1, nY2 - nY1 + 1);
 }
 
-void Qt5GraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
-                                  tools::Long nHeight)
+void QtGraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
+                                 tools::Long nHeight)
 {
     if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
         return;
 
-    Qt5Painter aPainter(*this, true);
+    QtPainter aPainter(*this, true);
     if (SALCOLOR_NONE != m_aFillColor)
         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
     if (SALCOLOR_NONE != m_aLineColor)
@@ -230,12 +229,12 @@ void Qt5GraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nW
     aPainter.update(nX, nY, nWidth, nHeight);
 }
 
-void Qt5GraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
+void QtGraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
 {
     if (0 == nPoints)
         return;
 
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     QPoint* pPoints = new QPoint[nPoints];
     QPoint aTopLeft(pPtAry->getX(), pPtAry->getY());
     QPoint aBottomRight = aTopLeft;
@@ -256,9 +255,9 @@ void Qt5GraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
     aPainter.update(QRect(aTopLeft, aBottomRight));
 }
 
-void Qt5GraphicsBackend::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
+void QtGraphicsBackend::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
 {
-    Qt5Painter aPainter(*this, true);
+    QtPainter aPainter(*this, true);
     QPolygon aPolygon(nPoints);
     for (sal_uInt32 i = 0; i < nPoints; ++i, ++pPtAry)
         aPolygon.setPoint(i, pPtAry->getX(), pPtAry->getY());
@@ -266,8 +265,8 @@ void Qt5GraphicsBackend::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
     aPainter.update(aPolygon.boundingRect());
 }
 
-void Qt5GraphicsBackend::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32* pPoints,
-                                         const Point** ppPtAry)
+void QtGraphicsBackend::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32* pPoints,
+                                        const Point** ppPtAry)
 {
     // ignore invisible polygons
     if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
@@ -288,14 +287,14 @@ void Qt5GraphicsBackend::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32
         }
     }
 
-    Qt5Painter aPainter(*this, true);
+    QtPainter aPainter(*this, true);
     aPainter.drawPath(aPath);
     aPainter.update(aPath.boundingRect());
 }
 
-bool Qt5GraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
-                                         const basegfx::B2DPolyPolygon& rPolyPolygon,
-                                         double fTransparency)
+bool QtGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
+                                        const basegfx::B2DPolyPolygon& rPolyPolygon,
+                                        double fTransparency)
 {
     // ignore invisible polygons
     if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
@@ -312,38 +311,37 @@ bool Qt5GraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToD
     if (!AddPolyPolygonToPath(aPath, aPolyPolygon, !getAntiAlias(), m_aLineColor != SALCOLOR_NONE))
         return true;
 
-    Qt5Painter aPainter(*this, true, 255 * (1.0 - fTransparency));
+    QtPainter aPainter(*this, true, 255 * (1.0 - fTransparency));
     aPainter.drawPath(aPath);
     aPainter.update(aPath.boundingRect());
     return true;
 }
 
-bool Qt5GraphicsBackend::drawPolyLineBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
-                                            const PolyFlags* /*pFlgAry*/)
+bool QtGraphicsBackend::drawPolyLineBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
+                                           const PolyFlags* /*pFlgAry*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::drawPolygonBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
-                                           const PolyFlags* /*pFlgAry*/)
+bool QtGraphicsBackend::drawPolygonBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
+                                          const PolyFlags* /*pFlgAry*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::drawPolyPolygonBezier(sal_uInt32 /*nPoly*/, const sal_uInt32* /*pPoints*/,
-                                               const Point* const* /*pPtAry*/,
-                                               const PolyFlags* const* /*pFlgAry*/)
+bool QtGraphicsBackend::drawPolyPolygonBezier(sal_uInt32 /*nPoly*/, const sal_uInt32* /*pPoints*/,
+                                              const Point* const* /*pPtAry*/,
+                                              const PolyFlags* const* /*pFlgAry*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice,
-                                      const basegfx::B2DPolygon& rPolyLine, double fTransparency,
-                                      double fLineWidth,
-                                      const std::vector<double>* pStroke, // MM01
-                                      basegfx::B2DLineJoin eLineJoin,
-                                      css::drawing::LineCap eLineCap, double fMiterMinimumAngle,
-                                      bool bPixelSnapHairline)
+bool QtGraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice,
+                                     const basegfx::B2DPolygon& rPolyLine, double fTransparency,
+                                     double fLineWidth,
+                                     const std::vector<double>* pStroke, // MM01
+                                     basegfx::B2DLineJoin eLineJoin, css::drawing::LineCap eLineCap,
+                                     double fMiterMinimumAngle, bool bPixelSnapHairline)
 {
     if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
     {
@@ -394,7 +392,7 @@ bool Qt5GraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevi
     // setup poly-polygon path
     QPainterPath aPath;
 
-    // MM01 todo - I assume that this is OKAY to be done in one run for Qt5,
+    // MM01 todo - I assume that this is OKAY to be done in one run for Qt,
     // but this NEEDS to be checked/verified
     for (sal_uInt32 a(0); a < aPolyPolygonLine.count(); a++)
     {
@@ -402,7 +400,7 @@ bool Qt5GraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevi
         AddPolygonToPath(aPath, aPolyLine, aPolyLine.isClosed(), !getAntiAlias(), true);
     }
 
-    Qt5Painter aPainter(*this, false, 255 * (1.0 - fTransparency));
+    QtPainter aPainter(*this, false, 255 * (1.0 - fTransparency));
 
     // setup line attributes
     QPen aPen = aPainter.pen();
@@ -442,30 +440,30 @@ bool Qt5GraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevi
     return true;
 }
 
-bool Qt5GraphicsBackend::drawGradient(const tools::PolyPolygon& /*rPolyPolygon*/,
-                                      const Gradient& /*rGradient*/)
+bool QtGraphicsBackend::drawGradient(const tools::PolyPolygon& /*rPolyPolygon*/,
+                                     const Gradient& /*rGradient*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::implDrawGradient(basegfx::B2DPolyPolygon const& /*rPolyPolygon*/,
-                                          SalGradient const& /*rGradient*/)
+bool QtGraphicsBackend::implDrawGradient(basegfx::B2DPolyPolygon const& /*rPolyPolygon*/,
+                                         SalGradient const& /*rGradient*/)
 {
     return false;
 }
 
-void Qt5GraphicsBackend::drawScaledImage(const SalTwoRect& rPosAry, const QImage& rImage)
+void QtGraphicsBackend::drawScaledImage(const SalTwoRect& rPosAry, const QImage& rImage)
 {
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     QRect aSrcRect(rPosAry.mnSrcX, rPosAry.mnSrcY, rPosAry.mnSrcWidth, rPosAry.mnSrcHeight);
     QRect aDestRect(rPosAry.mnDestX, rPosAry.mnDestY, rPosAry.mnDestWidth, rPosAry.mnDestHeight);
     aPainter.drawImage(aDestRect, rImage, aSrcRect);
     aPainter.update(aDestRect);
 }
 
-void Qt5GraphicsBackend::copyArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX,
-                                  tools::Long nSrcY, tools::Long nSrcWidth, tools::Long nSrcHeight,
-                                  bool /*bWindowInvalidate*/)
+void QtGraphicsBackend::copyArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX,
+                                 tools::Long nSrcY, tools::Long nSrcWidth, tools::Long nSrcHeight,
+                                 bool /*bWindowInvalidate*/)
 {
     if (nDestX == nSrcX && nDestY == nSrcY)
         return;
@@ -481,7 +479,7 @@ void Qt5GraphicsBackend::copyArea(tools::Long nDestX, tools::Long nDestY, tools:
     drawScaledImage(aTR, *pImage);
 }
 
-void Qt5GraphicsBackend::copyBits(const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics)
+void QtGraphicsBackend::copyBits(const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics)
 {
     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
         || rPosAry.mnDestHeight <= 0)
@@ -500,26 +498,26 @@ void Qt5GraphicsBackend::copyBits(const SalTwoRect& rPosAry, SalGraphics* pSrcGr
         aPosAry.mnSrcY = 0;
     }
     else
-        pImage = static_cast<Qt5Graphics*>(pSrcGraphics)->getQImage();
+        pImage = static_cast<QtGraphics*>(pSrcGraphics)->getQImage();
 
     drawScaledImage(aPosAry, *pImage);
 }
 
-void Qt5GraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap)
+void QtGraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap)
 {
     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
         || rPosAry.mnDestHeight <= 0)
         return;
 
-    const QImage* pImage = static_cast<const Qt5Bitmap*>(&rSalBitmap)->GetQImage();
+    const QImage* pImage = static_cast<const QtBitmap*>(&rSalBitmap)->GetQImage();
 
     assert(pImage);
 
     drawScaledImage(rPosAry, *pImage);
 }
 
-void Qt5GraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
-                                    const SalBitmap& /*rTransparentBitmap*/)
+void QtGraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
+                                   const SalBitmap& /*rTransparentBitmap*/)
 {
     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
         || rPosAry.mnDestHeight <= 0)
@@ -529,8 +527,8 @@ void Qt5GraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap&
     assert(rPosAry.mnSrcHeight == rPosAry.mnDestHeight);
 }
 
-void Qt5GraphicsBackend::drawMask(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
-                                  Color /*nMaskColor*/)
+void QtGraphicsBackend::drawMask(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
+                                 Color /*nMaskColor*/)
 {
     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
         || rPosAry.mnDestHeight <= 0)
@@ -540,21 +538,21 @@ void Qt5GraphicsBackend::drawMask(const SalTwoRect& rPosAry, const SalBitmap& /*
     assert(rPosAry.mnSrcHeight == rPosAry.mnDestHeight);
 }
 
-std::shared_ptr<SalBitmap> Qt5GraphicsBackend::getBitmap(tools::Long nX, tools::Long nY,
-                                                         tools::Long nWidth, tools::Long nHeight)
+std::shared_ptr<SalBitmap> QtGraphicsBackend::getBitmap(tools::Long nX, tools::Long nY,
+                                                        tools::Long nWidth, tools::Long nHeight)
 {
-    return std::make_shared<Qt5Bitmap>(m_pQImage->copy(nX, nY, nWidth, nHeight));
+    return std::make_shared<QtBitmap>(m_pQImage->copy(nX, nY, nWidth, nHeight));
 }
 
-Color Qt5GraphicsBackend::getPixel(tools::Long nX, tools::Long nY)
+Color QtGraphicsBackend::getPixel(tools::Long nX, tools::Long nY)
 {
     return Color(ColorTransparency, m_pQImage->pixel(nX, nY));
 }
 
-void Qt5GraphicsBackend::invert(tools::Long nX, tools::Long nY, tools::Long nWidth,
-                                tools::Long nHeight, SalInvert nFlags)
+void QtGraphicsBackend::invert(tools::Long nX, tools::Long nY, tools::Long nWidth,
+                               tools::Long nHeight, SalInvert nFlags)
 {
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     if (SalInvert::N50 & nFlags)
     {
         aPainter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
@@ -580,25 +578,25 @@ void Qt5GraphicsBackend::invert(tools::Long nX, tools::Long nY, tools::Long nWid
     aPainter.update(nX, nY, nWidth, nHeight);
 }
 
-void Qt5GraphicsBackend::invert(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
-                                SalInvert /*nFlags*/)
+void QtGraphicsBackend::invert(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
+                               SalInvert /*nFlags*/)
 {
 }
 
-bool Qt5GraphicsBackend::drawEPS(tools::Long /*nX*/, tools::Long /*nY*/, tools::Long /*nWidth*/,
-                                 tools::Long /*nHeight*/, void* /*pPtr*/, sal_uInt32 /*nSize*/)
+bool QtGraphicsBackend::drawEPS(tools::Long /*nX*/, tools::Long /*nY*/, tools::Long /*nWidth*/,
+                                tools::Long /*nHeight*/, void* /*pPtr*/, sal_uInt32 /*nSize*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::blendBitmap(const SalTwoRect&, const SalBitmap& /*rBitmap*/)
+bool QtGraphicsBackend::blendBitmap(const SalTwoRect&, const SalBitmap& /*rBitmap*/)
 {
     return false;
 }
 
-bool Qt5GraphicsBackend::blendAlphaBitmap(const SalTwoRect&, const SalBitmap& /*rSrcBitmap*/,
-                                          const SalBitmap& /*rMaskBitmap*/,
-                                          const SalBitmap& /*rAlphaBitmap*/)
+bool QtGraphicsBackend::blendAlphaBitmap(const SalTwoRect&, const SalBitmap& /*rSrcBitmap*/,
+                                         const SalBitmap& /*rMaskBitmap*/,
+                                         const SalBitmap& /*rAlphaBitmap*/)
 {
     return false;
 }
@@ -612,9 +610,9 @@ static bool getAlphaImage(const SalBitmap& rSourceBitmap, const SalBitmap& rAlph
         return false;
     }
 
-    const QImage* pBitmap = static_cast<const Qt5Bitmap*>(&rSourceBitmap)->GetQImage();
-    const QImage* pAlpha = static_cast<const Qt5Bitmap*>(&rAlphaBitmap)->GetQImage();
-    rAlphaImage = pBitmap->convertToFormat(Qt5_DefaultFormat32);
+    const QImage* pBitmap = static_cast<const QtBitmap*>(&rSourceBitmap)->GetQImage();
+    const QImage* pAlpha = static_cast<const QtBitmap*>(&rAlphaBitmap)->GetQImage();
+    rAlphaImage = pBitmap->convertToFormat(Qt_DefaultFormat32);
 
     if (rAlphaBitmap.GetBitCount() == 8)
     {
@@ -645,8 +643,8 @@ static bool getAlphaImage(const SalBitmap& rSourceBitmap, const SalBitmap& rAlph
     return true;
 }
 
-bool Qt5GraphicsBackend::drawAlphaBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSourceBitmap,
-                                         const SalBitmap& rAlphaBitmap)
+bool QtGraphicsBackend::drawAlphaBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSourceBitmap,
+                                        const SalBitmap& rAlphaBitmap)
 {
     QImage aImage;
     if (!getAlphaImage(rSourceBitmap, rAlphaBitmap, aImage))
@@ -655,11 +653,11 @@ bool Qt5GraphicsBackend::drawAlphaBitmap(const SalTwoRect& rPosAry, const SalBit
     return true;
 }
 
-bool Qt5GraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull,
-                                               const basegfx::B2DPoint& rX,
-                                               const basegfx::B2DPoint& rY,
-                                               const SalBitmap& rSourceBitmap,
-                                               const SalBitmap* pAlphaBitmap, double fAlpha)
+bool QtGraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull,
+                                              const basegfx::B2DPoint& rX,
+                                              const basegfx::B2DPoint& rY,
+                                              const SalBitmap& rSourceBitmap,
+                                              const SalBitmap* pAlphaBitmap, double fAlpha)
 {
     if (fAlpha != 1.0)
         return false;
@@ -668,11 +666,11 @@ bool Qt5GraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull,
         return false;
     else
     {
-        const QImage* pBitmap = static_cast<const Qt5Bitmap*>(&rSourceBitmap)->GetQImage();
-        aImage = pBitmap->convertToFormat(Qt5_DefaultFormat32);
+        const QImage* pBitmap = static_cast<const QtBitmap*>(&rSourceBitmap)->GetQImage();
+        aImage = pBitmap->convertToFormat(Qt_DefaultFormat32);
     }
 
-    Qt5Painter aPainter(*this);
+    QtPainter aPainter(*this);
     const basegfx::B2DVector aXRel = rX - rNull;
     const basegfx::B2DVector aYRel = rY - rNull;
     aPainter.setTransform(QTransform(aXRel.getX() / aImage.width(), aXRel.getY() / aImage.width(),
@@ -683,17 +681,17 @@ bool Qt5GraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull,
     return true;
 }
 
-bool Qt5GraphicsBackend::hasFastDrawTransformedBitmap() const { return false; }
+bool QtGraphicsBackend::hasFastDrawTransformedBitmap() const { return false; }
 
-bool Qt5GraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
-                                       tools::Long nHeight, sal_uInt8 nTransparency)
+bool QtGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
+                                      tools::Long nHeight, sal_uInt8 nTransparency)
 {
     if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
         return true;
     assert(nTransparency <= 100);
     if (nTransparency > 100)
         nTransparency = 100;
-    Qt5Painter aPainter(*this, true, (100 - nTransparency) * (255.0 / 100));
+    QtPainter aPainter(*this, true, (100 - nTransparency) * (255.0 / 100));
     if (SALCOLOR_NONE != m_aFillColor)
         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
     if (SALCOLOR_NONE != m_aLineColor)
@@ -702,19 +700,19 @@ bool Qt5GraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Lo
     return true;
 }
 
-sal_uInt16 Qt5GraphicsBackend::GetBitCount() const { return getFormatBits(m_pQImage->format()); }
+sal_uInt16 QtGraphicsBackend::GetBitCount() const { return getFormatBits(m_pQImage->format()); }
 
-tools::Long Qt5GraphicsBackend::GetGraphicsWidth() const { return m_pQImage->width(); }
+tools::Long QtGraphicsBackend::GetGraphicsWidth() const { return m_pQImage->width(); }
 
-void Qt5GraphicsBackend::SetLineColor() { m_aLineColor = SALCOLOR_NONE; }
+void QtGraphicsBackend::SetLineColor() { m_aLineColor = SALCOLOR_NONE; }
 
-void Qt5GraphicsBackend::SetLineColor(Color nColor) { m_aLineColor = nColor; }
+void QtGraphicsBackend::SetLineColor(Color nColor) { m_aLineColor = nColor; }
 
-void Qt5GraphicsBackend::SetFillColor() { m_aFillColor = SALCOLOR_NONE; }
+void QtGraphicsBackend::SetFillColor() { m_aFillColor = SALCOLOR_NONE; }
 
-void Qt5GraphicsBackend::SetFillColor(Color nColor) { m_aFillColor = nColor; }
+void QtGraphicsBackend::SetFillColor(Color nColor) { m_aFillColor = nColor; }
 
-void Qt5GraphicsBackend::SetXORMode(bool bSet, bool)
+void QtGraphicsBackend::SetXORMode(bool bSet, bool)
 {
     if (bSet)
         m_eCompositionMode = QPainter::CompositionMode_Xor;
@@ -722,11 +720,11 @@ void Qt5GraphicsBackend::SetXORMode(bool bSet, bool)
         m_eCompositionMode = QPainter::CompositionMode_SourceOver;
 }
 
-void Qt5GraphicsBackend::SetROPLineColor(SalROPColor /*nROPColor*/) {}
+void QtGraphicsBackend::SetROPLineColor(SalROPColor /*nROPColor*/) {}
 
-void Qt5GraphicsBackend::SetROPFillColor(SalROPColor /*nROPColor*/) {}
+void QtGraphicsBackend::SetROPFillColor(SalROPColor /*nROPColor*/) {}
 
-bool Qt5GraphicsBackend::supportsOperation(OutDevSupportType eType) const
+bool QtGraphicsBackend::supportsOperation(OutDevSupportType eType) const
 {
     switch (eType)
     {
@@ -738,7 +736,7 @@ bool Qt5GraphicsBackend::supportsOperation(OutDevSupportType eType) const
     }
 }
 
-void Qt5Graphics::GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY)
+void QtGraphics::GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY)
 {
     char* pForceDpi;
     if ((pForceDpi = getenv("SAL_FORCEDPI")))
diff --git a/vcl/qt5/Qt5Graphics_Text.cxx b/vcl/qt5/Qt5Graphics_Text.cxx
index 9e3065b70fe8..411becfe914a 100644
--- a/vcl/qt5/Qt5Graphics_Text.cxx
+++ b/vcl/qt5/Qt5Graphics_Text.cxx
@@ -39,9 +39,9 @@
 #include <QtGui/QRawFont>
 #include <QtCore/QStringList>
 
-void Qt5Graphics::SetTextColor(Color nColor) { m_aTextColor = nColor; }
+void QtGraphics::SetTextColor(Color nColor) { m_aTextColor = nColor; }
 
-void Qt5Graphics::SetFont(LogicalFontInstance* pReqFont, int nFallbackLevel)
+void QtGraphics::SetFont(LogicalFontInstance* pReqFont, int nFallbackLevel)
 {
     // release the text styles
     for (int i = nFallbackLevel; i < MAX_FALLBACK; ++i)
@@ -54,13 +54,13 @@ void Qt5Graphics::SetFont(LogicalFontInstance* pReqFont, int nFallbackLevel)
     if (!pReqFont)
         return;
 
-    m_pTextStyle[nFallbackLevel] = static_cast<Qt5Font*>(pReqFont);
+    m_pTextStyle[nFallbackLevel] = static_cast<QtFont*>(pReqFont);
 }
 
-void Qt5Graphics::GetFontMetric(ImplFontMetricDataRef& rFMD, int nFallbackLevel)
+void QtGraphics::GetFontMetric(ImplFontMetricDataRef& rFMD, int nFallbackLevel)
 {
     QRawFont aRawFont(QRawFont::fromFont(*m_pTextStyle[nFallbackLevel]));
-    Qt5FontFace::fillAttributesFromQFont(*m_pTextStyle[nFallbackLevel], *rFMD);
+    QtFontFace::fillAttributesFromQFont(*m_pTextStyle[nFallbackLevel], *rFMD);
 
     rFMD->ImplCalcLineSpacing(m_pTextStyle[nFallbackLevel].get());
 
@@ -70,21 +70,21 @@ void Qt5Graphics::GetFontMetric(ImplFontMetricDataRef& rFMD, int nFallbackLevel)
     rFMD->SetMinKashida(m_pTextStyle[nFallbackLevel]->GetKashidaWidth());
 }
 
-FontCharMapRef Qt5Graphics::GetFontCharMap() const
+FontCharMapRef QtGraphics::GetFontCharMap() const
 {
     if (!m_pTextStyle[0])
         return FontCharMapRef(new FontCharMap());
     return m_pTextStyle[0]->GetFontFace()->GetFontCharMap();
 }
 
-bool Qt5Graphics::GetFontCapabilities(vcl::FontCapabilities& rFontCapabilities) const
+bool QtGraphics::GetFontCapabilities(vcl::FontCapabilities& rFontCapabilities) const
 {
     if (!m_pTextStyle[0])
         return false;
     return m_pTextStyle[0]->GetFontFace()->GetFontCapabilities(rFontCapabilities);
 }
 
-void Qt5Graphics::GetDevFontList(PhysicalFontCollection* pPFC)
+void QtGraphics::GetDevFontList(PhysicalFontCollection* pPFC)
 {
     static const bool bUseFontconfig = (nullptr == getenv("SAL_VCL_QT5_NO_FONTCONFIG"));
 
@@ -119,32 +119,32 @@ void Qt5Graphics::GetDevFontList(PhysicalFontCollection* pPFC)
 
     for (auto& family : aFDB.families())
         for (auto& style : aFDB.styles(family))
-            pPFC->Add(Qt5FontFace::fromQFontDatabase(family, style));
+            pPFC->Add(QtFontFace::fromQFontDatabase(family, style));
 }
 
-void Qt5Graphics::ClearDevFontCache() {}
+void QtGraphics::ClearDevFontCache() {}
 
-bool Qt5Graphics::AddTempDevFont(PhysicalFontCollection*, const OUString& /*rFileURL*/,
-                                 const OUString& /*rFontName*/)
+bool QtGraphics::AddTempDevFont(PhysicalFontCollection*, const OUString& /*rFileURL*/,
+                                const OUString& /*rFontName*/)
 {
     return false;
 }
 
 namespace
 {
-class Qt5TrueTypeFont : public vcl::AbstractTrueTypeFont
+class QtTrueTypeFont : public vcl::AbstractTrueTypeFont
 {
     const QRawFont& m_aRawFont;
     mutable QByteArray m_aFontTable[vcl::NUM_TAGS];
 
 public:
-    Qt5TrueTypeFont(const Qt5FontFace& aFontFace, const QRawFont& aRawFont);
+    QtTrueTypeFont(const QtFontFace& aFontFace, const QRawFont& aRawFont);
 
     bool hasTable(sal_uInt32 ord) const override;
     const sal_uInt8* table(sal_uInt32 ord, sal_uInt32& size) const override;
 };
 
-Qt5TrueTypeFont::Qt5TrueTypeFont(const Qt5FontFace& aFontFace, const QRawFont& aRawFont)
+QtTrueTypeFont::QtTrueTypeFont(const QtFontFace& aFontFace, const QRawFont& aRawFont)
     : vcl::AbstractTrueTypeFont(nullptr, aFontFace.GetFontCharMap())
     , m_aRawFont(aRawFont)
 {
@@ -194,7 +194,7 @@ const char* vclFontTableAsChar(sal_uInt32 ord)
     }
 }
 
-bool Qt5TrueTypeFont::hasTable(sal_uInt32 ord) const
+bool QtTrueTypeFont::hasTable(sal_uInt32 ord) const
 {
     const char* table_char = vclFontTableAsChar(ord);
     if (!table_char)
@@ -204,7 +204,7 @@ bool Qt5TrueTypeFont::hasTable(sal_uInt32 ord) const
     return !m_aFontTable[ord].isEmpty();
 }
 
-const sal_uInt8* Qt5TrueTypeFont::table(sal_uInt32 ord, sal_uInt32& size) const
+const sal_uInt8* QtTrueTypeFont::table(sal_uInt32 ord, sal_uInt32& size) const
 {
     const char* table_char = vclFontTableAsChar(ord);
     if (!table_char)
@@ -216,17 +216,17 @@ const sal_uInt8* Qt5TrueTypeFont::table(sal_uInt32 ord, sal_uInt32& size) const
 }
 }
 
-bool Qt5Graphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFace* pFontFace,
-                                   const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
-                                   sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo)
+bool QtGraphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFace* pFontFace,
+                                  const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
+                                  sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo)
 {
     OUString aSysPath;
     if (osl_File_E_None != osl_getSystemPathFromFileURL(rToFile.pData, &aSysPath.pData))
         return false;
 
     // get the raw-bytes from the font to be subset
-    const Qt5FontFace* pQt5FontFace = static_cast<const Qt5FontFace*>(pFontFace);
-    const QFont aFont = pQt5FontFace->CreateFont();
+    const QtFontFace* pQtFontFace = static_cast<const QtFontFace*>(pFontFace);
+    const QFont aFont = pQtFontFace->CreateFont();
     const QRawFont aRawFont(QRawFont::fromFont(aFont));
     const OString aToFile(OUStringToOString(aSysPath, osl_getThreadTextEncoding()));
 
@@ -244,7 +244,7 @@ bool Qt5Graphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFa
     rInfo.m_nAscent = aRawFont.ascent();
     rInfo.m_nDescent = aRawFont.descent();
 
-    Qt5TrueTypeFont aTTF(*pQt5FontFace, aRawFont);
+    QtTrueTypeFont aTTF(*pQtFontFace, aRawFont);
     int nXmin, nYmin, nXmax, nYmax;
     sal_uInt16 nMacStyleFlags;
     if (GetTTGlobalFontHeadInfo(&aTTF, nXmin, nYmin, nXmax, nYmax, nMacStyleFlags))
@@ -254,28 +254,28 @@ bool Qt5Graphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFa
                                             pGlyphIds, pEncoding, pGlyphWidths, nGlyphCount);
 }
 
-const void* Qt5Graphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/)
+const void* QtGraphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/)
 {
     return nullptr;
 }
 
-void Qt5Graphics::FreeEmbedFontData(const void* /*pData*/, tools::Long /*nDataLen*/) {}
+void QtGraphics::FreeEmbedFontData(const void* /*pData*/, tools::Long /*nDataLen*/) {}
 
-void Qt5Graphics::GetGlyphWidths(const PhysicalFontFace* pFontFace, bool bVertical,
-                                 std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
+void QtGraphics::GetGlyphWidths(const PhysicalFontFace* pFontFace, bool bVertical,
+                                std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
 {
-    const Qt5FontFace* pQt5FontFace = static_cast<const Qt5FontFace*>(pFontFace);
-    const QRawFont aRawFont(QRawFont::fromFont(pQt5FontFace->CreateFont()));
-    Qt5TrueTypeFont aTTF(*pQt5FontFace, aRawFont);
+    const QtFontFace* pQtFontFace = static_cast<const QtFontFace*>(pFontFace);
+    const QRawFont aRawFont(QRawFont::fromFont(pQtFontFace->CreateFont()));
+    QtTrueTypeFont aTTF(*pQtFontFace, aRawFont);
     SalGraphics::GetGlyphWidths(aTTF, *pFontFace, bVertical, rWidths, rUnicodeEnc);
 }
 
 namespace
 {
-class Qt5CommonSalLayout : public GenericSalLayout
+class QtCommonSalLayout : public GenericSalLayout
 {
 public:
-    Qt5CommonSalLayout(LogicalFontInstance& rLFI)
+    QtCommonSalLayout(LogicalFontInstance& rLFI)
         : GenericSalLayout(rLFI)
     {
     }
@@ -284,17 +284,17 @@ public:
 };
 }
 
-std::unique_ptr<GenericSalLayout> Qt5Graphics::GetTextLayout(int nFallbackLevel)
+std::unique_ptr<GenericSalLayout> QtGraphics::GetTextLayout(int nFallbackLevel)
 {
     assert(m_pTextStyle[nFallbackLevel]);
     if (!m_pTextStyle[nFallbackLevel])
         return nullptr;
-    return std::make_unique<Qt5CommonSalLayout>(*m_pTextStyle[nFallbackLevel]);
+    return std::make_unique<QtCommonSalLayout>(*m_pTextStyle[nFallbackLevel]);
 }
 
-void Qt5Graphics::DrawTextLayout(const GenericSalLayout& rLayout)
+void QtGraphics::DrawTextLayout(const GenericSalLayout& rLayout)
 {
-    const Qt5Font* pFont = static_cast<const Qt5Font*>(&rLayout.GetFont());
+    const QtFont* pFont = static_cast<const QtFont*>(&rLayout.GetFont());
     assert(pFont);
     QRawFont aRawFont(QRawFont::fromFont(*pFont));
 
@@ -303,11 +303,11 @@ void Qt5Graphics::DrawTextLayout(const GenericSalLayout& rLayout)
 
     // prevent glyph rotation inside the SalLayout
     // probably better to add a parameter to GetNextGlyphs?
-    Qt5CommonSalLayout* pQt5Layout
-        = static_cast<Qt5CommonSalLayout*>(const_cast<GenericSalLayout*>(&rLayout));
+    QtCommonSalLayout* pQtLayout
+        = static_cast<QtCommonSalLayout*>(const_cast<GenericSalLayout*>(&rLayout));
     Degree10 nOrientation = rLayout.GetOrientation();
     if (nOrientation)
-        pQt5Layout->SetOrientation(0_deg10);
+        pQtLayout->SetOrientation(0_deg10);
 
     Point aPos;
     const GlyphItem* pGlyph;
@@ -323,14 +323,14 @@ void Qt5Graphics::DrawTextLayout(const GenericSalLayout& rLayout)
         return;
 
     if (nOrientation)
-        pQt5Layout->SetOrientation(nOrientation);
+        pQtLayout->SetOrientation(nOrientation);
 
     QGlyphRun aGlyphRun;
     aGlyphRun.setPositions(positions);
     aGlyphRun.setGlyphIndexes(glyphIndexes);
     aGlyphRun.setRawFont(aRawFont);
 
-    Qt5Painter aPainter(*m_pBackend);
+    QtPainter aPainter(*m_pBackend);
     QColor aColor = toQColor(m_aTextColor);
     aPainter.setPen(aColor);
 
diff --git a/vcl/qt5/Qt5Instance.cxx b/vcl/qt5/Qt5Instance.cxx
index c1e82aa6a0d9..d93b25f5bb89 100644
--- a/vcl/qt5/Qt5Instance.cxx
+++ b/vcl/qt5/Qt5Instance.cxx
@@ -61,9 +61,9 @@ Q_IMPORT_PLUGIN(QWasmIntegrationPlugin)
 
 namespace
 {
-/// TODO: not much Qt5 specific here? could be generalised, esp. for OSX...
+/// TODO: not much Qt specific here? could be generalised, esp. for OSX...
 /// this subclass allows for the transfer of a closure for running on the main
-/// thread, to handle all the thread affine stuff in Qt5; the SolarMutex is
+/// thread, to handle all the thread affine stuff in Qt; the SolarMutex is
 /// "loaned" to the main thread for the execution of the closure.
 /// @note it doesn't work to just use "emit" and signals/slots to move calls to
 /// the main thread, because the other thread has the SolarMutex; the other
@@ -71,7 +71,7 @@ namespace
 /// will handle all sorts of events and whatnot; this design ensures that the
 /// main thread only runs the passed closure (unless the closure releases
 /// SolarMutex itself, which should probably be avoided).
-class Qt5YieldMutex : public SalYieldMutex
+class QtYieldMutex : public SalYieldMutex
 {
 public:
     /// flag only accessed on main thread:
@@ -92,9 +92,9 @@ public:
 };
 }
 
-bool Qt5YieldMutex::IsCurrentThread() const
+bool QtYieldMutex::IsCurrentThread() const
 {
-    auto const* pSalInst(static_cast<Qt5Instance const*>(GetSalData()->m_pInstance));
+    auto const* pSalInst(static_cast<QtInstance const*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (pSalInst->IsMainThread() && m_bNoYieldLock)
     {
@@ -103,9 +103,9 @@ bool Qt5YieldMutex::IsCurrentThread() const
     return SalYieldMutex::IsCurrentThread();
 }
 
-void Qt5YieldMutex::doAcquire(sal_uInt32 nLockCount)
+void QtYieldMutex::doAcquire(sal_uInt32 nLockCount)
 {
-    auto const* pSalInst(static_cast<Qt5Instance const*>(GetSalData()->m_pInstance));
+    auto const* pSalInst(static_cast<QtInstance const*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -149,9 +149,9 @@ void Qt5YieldMutex::doAcquire(sal_uInt32 nLockCount)
     SalYieldMutex::doAcquire(nLockCount);
 }
 
-sal_uInt32 Qt5YieldMutex::doRelease(bool const bUnlockAll)
+sal_uInt32 QtYieldMutex::doRelease(bool const bUnlockAll)
 {
-    auto const* pSalInst(static_cast<Qt5Instance const*>(GetSalData()->m_pInstance));
+    auto const* pSalInst(static_cast<QtInstance const*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (pSalInst->IsMainThread() && m_bNoYieldLock)
     {
@@ -170,11 +170,11 @@ sal_uInt32 Qt5YieldMutex::doRelease(bool const bUnlockAll)
     return nCount;
 }
 
-// this could be abstracted to be independent of Qt5 by passing in the
+// this could be abstracted to be independent of Qt by passing in the
 // event-trigger as another function parameter...
 // it could also be a template of the return type, then it could return the
 // result of func... but then how to handle the result in doAcquire?
-void Qt5Instance::RunInMainThread(std::function<void()> func)
+void QtInstance::RunInMainThread(std::function<void()> func)
 {
     DBG_TESTSOLARMUTEX();
     if (IsMainThread())
@@ -183,7 +183,7 @@ void Qt5Instance::RunInMainThread(std::function<void()> func)
         return;
     }
 
-    Qt5YieldMutex* const pMutex(static_cast<Qt5YieldMutex*>(GetYieldMutex()));
+    QtYieldMutex* const pMutex(static_cast<QtYieldMutex*>(GetYieldMutex()));
     {
         std::scoped_lock<std::mutex> g(pMutex->m_RunInMainMutex);
         assert(!pMutex->m_Closure);
@@ -201,7 +201,7 @@ void Qt5Instance::RunInMainThread(std::function<void()> func)
     }
 }
 
-OUString Qt5Instance::constructToolkitID(std::u16string_view sTKname)
+OUString QtInstance::constructToolkitID(std::u16string_view sTKname)
 {
     OUString sID(sTKname + OUString::Concat(u" ("));
     if (m_bUseCairo)
@@ -212,8 +212,8 @@ OUString Qt5Instance::constructToolkitID(std::u16string_view sTKname)
     return sID;
 }
 
-Qt5Instance::Qt5Instance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo)
-    : SalGenericInstance(std::make_unique<Qt5YieldMutex>())
+QtInstance::QtInstance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo)
+    : SalGenericInstance(std::make_unique<QtYieldMutex>())
     , m_bUseCairo(bUseCairo)
     , m_pTimer(nullptr)
     , m_bSleeping(false)
@@ -231,12 +231,11 @@ Qt5Instance::Qt5Instance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo)
 
     // this one needs to be queued non-blocking
     // in order to have this event arriving to correct event processing loop
-    connect(this, &Qt5Instance::deleteObjectLaterSignal, this,
-            [](QObject* pObject) { Qt5Instance::deleteObjectLater(pObject); },
-            Qt::QueuedConnection);
+    connect(this, &QtInstance::deleteObjectLaterSignal, this,
+            [](QObject* pObject) { QtInstance::deleteObjectLater(pObject); }, Qt::QueuedConnection);
 
     m_aUpdateStyleTimer.SetTimeout(50);
-    m_aUpdateStyleTimer.SetInvokeHandler(LINK(this, Qt5Instance, updateStyleHdl));
+    m_aUpdateStyleTimer.SetInvokeHandler(LINK(this, QtInstance, updateStyleHdl));
 
     QAbstractEventDispatcher* dispatcher = QAbstractEventDispatcher::instance(qApp->thread());
     connect(dispatcher, &QAbstractEventDispatcher::awake, this, [this]() { m_bSleeping = false; });
@@ -244,21 +243,21 @@ Qt5Instance::Qt5Instance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo)
             [this]() { m_bSleeping = true; });
 
     connect(QGuiApplication::inputMethod(), &QInputMethod::localeChanged, this,
-            &Qt5Instance::localeChanged);
+            &QtInstance::localeChanged);
 
 #ifndef EMSCRIPTEN
     m_bSupportsOpenGL = true;
 #endif
 }
 
-Qt5Instance::~Qt5Instance()
+QtInstance::~QtInstance()
 {
     // force freeing the QApplication before freeing the arguments,
     // as it uses references to the provided arguments!
     m_pQApplication.reset();
 }
 
-void Qt5Instance::AfterAppInit()
+void QtInstance::AfterAppInit()
 {
     // set the default application icon via desktop file just on Wayland,
     // as this otherwise overrides the individual desktop icons on X11.
@@ -268,7 +267,7 @@ void Qt5Instance::AfterAppInit()
                                                                     : Qt::LeftToRight);
 }
 
-void Qt5Instance::localeChanged()
+void QtInstance::localeChanged()
 {
     SolarMutexGuard aGuard;
     const vcl::Window* pFocusWindow = Application::GetFocusWindow();
@@ -278,87 +277,87 @@ void Qt5Instance::localeChanged()
 
     const LanguageTag aTag(
         toOUString(QGuiApplication::inputMethod()->locale().name().replace("_", "-")));
-    static_cast<Qt5Frame*>(pFocusFrame)->setInputLanguage(aTag.getLanguageType());
+    static_cast<QtFrame*>(pFocusFrame)->setInputLanguage(aTag.getLanguageType());
 }
 
-void Qt5Instance::deleteObjectLater(QObject* pObject) { pObject->deleteLater(); }
+void QtInstance::deleteObjectLater(QObject* pObject) { pObject->deleteLater(); }
 
-SalFrame* Qt5Instance::CreateChildFrame(SystemParentData* /*pParent*/, SalFrameStyleFlags nStyle)
+SalFrame* QtInstance::CreateChildFrame(SystemParentData* /*pParent*/, SalFrameStyleFlags nStyle)
 {
     SalFrame* pRet(nullptr);
-    RunInMainThread([&, this]() { pRet = new Qt5Frame(nullptr, nStyle, useCairo()); });
+    RunInMainThread([&, this]() { pRet = new QtFrame(nullptr, nStyle, useCairo()); });
     assert(pRet);
     return pRet;
 }
 
-SalFrame* Qt5Instance::CreateFrame(SalFrame* pParent, SalFrameStyleFlags nStyle)
+SalFrame* QtInstance::CreateFrame(SalFrame* pParent, SalFrameStyleFlags nStyle)
 {
-    assert(!pParent || dynamic_cast<Qt5Frame*>(pParent));
+    assert(!pParent || dynamic_cast<QtFrame*>(pParent));
 
     SalFrame* pRet(nullptr);
     RunInMainThread(
-        [&, this]() { pRet = new Qt5Frame(static_cast<Qt5Frame*>(pParent), nStyle, useCairo()); });
+        [&, this]() { pRet = new QtFrame(static_cast<QtFrame*>(pParent), nStyle, useCairo()); });
     assert(pRet);
     return pRet;
 }
 
-void Qt5Instance::DestroyFrame(SalFrame* pFrame)
+void QtInstance::DestroyFrame(SalFrame* pFrame)
 {
     if (pFrame)
     {
-        assert(dynamic_cast<Qt5Frame*>(pFrame));
-        Q_EMIT deleteObjectLaterSignal(static_cast<Qt5Frame*>(pFrame));
+        assert(dynamic_cast<QtFrame*>(pFrame));
+        Q_EMIT deleteObjectLaterSignal(static_cast<QtFrame*>(pFrame));
     }
 }
 
-SalObject* Qt5Instance::CreateObject(SalFrame* pParent, SystemWindowData*, bool bShow)
+SalObject* QtInstance::CreateObject(SalFrame* pParent, SystemWindowData*, bool bShow)
 {
-    assert(!pParent || dynamic_cast<Qt5Frame*>(pParent));
+    assert(!pParent || dynamic_cast<QtFrame*>(pParent));
 
     SalObject* pRet(nullptr);
-    RunInMainThread([&]() { pRet = new Qt5Object(static_cast<Qt5Frame*>(pParent), bShow); });
+    RunInMainThread([&]() { pRet = new QtObject(static_cast<QtFrame*>(pParent), bShow); });
     assert(pRet);
     return pRet;
 }
 
-void Qt5Instance::DestroyObject(SalObject* pObject)
+void QtInstance::DestroyObject(SalObject* pObject)
 {
     if (pObject)
     {
-        assert(dynamic_cast<Qt5Object*>(pObject));
-        Q_EMIT deleteObjectLaterSignal(static_cast<Qt5Object*>(pObject));
+        assert(dynamic_cast<QtObject*>(pObject));
+        Q_EMIT deleteObjectLaterSignal(static_cast<QtObject*>(pObject));
     }
 }
 
 std::unique_ptr<SalVirtualDevice>
-Qt5Instance::CreateVirtualDevice(SalGraphics& rGraphics, tools::Long& nDX, tools::Long& nDY,
-                                 DeviceFormat /*eFormat*/, const SystemGraphicsData* pGd)
+QtInstance::CreateVirtualDevice(SalGraphics& rGraphics, tools::Long& nDX, tools::Long& nDY,
+                                DeviceFormat /*eFormat*/, const SystemGraphicsData* pGd)
 {
     if (m_bUseCairo)
     {
-        SvpSalGraphics* pSvpSalGraphics = dynamic_cast<Qt5SvpGraphics*>(&rGraphics);
+        SvpSalGraphics* pSvpSalGraphics = dynamic_cast<QtSvpGraphics*>(&rGraphics);
         assert(pSvpSalGraphics);
         // tdf#127529 see SvpSalInstance::CreateVirtualDevice for the rare case of a non-null pPreExistingTarget
         cairo_surface_t* pPreExistingTarget
             = pGd ? static_cast<cairo_surface_t*>(pGd->pSurface) : nullptr;
         std::unique_ptr<SalVirtualDevice> pVD(
-            new Qt5SvpVirtualDevice(pSvpSalGraphics->getSurface(), pPreExistingTarget));
+            new QtSvpVirtualDevice(pSvpSalGraphics->getSurface(), pPreExistingTarget));
         pVD->SetSize(nDX, nDY);
         return pVD;
     }
     else
     {
-        std::unique_ptr<SalVirtualDevice> pVD(new Qt5VirtualDevice(/*scale*/ 1));
+        std::unique_ptr<SalVirtualDevice> pVD(new QtVirtualDevice(/*scale*/ 1));
         pVD->SetSize(nDX, nDY);
         return pVD;
     }
 }
 
-std::unique_ptr<SalMenu> Qt5Instance::CreateMenu(bool bMenuBar, Menu* pVCLMenu)
+std::unique_ptr<SalMenu> QtInstance::CreateMenu(bool bMenuBar, Menu* pVCLMenu)
 {
     std::unique_ptr<SalMenu> pRet;
     RunInMainThread([&pRet, bMenuBar, pVCLMenu]() {
-        Qt5Menu* pSalMenu = new Qt5Menu(bMenuBar);
+        QtMenu* pSalMenu = new QtMenu(bMenuBar);
         pRet.reset(pSalMenu);
         pSalMenu->SetMenu(pVCLMenu);
     });
@@ -366,28 +365,28 @@ std::unique_ptr<SalMenu> Qt5Instance::CreateMenu(bool bMenuBar, Menu* pVCLMenu)
     return pRet;
 }
 
-std::unique_ptr<SalMenuItem> Qt5Instance::CreateMenuItem(const SalItemParams& rItemData)
+std::unique_ptr<SalMenuItem> QtInstance::CreateMenuItem(const SalItemParams& rItemData)
 {
-    return std::unique_ptr<SalMenuItem>(new Qt5MenuItem(&rItemData));
+    return std::unique_ptr<SalMenuItem>(new QtMenuItem(&rItemData));
 }
 
-SalTimer* Qt5Instance::CreateSalTimer()
+SalTimer* QtInstance::CreateSalTimer()
 {
-    m_pTimer = new Qt5Timer();
+    m_pTimer = new QtTimer();
     return m_pTimer;
 }
 
-SalSystem* Qt5Instance::CreateSalSystem() { return new Qt5System; }
+SalSystem* QtInstance::CreateSalSystem() { return new QtSystem; }
 
-std::shared_ptr<SalBitmap> Qt5Instance::CreateSalBitmap()
+std::shared_ptr<SalBitmap> QtInstance::CreateSalBitmap()
 {
     if (m_bUseCairo)
         return std::make_shared<SvpSalBitmap>();
     else
-        return std::make_shared<Qt5Bitmap>();
+        return std::make_shared<QtBitmap>();
 }
 
-bool Qt5Instance::ImplYield(bool bWait, bool bHandleAllCurrentEvents)
+bool QtInstance::ImplYield(bool bWait, bool bHandleAllCurrentEvents)
 {
     // Re-acquire the guard for user events when called via Q_EMIT ImplYieldSignal
     SolarMutexGuard aGuard;
@@ -408,7 +407,7 @@ bool Qt5Instance::ImplYield(bool bWait, bool bHandleAllCurrentEvents)
     return wasEvent;
 }
 
-bool Qt5Instance::DoYield(bool bWait, bool bHandleAllCurrentEvents)
+bool QtInstance::DoYield(bool bWait, bool bHandleAllCurrentEvents)
 {
     bool bWasEvent = false;
     if (qApp->thread() == QThread::currentThread())
@@ -434,7 +433,7 @@ bool Qt5Instance::DoYield(bool bWait, bool bHandleAllCurrentEvents)
     return bWasEvent;
 }
 
-bool Qt5Instance::AnyInput(VclInputFlags nType)
+bool QtInstance::AnyInput(VclInputFlags nType)
 {
     bool bResult = false;
     if (nType & VclInputFlags::TIMER)
@@ -444,62 +443,62 @@ bool Qt5Instance::AnyInput(VclInputFlags nType)
     return bResult;
 }
 
-OUString Qt5Instance::GetConnectionIdentifier() { return OUString(); }
+OUString QtInstance::GetConnectionIdentifier() { return OUString(); }
 
-void Qt5Instance::AddToRecentDocumentList(const OUString&, const OUString&, const OUString&) {}
+void QtInstance::AddToRecentDocumentList(const OUString&, const OUString&, const OUString&) {}
 
 #ifndef EMSCRIPTEN
-OpenGLContext* Qt5Instance::CreateOpenGLContext() { return new Qt5OpenGLContext; }
+OpenGLContext* QtInstance::CreateOpenGLContext() { return new QtOpenGLContext; }
 #endif
 
-bool Qt5Instance::IsMainThread() const
+bool QtInstance::IsMainThread() const
 {
     return !qApp || (qApp->thread() == QThread::currentThread());
 }
 
-void Qt5Instance::TriggerUserEventProcessing()
+void QtInstance::TriggerUserEventProcessing()
 {
     QAbstractEventDispatcher* dispatcher = QAbstractEventDispatcher::instance(qApp->thread());
     dispatcher->wakeUp();
 }
 
-void Qt5Instance::ProcessEvent(SalUserEvent aEvent)
+void QtInstance::ProcessEvent(SalUserEvent aEvent)
 {
     aEvent.m_pFrame->CallCallback(aEvent.m_nEvent, aEvent.m_pData);
 }
 
-rtl::Reference<Qt5FilePicker>
-Qt5Instance::createPicker(css::uno::Reference<css::uno::XComponentContext> const& context,
-                          QFileDialog::FileMode eMode)
+rtl::Reference<QtFilePicker>
+QtInstance::createPicker(css::uno::Reference<css::uno::XComponentContext> const& context,
+                         QFileDialog::FileMode eMode)
 {
     if (!IsMainThread())
     {
         SolarMutexGuard g;
-        rtl::Reference<Qt5FilePicker> pPicker;
+        rtl::Reference<QtFilePicker> pPicker;
         RunInMainThread([&, this]() { pPicker = createPicker(context, eMode); });
         assert(pPicker);
         return pPicker;
     }
 
-    return new Qt5FilePicker(context, eMode);
+    return new QtFilePicker(context, eMode);
 }
 
 css::uno::Reference<css::ui::dialogs::XFilePicker2>
-Qt5Instance::createFilePicker(const css::uno::Reference<css::uno::XComponentContext>& context)
+QtInstance::createFilePicker(const css::uno::Reference<css::uno::XComponentContext>& context)
 {
     return css::uno::Reference<css::ui::dialogs::XFilePicker2>(
         createPicker(context, QFileDialog::ExistingFile));
 }
 
 css::uno::Reference<css::ui::dialogs::XFolderPicker2>
-Qt5Instance::createFolderPicker(const css::uno::Reference<css::uno::XComponentContext>& context)
+QtInstance::createFolderPicker(const css::uno::Reference<css::uno::XComponentContext>& context)
 {
     return css::uno::Reference<css::ui::dialogs::XFolderPicker2>(
         createPicker(context, QFileDialog::Directory));
 }
 
 css::uno::Reference<css::uno::XInterface>
-Qt5Instance::CreateClipboard(const css::uno::Sequence<css::uno::Any>& arguments)
+QtInstance::CreateClipboard(const css::uno::Sequence<css::uno::Any>& arguments)
 {
     OUString sel;
     if (arguments.getLength() == 0)
@@ -508,7 +507,7 @@ Qt5Instance::CreateClipboard(const css::uno::Sequence<css::uno::Any>& arguments)
     }
     else if (arguments.getLength() != 1 || !(arguments[0] >>= sel))
     {
-        throw css::lang::IllegalArgumentException("bad Qt5Instance::CreateClipboard arguments",
+        throw css::lang::IllegalArgumentException("bad QtInstance::CreateClipboard arguments",
                                                   css::uno::Reference<css::uno::XInterface>(), -1);
     }
 
@@ -521,26 +520,26 @@ Qt5Instance::CreateClipboard(const css::uno::Sequence<css::uno::Any>& arguments)
     if (it != m_aClipboards.end())
         return it->second;
 
-    css::uno::Reference<css::uno::XInterface> xClipboard = Qt5Clipboard::create(sel);
+    css::uno::Reference<css::uno::XInterface> xClipboard = QtClipboard::create(sel);
     if (xClipboard.is())
         m_aClipboards[sel] = xClipboard;
 
     return xClipboard;
 }
 
-css::uno::Reference<css::uno::XInterface> Qt5Instance::CreateDragSource()
+css::uno::Reference<css::uno::XInterface> QtInstance::CreateDragSource()
 {
     return css::uno::Reference<css::uno::XInterface>(
-        static_cast<cppu::OWeakObject*>(new Qt5DragSource()));
+        static_cast<cppu::OWeakObject*>(new QtDragSource()));
 }
 
-css::uno::Reference<css::uno::XInterface> Qt5Instance::CreateDropTarget()
+css::uno::Reference<css::uno::XInterface> QtInstance::CreateDropTarget()
 {
     return css::uno::Reference<css::uno::XInterface>(
-        static_cast<cppu::OWeakObject*>(new Qt5DropTarget()));
+        static_cast<cppu::OWeakObject*>(new QtDropTarget()));
 }
 
-IMPL_LINK_NOARG(Qt5Instance, updateStyleHdl, Timer*, void)
+IMPL_LINK_NOARG(QtInstance, updateStyleHdl, Timer*, void)
 {
     SolarMutexGuard aGuard;
     SalFrame* pFrame = anyFrame();
@@ -555,7 +554,7 @@ IMPL_LINK_NOARG(Qt5Instance, updateStyleHdl, Timer*, void)
     }
 }
 
-void Qt5Instance::UpdateStyle(bool bFontsChanged)
+void QtInstance::UpdateStyle(bool bFontsChanged)
 {
     if (bFontsChanged)
         m_bUpdateFonts = true;
@@ -563,7 +562,7 @@ void Qt5Instance::UpdateStyle(bool bFontsChanged)
         m_aUpdateStyleTimer.Start();
 }
 
-void* Qt5Instance::CreateGStreamerSink(const SystemChildWindow* pWindow)
+void* QtInstance::CreateGStreamerSink(const SystemChildWindow* pWindow)
 {
 #if ENABLE_GSTREAMER_1_0 && QT5_HAVE_GOBJECT
     auto pSymbol = gstElementFactoryNameSymbol();
@@ -598,9 +597,9 @@ void* Qt5Instance::CreateGStreamerSink(const SystemChildWindow* pWindow)
 #endif
 }
 
-void Qt5Instance::AllocFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
-                                       std::unique_ptr<int>& rFakeArgc,
-                                       std::vector<FreeableCStr>& rFakeArgvFreeable)
+void QtInstance::AllocFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
+                                      std::unique_ptr<int>& rFakeArgc,
+                                      std::vector<FreeableCStr>& rFakeArgvFreeable)
 {
     OString aVersion(qVersion());
     SAL_INFO("vcl.qt5", "qt version string is " << aVersion);
@@ -644,16 +643,16 @@ void Qt5Instance::AllocFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
     *rFakeArgc = nFakeArgc;
 }
 
-void Qt5Instance::MoveFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
-                                      std::unique_ptr<int>& rFakeArgc,
-                                      std::vector<FreeableCStr>& rFakeArgvFreeable)
+void QtInstance::MoveFakeCmdlineArgs(std::unique_ptr<char* []>& rFakeArgv,
+                                     std::unique_ptr<int>& rFakeArgc,
+                                     std::vector<FreeableCStr>& rFakeArgvFreeable)
 {
     m_pFakeArgv = std::move(rFakeArgv);
     m_pFakeArgc = std::move(rFakeArgc);
     m_pFakeArgvFreeable.swap(rFakeArgvFreeable);
 }
 
-std::unique_ptr<QApplication> Qt5Instance::CreateQApplication(int& nArgc, char** pArgv)
+std::unique_ptr<QApplication> QtInstance::CreateQApplication(int& nArgc, char** pArgv)
 {
     QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
     // for scaled icons in the native menus
@@ -686,15 +685,15 @@ VCLPLUG_QT5_PUBLIC SalInstance* create_SalInstance()
     std::unique_ptr<char* []> pFakeArgv;
     std::unique_ptr<int> pFakeArgc;
     std::vector<FreeableCStr> aFakeArgvFreeable;
-    Qt5Instance::AllocFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
+    QtInstance::AllocFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
 
     std::unique_ptr<QApplication> pQApp
-        = Qt5Instance::CreateQApplication(*pFakeArgc, pFakeArgv.get());
+        = QtInstance::CreateQApplication(*pFakeArgc, pFakeArgv.get());
 
-    Qt5Instance* pInstance = new Qt5Instance(pQApp, bUseCairo);
+    QtInstance* pInstance = new QtInstance(pQApp, bUseCairo);
     pInstance->MoveFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
 
-    new Qt5Data(pInstance);
+    new QtData(pInstance);
 
     return pInstance;
 }
diff --git a/vcl/qt5/Qt5Instance_Print.cxx b/vcl/qt5/Qt5Instance_Print.cxx
index 99083ae84697..2f9a096f7eb9 100644
--- a/vcl/qt5/Qt5Instance_Print.cxx
+++ b/vcl/qt5/Qt5Instance_Print.cxx
@@ -64,8 +64,8 @@ static OUString getPdfDir(const PrinterInfo& rInfo)
     return aDir;
 }
 
-SalInfoPrinter* Qt5Instance::CreateInfoPrinter(SalPrinterQueueInfo* pQueueInfo,
-                                               ImplJobSetup* pJobSetup)
+SalInfoPrinter* QtInstance::CreateInfoPrinter(SalPrinterQueueInfo* pQueueInfo,
+                                              ImplJobSetup* pJobSetup)
 {
     // create and initialize SalInfoPrinter
     PspSalInfoPrinter* pPrinter = new PspSalInfoPrinter;
@@ -74,18 +74,18 @@ SalInfoPrinter* Qt5Instance::CreateInfoPrinter(SalPrinterQueueInfo* pQueueInfo,
     return pPrinter;
 }
 
-void Qt5Instance::DestroyInfoPrinter(SalInfoPrinter* pPrinter) { delete pPrinter; }
+void QtInstance::DestroyInfoPrinter(SalInfoPrinter* pPrinter) { delete pPrinter; }
 
-std::unique_ptr<SalPrinter> Qt5Instance::CreatePrinter(SalInfoPrinter* pInfoPrinter)
+std::unique_ptr<SalPrinter> QtInstance::CreatePrinter(SalInfoPrinter* pInfoPrinter)
 {
     // create and initialize SalPrinter
-    Qt5Printer* pPrinter = new Qt5Printer(pInfoPrinter);
+    QtPrinter* pPrinter = new QtPrinter(pInfoPrinter);
     pPrinter->m_aJobData = static_cast<PspSalInfoPrinter*>(pInfoPrinter)->m_aJobData;
 
     return std::unique_ptr<SalPrinter>(pPrinter);
 }
 
-void Qt5Instance::GetPrinterQueueInfo(ImplPrnQueueList* pList)
+void QtInstance::GetPrinterQueueInfo(ImplPrnQueueList* pList)
 {
     PrinterInfoManager& rManager(PrinterInfoManager::get());
     static const char* pNoSyncDetection = getenv("SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION");
@@ -122,17 +122,17 @@ void Qt5Instance::GetPrinterQueueInfo(ImplPrnQueueList* pList)
     }
 }
 
-void Qt5Instance::GetPrinterQueueState(SalPrinterQueueInfo*) {}
+void QtInstance::GetPrinterQueueState(SalPrinterQueueInfo*) {}
 
-OUString Qt5Instance::GetDefaultPrinter()
+OUString QtInstance::GetDefaultPrinter()
 {
     PrinterInfoManager& rManager(PrinterInfoManager::get());
     return rManager.getDefaultPrinter();
 }
 
-void Qt5Instance::PostPrintersChanged() {}
+void QtInstance::PostPrintersChanged() {}
 
-std::unique_ptr<GenPspGraphics> Qt5Instance::CreatePrintGraphics()
+std::unique_ptr<GenPspGraphics> QtInstance::CreatePrintGraphics()
 {
     return std::make_unique<GenPspGraphics>();
 }
diff --git a/vcl/qt5/Qt5MainWindow.cxx b/vcl/qt5/Qt5MainWindow.cxx
index 89879864a9bc..3f8814cad73d 100644
--- a/vcl/qt5/Qt5MainWindow.cxx
+++ b/vcl/qt5/Qt5MainWindow.cxx
@@ -15,16 +15,16 @@
 #include <QtGui/QAccessible>
 #include <QtGui/QCloseEvent>
 
-Qt5MainWindow::Qt5MainWindow(Qt5Frame& rFrame, Qt::WindowFlags f)
+QtMainWindow::QtMainWindow(QtFrame& rFrame, Qt::WindowFlags f)
     : QMainWindow(nullptr, f)
     , m_rFrame(rFrame)
 {
 #ifndef EMSCRIPTEN
-    QAccessible::installFactory(Qt5AccessibleWidget::customFactory);
+    QAccessible::installFactory(QtAccessibleWidget::customFactory);
 #endif
 }
 
-void Qt5MainWindow::closeEvent(QCloseEvent* pEvent)
+void QtMainWindow::closeEvent(QCloseEvent* pEvent)
 {
     bool bRet = false;
     bRet = m_rFrame.CallCallback(SalEvent::Close, nullptr);
@@ -38,7 +38,7 @@ void Qt5MainWindow::closeEvent(QCloseEvent* pEvent)
         pEvent->ignore();
 }
 
-void Qt5MainWindow::moveEvent(QMoveEvent* pEvent)
+void QtMainWindow::moveEvent(QMoveEvent* pEvent)
 {
     const qreal fRatio = m_rFrame.devicePixelRatioF();
     m_rFrame.maGeometry.nX = round(pEvent->pos().x() * fRatio);
diff --git a/vcl/qt5/Qt5Menu.cxx b/vcl/qt5/Qt5Menu.cxx
index e8a170407281..ace199df9f88 100644
--- a/vcl/qt5/Qt5Menu.cxx
+++ b/vcl/qt5/Qt5Menu.cxx
@@ -27,7 +27,7 @@
 #include <vcl/toolkit/floatwin.hxx>
 #include <window.h>
 
-Qt5Menu::Qt5Menu(bool bMenuBar)
+QtMenu::QtMenu(bool bMenuBar)
     : mpVCLMenu(nullptr)
     , mpParentSalMenu(nullptr)
     , mpFrame(nullptr)
@@ -38,9 +38,9 @@ Qt5Menu::Qt5Menu(bool bMenuBar)
 {
 }
 
-bool Qt5Menu::VisibleMenuBar() { return true; }
+bool QtMenu::VisibleMenuBar() { return true; }
 
-void Qt5Menu::InsertMenuItem(Qt5MenuItem* pSalMenuItem, unsigned nPos)
+void QtMenu::InsertMenuItem(QtMenuItem* pSalMenuItem, unsigned nPos)
 {
     sal_uInt16 nId = pSalMenuItem->mnId;
     OUString aText = mpVCLMenu->GetItemText(nId);
@@ -174,7 +174,7 @@ void Qt5Menu::InsertMenuItem(Qt5MenuItem* pSalMenuItem, unsigned nPos)
     }
 }
 
-void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
+void QtMenu::ReinitializeActionGroup(unsigned nPos)
 {
     const unsigned nCount = GetItemCount();
 
@@ -192,9 +192,9 @@ void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
         return;
     }
 
-    Qt5MenuItem* pPrevItem = (nPos > 0) ? GetItemAtPos(nPos - 1) : nullptr;
-    Qt5MenuItem* pCurrentItem = GetItemAtPos(nPos);
-    Qt5MenuItem* pNextItem = (nPos < nCount - 1) ? GetItemAtPos(nPos + 1) : nullptr;
+    QtMenuItem* pPrevItem = (nPos > 0) ? GetItemAtPos(nPos - 1) : nullptr;
+    QtMenuItem* pCurrentItem = GetItemAtPos(nPos);
+    QtMenuItem* pNextItem = (nPos < nCount - 1) ? GetItemAtPos(nPos + 1) : nullptr;
 
     if (pCurrentItem->mnType == MenuItemType::SEPARATOR)
     {
@@ -213,7 +213,7 @@ void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
 
             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
             {
-                Qt5MenuItem* pModifiedItem = GetItemAtPos(idx);
+                QtMenuItem* pModifiedItem = GetItemAtPos(idx);
 
                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
                 {
@@ -276,7 +276,7 @@ void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
             // now replace all pointers to second group with pointers to first group
             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
             {
-                Qt5MenuItem* pModifiedItem = GetItemAtPos(idx);
+                QtMenuItem* pModifiedItem = GetItemAtPos(idx);
 
                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
                 {
@@ -289,16 +289,16 @@ void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
     }
 }
 
-void Qt5Menu::ResetAllActionGroups()
+void QtMenu::ResetAllActionGroups()
 {
     for (unsigned nItem = 0; nItem < GetItemCount(); ++nItem)
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nItem);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nItem);
         pSalMenuItem->mpActionGroup.reset();
     }
 }
 
-void Qt5Menu::UpdateActionGroupItem(const Qt5MenuItem* pSalMenuItem)
+void QtMenu::UpdateActionGroupItem(const QtMenuItem* pSalMenuItem)
 {
     QAction* pAction = pSalMenuItem->getAction();
     if (!pAction)
@@ -335,10 +335,10 @@ void Qt5Menu::UpdateActionGroupItem(const Qt5MenuItem* pSalMenuItem)
     }
 }
 
-void Qt5Menu::InsertItem(SalMenuItem* pSalMenuItem, unsigned nPos)
+void QtMenu::InsertItem(SalMenuItem* pSalMenuItem, unsigned nPos)
 {
     SolarMutexGuard aGuard;
-    Qt5MenuItem* pItem = static_cast<Qt5MenuItem*>(pSalMenuItem);
+    QtMenuItem* pItem = static_cast<QtMenuItem*>(pSalMenuItem);
 
     if (nPos == MENU_APPEND)
         maItems.push_back(pItem);
@@ -350,14 +350,14 @@ void Qt5Menu::InsertItem(SalMenuItem* pSalMenuItem, unsigned nPos)
     InsertMenuItem(pItem, nPos);
 }
 
-void Qt5Menu::RemoveItem(unsigned nPos)
+void QtMenu::RemoveItem(unsigned nPos)
 {
     SolarMutexGuard aGuard;
 
     if (nPos >= maItems.size())
         return;
 
-    Qt5MenuItem* pItem = maItems[nPos];
+    QtMenuItem* pItem = maItems[nPos];
     pItem->mpAction.reset();
     pItem->mpMenu.reset();
 
@@ -372,11 +372,11 @@ void Qt5Menu::RemoveItem(unsigned nPos)
     }
 }
 
-void Qt5Menu::SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned nPos)
+void QtMenu::SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned nPos)
 {
     SolarMutexGuard aGuard;
-    Qt5MenuItem* pItem = static_cast<Qt5MenuItem*>(pSalMenuItem);
-    Qt5Menu* pQSubMenu = static_cast<Qt5Menu*>(pSubMenu);
+    QtMenuItem* pItem = static_cast<QtMenuItem*>(pSalMenuItem);
+    QtMenu* pQSubMenu = static_cast<QtMenu*>(pSubMenu);
 
     pItem->mpSubMenu = pQSubMenu;
     // at this point the pointer to parent menu may be outdated, update it too
@@ -402,9 +402,9 @@ void Qt5Menu::SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned
     InsertMenuItem(pItem, nPos);
 }
 
-void Qt5Menu::SetFrame(const SalFrame* pFrame)
+void QtMenu::SetFrame(const SalFrame* pFrame)
 {
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -414,11 +414,11 @@ void Qt5Menu::SetFrame(const SalFrame* pFrame)
 
     SolarMutexGuard aGuard;
     assert(mbMenuBar);
-    mpFrame = const_cast<Qt5Frame*>(static_cast<const Qt5Frame*>(pFrame));
+    mpFrame = const_cast<QtFrame*>(static_cast<const QtFrame*>(pFrame));
 
     mpFrame->SetMenu(this);
 
-    Qt5MainWindow* pMainWindow = mpFrame->GetTopLevelWindow();
+    QtMainWindow* pMainWindow = mpFrame->GetTopLevelWindow();
     if (!pMainWindow)
         return;
 
@@ -431,7 +431,7 @@ void Qt5Menu::SetFrame(const SalFrame* pFrame)
         if (pButton && ((mpCloseButton != pButton) || !maCloseButtonConnection))
         {
             maCloseButtonConnection
-                = connect(pButton, &QPushButton::clicked, this, &Qt5Menu::slotCloseDocument);
+                = connect(pButton, &QPushButton::clicked, this, &QtMenu::slotCloseDocument);
             mpCloseButton = pButton;
         }
     }
@@ -441,7 +441,7 @@ void Qt5Menu::SetFrame(const SalFrame* pFrame)
     DoFullMenuUpdate(mpVCLMenu);
 }
 
-void Qt5Menu::DoFullMenuUpdate(Menu* pMenuBar)
+void QtMenu::DoFullMenuUpdate(Menu* pMenuBar)
 {
     // clear action groups since menu is rebuilt
     ResetAllActionGroups();
@@ -449,7 +449,7 @@ void Qt5Menu::DoFullMenuUpdate(Menu* pMenuBar)
 
     for (sal_Int32 nItem = 0; nItem < static_cast<sal_Int32>(GetItemCount()); nItem++)
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nItem);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nItem);
         InsertMenuItem(pSalMenuItem, nItem);
         SetItemImage(nItem, pSalMenuItem, pSalMenuItem->maImage);
         const bool bShowDisabled
@@ -467,11 +467,11 @@ void Qt5Menu::DoFullMenuUpdate(Menu* pMenuBar)
     }
 }
 
-void Qt5Menu::ShowItem(unsigned nPos, bool bShow)
+void QtMenu::ShowItem(unsigned nPos, bool bShow)
 {
     if (nPos < maItems.size())
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
         QAction* pAction = pSalMenuItem->getAction();
         if (pAction)
             pAction->setVisible(bShow);
@@ -479,20 +479,20 @@ void Qt5Menu::ShowItem(unsigned nPos, bool bShow)
     }
 }
 
-void Qt5Menu::SetItemBits(unsigned nPos, MenuItemBits)
+void QtMenu::SetItemBits(unsigned nPos, MenuItemBits)
 {
     if (nPos < maItems.size())
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
         UpdateActionGroupItem(pSalMenuItem);
     }
 }
 
-void Qt5Menu::CheckItem(unsigned nPos, bool bChecked)
+void QtMenu::CheckItem(unsigned nPos, bool bChecked)
 {
     if (nPos < maItems.size())
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
         QAction* pAction = pSalMenuItem->getAction();
         if (pAction)
         {
@@ -502,11 +502,11 @@ void Qt5Menu::CheckItem(unsigned nPos, bool bChecked)
     }
 }
 
-void Qt5Menu::EnableItem(unsigned nPos, bool bEnable)
+void QtMenu::EnableItem(unsigned nPos, bool bEnable)
 {
     if (nPos < maItems.size())
     {
-        Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
+        QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
         QAction* pAction = pSalMenuItem->getAction();
         if (pAction)
             pAction->setEnabled(bEnable);
@@ -514,9 +514,9 @@ void Qt5Menu::EnableItem(unsigned nPos, bool bEnable)
     }
 }
 
-void Qt5Menu::SetItemText(unsigned, SalMenuItem* pItem, const OUString& rText)
+void QtMenu::SetItemText(unsigned, SalMenuItem* pItem, const OUString& rText)
 {
-    Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
+    QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
     QAction* pAction = pSalMenuItem->getAction();
     if (pAction)
     {
@@ -526,9 +526,9 @@ void Qt5Menu::SetItemText(unsigned, SalMenuItem* pItem, const OUString& rText)
     }
 }
 
-void Qt5Menu::SetItemImage(unsigned, SalMenuItem* pItem, const Image& rImage)
+void QtMenu::SetItemImage(unsigned, SalMenuItem* pItem, const Image& rImage)
 {
-    Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
+    QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
 
     // Save new image to use it in DoFullMenuUpdate
     pSalMenuItem->maImage = rImage;
@@ -540,47 +540,47 @@ void Qt5Menu::SetItemImage(unsigned, SalMenuItem* pItem, const Image& rImage)
     pAction->setIcon(QPixmap::fromImage(toQImage(rImage)));
 }
 
-void Qt5Menu::SetAccelerator(unsigned, SalMenuItem* pItem, const vcl::KeyCode&,
-                             const OUString& rText)
+void QtMenu::SetAccelerator(unsigned, SalMenuItem* pItem, const vcl::KeyCode&,
+                            const OUString& rText)
 {
-    Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
+    QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
     QAction* pAction = pSalMenuItem->getAction();
     if (pAction)
         pAction->setShortcut(QKeySequence(toQString(rText), QKeySequence::PortableText));
 }
 
-void Qt5Menu::GetSystemMenuData(SystemMenuData*) {}
+void QtMenu::GetSystemMenuData(SystemMenuData*) {}
 
-Qt5Menu* Qt5Menu::GetTopLevel()
+QtMenu* QtMenu::GetTopLevel()
 {
-    Qt5Menu* pMenu = this;
+    QtMenu* pMenu = this;
     while (pMenu->mpParentSalMenu)
         pMenu = pMenu->mpParentSalMenu;
     return pMenu;
 }
 
-void Qt5Menu::ShowMenuBar(bool bVisible)
+void QtMenu::ShowMenuBar(bool bVisible)
 {
     if (mpQMenuBar)
         mpQMenuBar->setVisible(bVisible);
 }
 
-const Qt5Frame* Qt5Menu::GetFrame() const
+const QtFrame* QtMenu::GetFrame() const
 {
     SolarMutexGuard aGuard;
-    const Qt5Menu* pMenu = this;
+    const QtMenu* pMenu = this;
     while (pMenu && !pMenu->mpFrame)
         pMenu = pMenu->mpParentSalMenu;
     return pMenu ? pMenu->mpFrame : nullptr;
 }
 
-void Qt5Menu::slotMenuTriggered(Qt5MenuItem* pQItem)
+void QtMenu::slotMenuTriggered(QtMenuItem* pQItem)
 {
     if (!pQItem)
         return;
 
-    Qt5Menu* pSalMenu = pQItem->mpParentMenu;
-    Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
+    QtMenu* pSalMenu = pQItem->mpParentMenu;
+    QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 
     Menu* pMenu = pSalMenu->GetMenu();
     auto mnId = pQItem->mnId;
@@ -593,12 +593,12 @@ void Qt5Menu::slotMenuTriggered(Qt5MenuItem* pQItem)
     pTopLevel->GetMenu()->HandleMenuCommandEvent(pMenu, mnId);
 }
 
-void Qt5Menu::slotMenuAboutToShow(Qt5MenuItem* pQItem)
+void QtMenu::slotMenuAboutToShow(QtMenuItem* pQItem)
 {
     if (pQItem)
     {
-        Qt5Menu* pSalMenu = pQItem->mpSubMenu;
-        Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
+        QtMenu* pSalMenu = pQItem->mpSubMenu;
+        QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 
         Menu* pMenu = pSalMenu->GetMenu();
 
@@ -607,12 +607,12 @@ void Qt5Menu::slotMenuAboutToShow(Qt5MenuItem* pQItem)
     }
 }
 
-void Qt5Menu::slotMenuAboutToHide(Qt5MenuItem* pQItem)
+void QtMenu::slotMenuAboutToHide(QtMenuItem* pQItem)
 {
     if (pQItem)
     {
-        Qt5Menu* pSalMenu = pQItem->mpSubMenu;
-        Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
+        QtMenu* pSalMenu = pQItem->mpSubMenu;
+        QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 
         Menu* pMenu = pSalMenu->GetMenu();
 
@@ -620,7 +620,7 @@ void Qt5Menu::slotMenuAboutToHide(Qt5MenuItem* pQItem)
     }
 }
 
-void Qt5Menu::NativeItemText(OUString& rItemText)
+void QtMenu::NativeItemText(OUString& rItemText)
 {
     // preserve literal '&'s in menu texts
     rItemText = rItemText.replaceAll("&", "&&");
@@ -628,14 +628,14 @@ void Qt5Menu::NativeItemText(OUString& rItemText)
     rItemText = rItemText.replace('~', '&');
 }
 
-void Qt5Menu::slotCloseDocument()
+void QtMenu::slotCloseDocument()
 {
     MenuBar* pVclMenuBar = static_cast<MenuBar*>(mpVCLMenu.get());
     if (pVclMenuBar)
         Application::PostUserEvent(pVclMenuBar->GetCloseButtonClickHdl());
 }
 
-void Qt5Menu::ShowCloseButton(bool bShow)
+void QtMenu::ShowCloseButton(bool bShow)
 {
     if (!mpQMenuBar)
         return;
@@ -656,7 +656,7 @@ void Qt5Menu::ShowCloseButton(bool bShow)
         pButton->setToolTip(toQString(VclResId(SV_HELPTEXT_CLOSEDOCUMENT)));
         mpQMenuBar->setCornerWidget(pButton, Qt::TopRightCorner);
         maCloseButtonConnection
-            = connect(pButton, &QPushButton::clicked, this, &Qt5Menu::slotCloseDocument);
+            = connect(pButton, &QPushButton::clicked, this, &QtMenu::slotCloseDocument);
         mpCloseButton = pButton;
     }
 
@@ -666,8 +666,8 @@ void Qt5Menu::ShowCloseButton(bool bShow)
         pButton->hide();
 }
 
-bool Qt5Menu::ShowNativePopupMenu(FloatingWindow*, const tools::Rectangle&,
-                                  FloatWinPopupFlags nFlags)
+bool QtMenu::ShowNativePopupMenu(FloatingWindow*, const tools::Rectangle&,
+                                 FloatWinPopupFlags nFlags)
 {
     assert(mpQMenu);
     DoFullMenuUpdate(mpVCLMenu);
@@ -679,7 +679,7 @@ bool Qt5Menu::ShowNativePopupMenu(FloatingWindow*, const tools::Rectangle&,
     return true;
 }
 
-Qt5MenuItem::Qt5MenuItem(const SalItemParams* pItemData)
+QtMenuItem::QtMenuItem(const SalItemParams* pItemData)
     : mpParentMenu(nullptr)
     , mpSubMenu(nullptr)
     , mnId(pItemData->nId)
@@ -690,7 +690,7 @@ Qt5MenuItem::Qt5MenuItem(const SalItemParams* pItemData)
 {
 }
 
-QAction* Qt5MenuItem::getAction() const
+QAction* QtMenuItem::getAction() const
 {
     if (mpMenu)
         return mpMenu->menuAction();
diff --git a/vcl/qt5/Qt5Object.cxx b/vcl/qt5/Qt5Object.cxx
index 631321681daa..b48c1a143248 100644
--- a/vcl/qt5/Qt5Object.cxx
+++ b/vcl/qt5/Qt5Object.cxx
@@ -25,7 +25,7 @@
 
 #include <QtGui/QGuiApplication>
 
-Qt5Object::Qt5Object(Qt5Frame* pParent, bool bShow)
+QtObject::QtObject(QtFrame* pParent, bool bShow)
     : m_pParent(pParent)
     , m_pQWidget(nullptr)
     , m_pQWindow(nullptr)
@@ -33,7 +33,7 @@ Qt5Object::Qt5Object(Qt5Frame* pParent, bool bShow)
     if (!m_pParent || !pParent->GetQWidget())
         return;
 
-    m_pQWindow = new Qt5ObjectWindow(*this);
+    m_pQWindow = new QtObjectWindow(*this);
     m_pQWidget = QWidget::createWindowContainer(m_pQWindow, pParent->GetQWidget());
     m_pQWidget->setAttribute(Qt::WA_NoSystemBackground);
     connect(m_pQWidget, &QObject::destroyed, this, [this]() { m_pQWidget = nullptr; });
@@ -65,7 +65,7 @@ Qt5Object::Qt5Object(Qt5Frame* pParent, bool bShow)
     }
 }
 
-Qt5Object::~Qt5Object()
+QtObject::~QtObject()
 {
     if (m_pQWidget)
     {
@@ -74,7 +74,7 @@ Qt5Object::~Qt5Object()
     }
 }
 
-void Qt5Object::ResetClipRegion()
+void QtObject::ResetClipRegion()
 {
     if (m_pQWidget)
         m_pRegion = QRegion(m_pQWidget->geometry());
@@ -82,21 +82,21 @@ void Qt5Object::ResetClipRegion()
         m_pRegion = QRegion();
 }
 
-void Qt5Object::BeginSetClipRegion(sal_uInt32) { m_pRegion = QRegion(); }
+void QtObject::BeginSetClipRegion(sal_uInt32) { m_pRegion = QRegion(); }
 
-void Qt5Object::UnionClipRegion(tools::Long nX, tools::Long nY, tools::Long nWidth,
-                                tools::Long nHeight)
+void QtObject::UnionClipRegion(tools::Long nX, tools::Long nY, tools::Long nWidth,
+                               tools::Long nHeight)
 {
     m_pRegion += QRect(nX, nY, nWidth, nHeight);
 }
 
-void Qt5Object::EndSetClipRegion()
+void QtObject::EndSetClipRegion()
 {
     if (m_pQWidget)
         m_pRegion = m_pRegion.intersected(m_pQWidget->geometry());
 }
 
-void Qt5Object::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight)
+void QtObject::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight)
 {
     if (m_pQWidget)
     {
@@ -105,52 +105,52 @@ void Qt5Object::SetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth, t
     }
 }
 
-void Qt5Object::Show(bool bVisible)
+void QtObject::Show(bool bVisible)
 {
     if (m_pQWidget)
         m_pQWidget->setVisible(bVisible);
 }
 
-void Qt5Object::SetForwardKey(bool /*bEnable*/) {}
+void QtObject::SetForwardKey(bool /*bEnable*/) {}
 
-Qt5ObjectWindow::Qt5ObjectWindow(Qt5Object& rParent)
+QtObjectWindow::QtObjectWindow(QtObject& rParent)
     : m_rParent(rParent)
 {
     assert(m_rParent.frame() && m_rParent.frame()->GetQWidget());
 }
 
-void Qt5ObjectWindow::focusInEvent(QFocusEvent* pEvent)
+void QtObjectWindow::focusInEvent(QFocusEvent* pEvent)
 {
     m_rParent.CallCallback(SalObjEvent::GetFocus);
     QWindow::focusInEvent(pEvent);
 }
 
-void Qt5ObjectWindow::focusOutEvent(QFocusEvent* pEvent)
+void QtObjectWindow::focusOutEvent(QFocusEvent* pEvent)
 {
     m_rParent.CallCallback(SalObjEvent::LoseFocus);
     QWindow::focusOutEvent(pEvent);
 }
 
-void Qt5ObjectWindow::mousePressEvent(QMouseEvent* pEvent)
+void QtObjectWindow::mousePressEvent(QMouseEvent* pEvent)
 {
     m_rParent.CallCallback(SalObjEvent::ToTop);
-    Qt5Widget::handleMousePressEvent(*m_rParent.frame(), pEvent);
+    QtWidget::handleMousePressEvent(*m_rParent.frame(), pEvent);
 }
 
-void Qt5ObjectWindow::mouseReleaseEvent(QMouseEvent* pEvent)
+void QtObjectWindow::mouseReleaseEvent(QMouseEvent* pEvent)
 {
-    Qt5Widget::handleMouseReleaseEvent(*m_rParent.frame(), pEvent);
+    QtWidget::handleMouseReleaseEvent(*m_rParent.frame(), pEvent);
 }
 
-bool Qt5ObjectWindow::event(QEvent* pEvent)
+bool QtObjectWindow::event(QEvent* pEvent)
 {
-    return Qt5Widget::handleEvent(*m_rParent.frame(), *m_rParent.widget(), pEvent)
+    return QtWidget::handleEvent(*m_rParent.frame(), *m_rParent.widget(), pEvent)
            || QWindow::event(pEvent);
 }
 
-void Qt5ObjectWindow::keyReleaseEvent(QKeyEvent* pEvent)
+void QtObjectWindow::keyReleaseEvent(QKeyEvent* pEvent)
 {
-    if (!Qt5Widget::handleKeyReleaseEvent(*m_rParent.frame(), *m_rParent.widget(), pEvent))
+    if (!QtWidget::handleKeyReleaseEvent(*m_rParent.frame(), *m_rParent.widget(), pEvent))
         QWindow::keyReleaseEvent(pEvent);
 }
 
diff --git a/vcl/qt5/Qt5OpenGLContext.cxx b/vcl/qt5/Qt5OpenGLContext.cxx
index ca2ec48d1d4c..0c8dd1729886 100644
--- a/vcl/qt5/Qt5OpenGLContext.cxx
+++ b/vcl/qt5/Qt5OpenGLContext.cxx
@@ -32,9 +32,9 @@
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QWindow>
 
-bool Qt5OpenGLContext::g_bAnyCurrent = false;
+bool QtOpenGLContext::g_bAnyCurrent = false;
 
-void Qt5OpenGLContext::swapBuffers()
+void QtOpenGLContext::swapBuffers()
 {
     OpenGLZone aZone;
 
@@ -46,7 +46,7 @@ void Qt5OpenGLContext::swapBuffers()
     BuffersSwapped();
 }
 
-void Qt5OpenGLContext::resetCurrent()
+void QtOpenGLContext::resetCurrent()
 {
     clearCurrent();
 
@@ -59,19 +59,19 @@ void Qt5OpenGLContext::resetCurrent()
     }
 }
 
-bool Qt5OpenGLContext::isCurrent()
+bool QtOpenGLContext::isCurrent()
 {
     OpenGLZone aZone;
     return g_bAnyCurrent && (QOpenGLContext::currentContext() == m_pContext);
 }
 
-bool Qt5OpenGLContext::isAnyCurrent()
+bool QtOpenGLContext::isAnyCurrent()
 {
     OpenGLZone aZone;
     return g_bAnyCurrent && (QOpenGLContext::currentContext() != nullptr);
 }
 
-bool Qt5OpenGLContext::ImplInit()
+bool QtOpenGLContext::ImplInit()
 {
     if (!m_pWindow)
     {
@@ -102,7 +102,7 @@ bool Qt5OpenGLContext::ImplInit()
     return bRet;
 }
 
-void Qt5OpenGLContext::makeCurrent()
+void QtOpenGLContext::makeCurrent()
 {
     if (isCurrent())
         return;
@@ -120,7 +120,7 @@ void Qt5OpenGLContext::makeCurrent()
     registerAsCurrent();
 }
 
-void Qt5OpenGLContext::destroyCurrentContext()
+void QtOpenGLContext::destroyCurrentContext()
 {
     OpenGLZone aZone;
 
@@ -136,7 +136,7 @@ void Qt5OpenGLContext::destroyCurrentContext()
     }
 }
 
-void Qt5OpenGLContext::initWindow()
+void QtOpenGLContext::initWindow()
 {
     if (!m_pChildWindow)
     {
@@ -150,5 +150,5 @@ void Qt5OpenGLContext::initWindow()
     }
 
     m_pWindow
-        = static_cast<Qt5Object*>(m_pChildWindow->ImplGetWindowImpl()->mpSysObj)->windowHandle();
+        = static_cast<QtObject*>(m_pChildWindow->ImplGetWindowImpl()->mpSysObj)->windowHandle();
 }
diff --git a/vcl/qt5/Qt5Painter.cxx b/vcl/qt5/Qt5Painter.cxx
index d898a6106406..5941b3dbeabb 100644
--- a/vcl/qt5/Qt5Painter.cxx
+++ b/vcl/qt5/Qt5Painter.cxx
@@ -21,7 +21,7 @@
 
 #include <QtGui/QColor>
 
-Qt5Painter::Qt5Painter(Qt5GraphicsBackend& rGraphics, bool bPrepareBrush, sal_uInt8 nTransparency)
+QtPainter::QtPainter(QtGraphicsBackend& rGraphics, bool bPrepareBrush, sal_uInt8 nTransparency)
     : m_rGraphics(rGraphics)
 {
     if (rGraphics.m_pQImage)
diff --git a/vcl/qt5/Qt5Printer.cxx b/vcl/qt5/Qt5Printer.cxx
index 16a6a1115073..3f77fce307ec 100644
--- a/vcl/qt5/Qt5Printer.cxx
+++ b/vcl/qt5/Qt5Printer.cxx
@@ -19,7 +19,7 @@
 
 #include <Qt5Printer.hxx>
 
-Qt5Printer::Qt5Printer(SalInfoPrinter* pInfoPrinter)
+QtPrinter::QtPrinter(SalInfoPrinter* pInfoPrinter)
     : PspSalPrinter(pInfoPrinter)
 {
 }
diff --git a/vcl/qt5/Qt5SvpGraphics.cxx b/vcl/qt5/Qt5SvpGraphics.cxx
index 5143114bcb74..1d2b4dc7de1a 100644
--- a/vcl/qt5/Qt5SvpGraphics.cxx
+++ b/vcl/qt5/Qt5SvpGraphics.cxx
@@ -24,18 +24,18 @@
 #include <QtGui/QWindow>
 #include <QtWidgets/QWidget>
 
-Qt5SvpGraphics::Qt5SvpGraphics(Qt5Frame* pFrame)
+QtSvpGraphics::QtSvpGraphics(QtFrame* pFrame)
     : m_pFrame(pFrame)
 {
-    if (!Qt5Data::noNativeControls())
-        m_pWidgetDraw.reset(new Qt5Graphics_Controls(*this));
+    if (!QtData::noNativeControls())
+        m_pWidgetDraw.reset(new QtGraphics_Controls(*this));
     if (m_pFrame)
         setDevicePixelRatioF(m_pFrame->devicePixelRatioF());
 }
 
-Qt5SvpGraphics::~Qt5SvpGraphics() {}
+QtSvpGraphics::~QtSvpGraphics() {}
 
-void Qt5SvpGraphics::updateQWidget() const
+void QtSvpGraphics::updateQWidget() const
 {
     if (!m_pFrame)
         return;
@@ -46,18 +46,18 @@ void Qt5SvpGraphics::updateQWidget() const
 
 #if ENABLE_CAIRO_CANVAS
 
-bool Qt5SvpGraphics::SupportsCairo() const { return true; }
+bool QtSvpGraphics::SupportsCairo() const { return true; }
 
 cairo::SurfaceSharedPtr
-Qt5SvpGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const
+QtSvpGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const
 {
-    return std::make_shared<cairo::Qt5SvpSurface>(rSurface);
+    return std::make_shared<cairo::QtSvpSurface>(rSurface);
 }
 
-cairo::SurfaceSharedPtr Qt5SvpGraphics::CreateSurface(const OutputDevice& /*rRefDevice*/, int x,
-                                                      int y, int width, int height) const
+cairo::SurfaceSharedPtr QtSvpGraphics::CreateSurface(const OutputDevice& /*rRefDevice*/, int x,
+                                                     int y, int width, int height) const
 {
-    return std::make_shared<cairo::Qt5SvpSurface>(this, x, y, width, height);
+    return std::make_shared<cairo::QtSvpSurface>(this, x, y, width, height);
 }
 
 #endif
@@ -74,13 +74,13 @@ static void QImage2BitmapBuffer(QImage& rImg, BitmapBuffer& rBuf)
     rBuf.mnScanlineSize = rImg.bytesPerLine();
 }
 
-void Qt5SvpGraphics::handleDamage(const tools::Rectangle& rDamagedRegion)
+void QtSvpGraphics::handleDamage(const tools::Rectangle& rDamagedRegion)
 {
     assert(m_pWidgetDraw);
-    assert(dynamic_cast<Qt5Graphics_Controls*>(m_pWidgetDraw.get()));
+    assert(dynamic_cast<QtGraphics_Controls*>(m_pWidgetDraw.get()));
     assert(!rDamagedRegion.IsEmpty());
 
-    QImage* pImage = static_cast<Qt5Graphics_Controls*>(m_pWidgetDraw.get())->getImage();
+    QImage* pImage = static_cast<QtGraphics_Controls*>(m_pWidgetDraw.get())->getImage();
     assert(pImage);
     if (pImage->width() == 0 || pImage->height() == 0)
         return;
@@ -92,7 +92,7 @@ void Qt5SvpGraphics::handleDamage(const tools::Rectangle& rDamagedRegion)
     drawBitmap(aTR, &aBuffer, CAIRO_OPERATOR_OVER);
 }
 
-void Qt5SvpGraphics::GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY)
+void QtSvpGraphics::GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY)
 {
     char* pForceDpi;
     if ((pForceDpi = getenv("SAL_FORCEDPI")))
diff --git a/vcl/qt5/Qt5SvpSurface.cxx b/vcl/qt5/Qt5SvpSurface.cxx
index 4bab429971ba..8b83e9f98424 100644
--- a/vcl/qt5/Qt5SvpSurface.cxx
+++ b/vcl/qt5/Qt5SvpSurface.cxx
@@ -33,14 +33,14 @@ Size get_surface_size(cairo_surface_t* surface)
 
 namespace cairo
 {
-Qt5SvpSurface::Qt5SvpSurface(const CairoSurfaceSharedPtr& pSurface)
+QtSvpSurface::QtSvpSurface(const CairoSurfaceSharedPtr& pSurface)
     : m_pGraphics(nullptr)
     , m_pCairoContext(nullptr)
     , m_pSurface(pSurface)
 {
 }
 
-Qt5SvpSurface::Qt5SvpSurface(const Qt5SvpGraphics* pGraphics, int x, int y, int width, int height)
+QtSvpSurface::QtSvpSurface(const QtSvpGraphics* pGraphics, int x, int y, int width, int height)
     : m_pGraphics(pGraphics)
     , m_pCairoContext(pGraphics->getCairoContext(false))
 {
@@ -49,33 +49,33 @@ Qt5SvpSurface::Qt5SvpSurface(const Qt5SvpGraphics* pGraphics, int x, int y, int
                      &cairo_surface_destroy);
 }
 
-Qt5SvpSurface::~Qt5SvpSurface()
+QtSvpSurface::~QtSvpSurface()
 {
     if (m_pCairoContext)
         cairo_destroy(m_pCairoContext);
 }
 
-CairoSharedPtr Qt5SvpSurface::getCairo() const
+CairoSharedPtr QtSvpSurface::getCairo() const
 {
     return CairoSharedPtr(cairo_create(m_pSurface.get()), &cairo_destroy);
 }
 
-SurfaceSharedPtr Qt5SvpSurface::getSimilar(int cairo_content_type, int width, int height) const
+SurfaceSharedPtr QtSvpSurface::getSimilar(int cairo_content_type, int width, int height) const
 {
-    return std::make_shared<Qt5SvpSurface>(CairoSurfaceSharedPtr(
+    return std::make_shared<QtSvpSurface>(CairoSurfaceSharedPtr(
         cairo_surface_create_similar(
             m_pSurface.get(), static_cast<cairo_content_t>(cairo_content_type), width, height),
         &cairo_surface_destroy));
 }
 
-void Qt5SvpSurface::flush() const
+void QtSvpSurface::flush() const
 {
     cairo_surface_flush(m_pSurface.get());
     if (m_pGraphics)
         m_pGraphics->updateQWidget();
 }
 
-VclPtr<VirtualDevice> Qt5SvpSurface::createVirtualDevice() const
+VclPtr<VirtualDevice> QtSvpSurface::createVirtualDevice() const
 {
     SystemGraphicsData aSystemGraphicsData;
 
diff --git a/vcl/qt5/Qt5SvpVirtualDevice.hxx b/vcl/qt5/Qt5SvpVirtualDevice.hxx
index 3b76a6f5200a..8d9dcdc20d72 100644
--- a/vcl/qt5/Qt5SvpVirtualDevice.hxx
+++ b/vcl/qt5/Qt5SvpVirtualDevice.hxx
@@ -22,15 +22,15 @@
 #include <headless/svpvd.hxx>
 #include <Qt5SvpGraphics.hxx>
 
-class VCL_DLLPUBLIC Qt5SvpVirtualDevice : public SvpSalVirtualDevice
+class VCL_DLLPUBLIC QtSvpVirtualDevice : public SvpSalVirtualDevice
 {
 public:
-    Qt5SvpVirtualDevice(cairo_surface_t* pRefSurface, cairo_surface_t* pPreExistingTarget)
+    QtSvpVirtualDevice(cairo_surface_t* pRefSurface, cairo_surface_t* pPreExistingTarget)
         : SvpSalVirtualDevice(pRefSurface, pPreExistingTarget)
     {
     }
 
-    SalGraphics* AcquireGraphics() override { return AddGraphics(new Qt5SvpGraphics(nullptr)); }
+    SalGraphics* AcquireGraphics() override { return AddGraphics(new QtSvpGraphics(nullptr)); }
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5System.cxx b/vcl/qt5/Qt5System.cxx
index e787ea0cab2b..7483850a28e7 100644
--- a/vcl/qt5/Qt5System.cxx
+++ b/vcl/qt5/Qt5System.cxx
@@ -14,15 +14,15 @@
 #include <Qt5System.hxx>
 #include <Qt5Tools.hxx>
 
-unsigned int Qt5System::GetDisplayScreenCount() { return QGuiApplication::screens().size(); }
+unsigned int QtSystem::GetDisplayScreenCount() { return QGuiApplication::screens().size(); }
 
-tools::Rectangle Qt5System::GetDisplayScreenPosSizePixel(unsigned int nScreen)
+tools::Rectangle QtSystem::GetDisplayScreenPosSizePixel(unsigned int nScreen)
 {
     QRect qRect = QGuiApplication::screens().at(nScreen)->geometry();
     return toRectangle(scaledQRect(qRect, qApp->devicePixelRatio()));
 }
 
-int Qt5System::ShowNativeDialog(const OUString&, const OUString&, const std::vector<OUString>&)
+int QtSystem::ShowNativeDialog(const OUString&, const OUString&, const std::vector<OUString>&)
 {
     return 0;
 }
diff --git a/vcl/qt5/Qt5Timer.cxx b/vcl/qt5/Qt5Timer.cxx
index bbc2800e868d..f52491d81cd0 100644
--- a/vcl/qt5/Qt5Timer.cxx
+++ b/vcl/qt5/Qt5Timer.cxx
@@ -26,7 +26,7 @@
 #include <vcl/svapp.hxx>
 #include <sal/log.hxx>
 
-Qt5Timer::Qt5Timer()
+QtTimer::QtTimer()
 {
     m_aTimer.setSingleShot(true);
     m_aTimer.setTimerType(Qt::PreciseTimer);
@@ -35,18 +35,18 @@ Qt5Timer::Qt5Timer()
     connect(this, SIGNAL(stopTimerSignal()), this, SLOT(stopTimer()));
 }
 
-void Qt5Timer::timeoutActivated()
+void QtTimer::timeoutActivated()
 {
     SolarMutexGuard aGuard;
     CallCallback();
 }
 
-void Qt5Timer::startTimer(int nMS) { m_aTimer.start(nMS); }
+void QtTimer::startTimer(int nMS) { m_aTimer.start(nMS); }
 
-void Qt5Timer::Start(sal_uInt64 nMS) { Q_EMIT startTimerSignal(nMS); }
+void QtTimer::Start(sal_uInt64 nMS) { Q_EMIT startTimerSignal(nMS); }
 
-void Qt5Timer::stopTimer() { m_aTimer.stop(); }
+void QtTimer::stopTimer() { m_aTimer.stop(); }
 
-void Qt5Timer::Stop() { Q_EMIT stopTimerSignal(); }
+void QtTimer::Stop() { Q_EMIT stopTimerSignal(); }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5Transferable.cxx b/vcl/qt5/Qt5Transferable.cxx
index 2e0deef9b8e8..5da55fa653c1 100644
--- a/vcl/qt5/Qt5Transferable.cxx
+++ b/vcl/qt5/Qt5Transferable.cxx
@@ -40,14 +40,14 @@ static bool lcl_textMimeInfo(const OUString& rMimeString, bool& bHaveNoCharset,
     return false;
 }
 
-Qt5Transferable::Qt5Transferable(const QMimeData* pMimeData)
+QtTransferable::QtTransferable(const QMimeData* pMimeData)
     : m_pMimeData(pMimeData)
     , m_bConvertFromLocale(false)
 {
     assert(pMimeData);
 }
 
-css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL Qt5Transferable::getTransferDataFlavors()
+css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL QtTransferable::getTransferDataFlavors()
 {
     // it's just filled once, ever, so just try to get it without locking first
     if (m_aMimeTypeSeq.hasElements())
@@ -115,7 +115,7 @@ css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL Qt5Transferable::getT
 }
 
 sal_Bool SAL_CALL
-Qt5Transferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
+QtTransferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
 {
     const auto aSeq = getTransferDataFlavors();
     return std::any_of(aSeq.begin(), aSeq.end(), [&](const css::datatransfer::DataFlavor& aFlavor) {
@@ -123,8 +123,7 @@ Qt5Transferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFla
     });
 }
 
-css::uno::Any SAL_CALL
-Qt5Transferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
+css::uno::Any SAL_CALL QtTransferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
 {
     css::uno::Any aAny;
     if (!isDataFlavorSupported(rFlavor))
@@ -158,14 +157,14 @@ Qt5Transferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
     return aAny;
 }
 
-Qt5ClipboardTransferable::Qt5ClipboardTransferable(const QClipboard::Mode aMode,
-                                                   const QMimeData* pMimeData)
-    : Qt5Transferable(pMimeData)
+QtClipboardTransferable::QtClipboardTransferable(const QClipboard::Mode aMode,
+                                                 const QMimeData* pMimeData)
+    : QtTransferable(pMimeData)
     , m_aMode(aMode)
 {
 }
 
-bool Qt5ClipboardTransferable::hasInFlightChanged() const
+bool QtClipboardTransferable::hasInFlightChanged() const
 {
     const bool bChanged(mimeData() != QApplication::clipboard()->mimeData(m_aMode));
     SAL_WARN_IF(bChanged, "vcl.qt5",
@@ -174,45 +173,45 @@ bool Qt5ClipboardTransferable::hasInFlightChanged() const
 }
 
 css::uno::Any SAL_CALL
-Qt5ClipboardTransferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
+QtClipboardTransferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
 {
     css::uno::Any aAny;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     SolarMutexGuard g;
     pSalInst->RunInMainThread([&, this]() {
         if (!hasInFlightChanged())
-            aAny = Qt5Transferable::getTransferData(rFlavor);
+            aAny = QtTransferable::getTransferData(rFlavor);
     });
     return aAny;
 }
 
 css::uno::Sequence<css::datatransfer::DataFlavor>
-    SAL_CALL Qt5ClipboardTransferable::getTransferDataFlavors()
+    SAL_CALL QtClipboardTransferable::getTransferDataFlavors()
 {
     css::uno::Sequence<css::datatransfer::DataFlavor> aSeq;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     SolarMutexGuard g;
     pSalInst->RunInMainThread([&, this]() {
         if (!hasInFlightChanged())
-            aSeq = Qt5Transferable::getTransferDataFlavors();
+            aSeq = QtTransferable::getTransferDataFlavors();
     });
     return aSeq;
 }
 
 sal_Bool SAL_CALL
-Qt5ClipboardTransferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
+QtClipboardTransferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
 {
     bool bIsSupported = false;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     SolarMutexGuard g;
     pSalInst->RunInMainThread([&, this]() {
         if (!hasInFlightChanged())
-            bIsSupported = Qt5Transferable::isDataFlavorSupported(rFlavor);
+            bIsSupported = QtTransferable::isDataFlavorSupported(rFlavor);
     });
     return bIsSupported;
 }
 
-Qt5MimeData::Qt5MimeData(const css::uno::Reference<css::datatransfer::XTransferable>& xTrans)
+QtMimeData::QtMimeData(const css::uno::Reference<css::datatransfer::XTransferable>& xTrans)
     : m_aContents(xTrans)
     , m_bHaveNoCharset(false)
     , m_bHaveUTF8(false)
@@ -220,7 +219,7 @@ Qt5MimeData::Qt5MimeData(const css::uno::Reference<css::datatransfer::XTransfera
     assert(xTrans.is());
 }
 
-bool Qt5MimeData::deepCopy(QMimeData** const pMimeCopy) const
+bool QtMimeData::deepCopy(QMimeData** const pMimeCopy) const
 {
     if (!pMimeCopy)
         return false;
@@ -244,7 +243,7 @@ bool Qt5MimeData::deepCopy(QMimeData** const pMimeCopy) const
     return true;
 }
 
-QStringList Qt5MimeData::formats() const
+QStringList QtMimeData::formats() const
 {
     if (!m_aMimeTypeList.isEmpty())
         return m_aMimeTypeList;
@@ -275,7 +274,7 @@ QStringList Qt5MimeData::formats() const
     return m_aMimeTypeList;
 }
 
-QVariant Qt5MimeData::retrieveData(const QString& mimeType, QVariant::Type) const
+QVariant QtMimeData::retrieveData(const QString& mimeType, QVariant::Type) const
 {
     if (!hasFormat(mimeType))
         return QVariant();
@@ -340,6 +339,6 @@ QVariant Qt5MimeData::retrieveData(const QString& mimeType, QVariant::Type) cons
     return QVariant::fromValue(aByteArray);
 }
 
-bool Qt5MimeData::hasFormat(const QString& mimeType) const { return formats().contains(mimeType); }
+bool QtMimeData::hasFormat(const QString& mimeType) const { return formats().contains(mimeType); }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5VirtualDevice.cxx b/vcl/qt5/Qt5VirtualDevice.cxx
index 6b2c31c6b4b7..85f56bff4c17 100644
--- a/vcl/qt5/Qt5VirtualDevice.cxx
+++ b/vcl/qt5/Qt5VirtualDevice.cxx
@@ -24,34 +24,33 @@
 
 #include <QtGui/QImage>
 
-Qt5VirtualDevice::Qt5VirtualDevice(double fScale)
+QtVirtualDevice::QtVirtualDevice(double fScale)
     : m_fScale(fScale)
 {
 }
 
-SalGraphics* Qt5VirtualDevice::AcquireGraphics()
+SalGraphics* QtVirtualDevice::AcquireGraphics()
 {
     assert(m_pImage);
-    Qt5Graphics* pGraphics = new Qt5Graphics(m_pImage.get());
+    QtGraphics* pGraphics = new QtGraphics(m_pImage.get());
     m_aGraphics.push_back(pGraphics);
     return pGraphics;
 }
 
-void Qt5VirtualDevice::ReleaseGraphics(SalGraphics* pGraphics)
+void QtVirtualDevice::ReleaseGraphics(SalGraphics* pGraphics)
 {
     m_aGraphics.erase(
-        std::remove(m_aGraphics.begin(), m_aGraphics.end(), dynamic_cast<Qt5Graphics*>(pGraphics)),
+        std::remove(m_aGraphics.begin(), m_aGraphics.end(), dynamic_cast<QtGraphics*>(pGraphics)),
         m_aGraphics.end());
     delete pGraphics;
 }
 
-bool Qt5VirtualDevice::SetSize(tools::Long nNewDX, tools::Long nNewDY)
+bool QtVirtualDevice::SetSize(tools::Long nNewDX, tools::Long nNewDY)
 {
     return SetSizeUsingBuffer(nNewDX, nNewDY, nullptr);
 }
 
-bool Qt5VirtualDevice::SetSizeUsingBuffer(tools::Long nNewDX, tools::Long nNewDY,
-                                          sal_uInt8* pBuffer)
+bool QtVirtualDevice::SetSizeUsingBuffer(tools::Long nNewDX, tools::Long nNewDY, sal_uInt8* pBuffer)
 {
     if (nNewDX == 0)
         nNewDX = 1;
@@ -67,22 +66,22 @@ bool Qt5VirtualDevice::SetSizeUsingBuffer(tools::Long nNewDX, tools::Long nNewDY
     nNewDY *= m_fScale;
 
     if (pBuffer)
-        m_pImage.reset(new QImage(pBuffer, nNewDX, nNewDY, Qt5_DefaultFormat32));
+        m_pImage.reset(new QImage(pBuffer, nNewDX, nNewDY, Qt_DefaultFormat32));
     else
-        m_pImage.reset(new QImage(nNewDX, nNewDY, Qt5_DefaultFormat32));
+        m_pImage.reset(new QImage(nNewDX, nNewDY, Qt_DefaultFormat32));
 
     m_pImage->fill(Qt::transparent);
     m_pImage->setDevicePixelRatio(m_fScale);
 
     // update device in existing graphics
-    for (auto pQt5Graph : m_aGraphics)
-        pQt5Graph->ChangeQImage(m_pImage.get());
+    for (auto pQtGraph : m_aGraphics)
+        pQtGraph->ChangeQImage(m_pImage.get());
 
     return true;
 }
 
-tools::Long Qt5VirtualDevice::GetWidth() const { return m_pImage ? m_aFrameSize.width() : 0; }
+tools::Long QtVirtualDevice::GetWidth() const { return m_pImage ? m_aFrameSize.width() : 0; }
 
-tools::Long Qt5VirtualDevice::GetHeight() const { return m_pImage ? m_aFrameSize.height() : 0; }
+tools::Long QtVirtualDevice::GetHeight() const { return m_pImage ? m_aFrameSize.height() : 0; }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qt5/Qt5Widget.cxx b/vcl/qt5/Qt5Widget.cxx
index ca23138b5739..9eb9ac7d3ee9 100644
--- a/vcl/qt5/Qt5Widget.cxx
+++ b/vcl/qt5/Qt5Widget.cxx
@@ -60,7 +60,7 @@
 
 using namespace com::sun::star;
 
-void Qt5Widget::paintEvent(QPaintEvent* pEvent)
+void QtWidget::paintEvent(QPaintEvent* pEvent)
 {
     QPainter p(this);
     if (!m_rFrame.m_bNullRegion)
@@ -74,7 +74,7 @@ void Qt5Widget::paintEvent(QPaintEvent* pEvent)
 
         aImage = QImage(cairo_image_surface_get_data(pSurface),
                         cairo_image_surface_get_width(pSurface),
-                        cairo_image_surface_get_height(pSurface), Qt5_DefaultFormat32);
+                        cairo_image_surface_get_height(pSurface), Qt_DefaultFormat32);
     }
     else
         aImage = *m_rFrame.m_pQImage;
@@ -85,7 +85,7 @@ void Qt5Widget::paintEvent(QPaintEvent* pEvent)
     p.drawImage(pEvent->rect(), aImage, source);
 }
 
-void Qt5Widget::resizeEvent(QResizeEvent* pEvent)
+void QtWidget::resizeEvent(QResizeEvent* pEvent)
 {
     const qreal fRatio = m_rFrame.devicePixelRatioF();
     const int nWidth = ceil(pEvent->size().width() * fRatio);
@@ -122,20 +122,20 @@ void Qt5Widget::resizeEvent(QResizeEvent* pEvent)
             pImage = new QImage(m_rFrame.m_pQImage->copy(0, 0, nWidth, nHeight));
         else
         {
-            pImage = new QImage(nWidth, nHeight, Qt5_DefaultFormat32);
+            pImage = new QImage(nWidth, nHeight, Qt_DefaultFormat32);
             pImage->fill(Qt::transparent);
         }
 
-        m_rFrame.m_pQt5Graphics->ChangeQImage(pImage);
+        m_rFrame.m_pQtGraphics->ChangeQImage(pImage);
         m_rFrame.m_pQImage.reset(pImage);
     }
 
     m_rFrame.CallCallback(SalEvent::Resize, nullptr);
 }
 
-void Qt5Widget::fillSalAbstractMouseEvent(const Qt5Frame& rFrame, const QInputEvent* pQEvent,
-                                          const QPoint& rPos, Qt::MouseButtons eButtons, int nWidth,
-                                          SalAbstractMouseEvent& aSalEvent)
+void QtWidget::fillSalAbstractMouseEvent(const QtFrame& rFrame, const QInputEvent* pQEvent,
+                                         const QPoint& rPos, Qt::MouseButtons eButtons, int nWidth,
+                                         SalAbstractMouseEvent& aSalEvent)
 {
     const qreal fRatio = rFrame.devicePixelRatioF();
     const Point aPos = toPoint(rPos * fRatio);
@@ -149,8 +149,8 @@ void Qt5Widget::fillSalAbstractMouseEvent(const Qt5Frame& rFrame, const QInputEv
 #define FILL_SAME(rFrame, nWidth)                                                                  \
     fillSalAbstractMouseEvent(rFrame, pEvent, pEvent->pos(), pEvent->buttons(), nWidth, aEvent)
 
-void Qt5Widget::handleMouseButtonEvent(const Qt5Frame& rFrame, const QMouseEvent* pEvent,
-                                       const ButtonKeyState eState)
+void QtWidget::handleMouseButtonEvent(const QtFrame& rFrame, const QMouseEvent* pEvent,
+                                      const ButtonKeyState eState)
 {
     SalMouseEvent aEvent;
     FILL_SAME(rFrame, rFrame.GetQWidget()->width());
@@ -178,7 +178,7 @@ void Qt5Widget::handleMouseButtonEvent(const Qt5Frame& rFrame, const QMouseEvent
     rFrame.CallCallback(nEventType, &aEvent);
 }
 
-void Qt5Widget::mousePressEvent(QMouseEvent* pEvent)
+void QtWidget::mousePressEvent(QMouseEvent* pEvent)
 {
     handleMousePressEvent(m_rFrame, pEvent);
     if (m_rFrame.isPopup()
@@ -186,12 +186,9 @@ void Qt5Widget::mousePressEvent(QMouseEvent* pEvent)
         closePopup();
 }
 
-void Qt5Widget::mouseReleaseEvent(QMouseEvent* pEvent)
-{
-    handleMouseReleaseEvent(m_rFrame, pEvent);
-}
+void QtWidget::mouseReleaseEvent(QMouseEvent* pEvent) { handleMouseReleaseEvent(m_rFrame, pEvent); }
 
-void Qt5Widget::mouseMoveEvent(QMouseEvent* pEvent)
+void QtWidget::mouseMoveEvent(QMouseEvent* pEvent)
 {
     SalMouseEvent aEvent;
     FILL_SAME(m_rFrame, width());
@@ -202,7 +199,7 @@ void Qt5Widget::mouseMoveEvent(QMouseEvent* pEvent)
     pEvent->accept();
 }
 
-void Qt5Widget::wheelEvent(QWheelEvent* pEvent)
+void QtWidget::wheelEvent(QWheelEvent* pEvent)
 {
     SalWheelMouseEvent aEvent;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
@@ -242,22 +239,22 @@ void Qt5Widget::wheelEvent(QWheelEvent* pEvent)
     pEvent->accept();
 }
 
-void Qt5Widget::dragEnterEvent(QDragEnterEvent* event)
+void QtWidget::dragEnterEvent(QDragEnterEvent* event)
 {
-    if (dynamic_cast<const Qt5MimeData*>(event->mimeData()))
+    if (dynamic_cast<const QtMimeData*>(event->mimeData()))
         event->accept();
     else
         event->acceptProposedAction();
 }
 
 // also called when a drop is rejected
-void Qt5Widget::dragLeaveEvent(QDragLeaveEvent*) { m_rFrame.handleDragLeave(); }
+void QtWidget::dragLeaveEvent(QDragLeaveEvent*) { m_rFrame.handleDragLeave(); }
 
-void Qt5Widget::dragMoveEvent(QDragMoveEvent* pEvent) { m_rFrame.handleDragMove(pEvent); }
+void QtWidget::dragMoveEvent(QDragMoveEvent* pEvent) { m_rFrame.handleDragMove(pEvent); }
 
-void Qt5Widget::dropEvent(QDropEvent* pEvent) { m_rFrame.handleDrop(pEvent); }
+void QtWidget::dropEvent(QDropEvent* pEvent) { m_rFrame.handleDrop(pEvent); }
 
-void Qt5Widget::moveEvent(QMoveEvent* pEvent)
+void QtWidget::moveEvent(QMoveEvent* pEvent)
 {
     if (m_rFrame.m_pTopLevel)
         return;
@@ -268,17 +265,17 @@ void Qt5Widget::moveEvent(QMoveEvent* pEvent)
     m_rFrame.CallCallback(SalEvent::Move, nullptr);
 }
 
-void Qt5Widget::showEvent(QShowEvent*)
+void QtWidget::showEvent(QShowEvent*)
 {
     QSize aSize(m_rFrame.GetQWidget()->size() * m_rFrame.devicePixelRatioF());
     // forcing an immediate update somehow interferes with the hide + show
-    // sequence from Qt5Frame::SetModal, if the frame was already set visible,
+    // sequence from QtFrame::SetModal, if the frame was already set visible,
     // resulting in a hidden / unmapped window
     SalPaintEvent aPaintEvt(0, 0, aSize.width(), aSize.height());
     m_rFrame.CallCallback(SalEvent::Paint, &aPaintEvt);
 }
 
-void Qt5Widget::closeEvent(QCloseEvent* /*pEvent*/)
+void QtWidget::closeEvent(QCloseEvent* /*pEvent*/)
 {
     m_rFrame.CallCallback(SalEvent::Close, nullptr);
 }
@@ -429,7 +426,7 @@ static sal_uInt16 GetKeyCode(int keyval, Qt::KeyboardModifiers modifiers)
     return nCode;
 }
 
-void Qt5Widget::commitText(Qt5Frame& rFrame, const QString& aText)
+void QtWidget::commitText(QtFrame& rFrame, const QString& aText)
 {
     SalExtTextInputEvent aInputEvent;
     aInputEvent.mpTextAttr = nullptr;
@@ -444,8 +441,8 @@ void Qt5Widget::commitText(Qt5Frame& rFrame, const QString& aText)
         rFrame.CallCallback(SalEvent::EndExtTextInput, nullptr);
 }
 
-bool Qt5Widget::handleKeyEvent(Qt5Frame& rFrame, const QWidget& rWidget, QKeyEvent* pEvent,
-                               const ButtonKeyState eState)
+bool QtWidget::handleKeyEvent(QtFrame& rFrame, const QWidget& rWidget, QKeyEvent* pEvent,
+                              const ButtonKeyState eState)
 {
     sal_uInt16 nCode = GetKeyCode(pEvent->key(), pEvent->modifiers());
     if (eState == ButtonKeyState::Pressed && nCode == 0 && pEvent->text().length() > 1
@@ -555,7 +552,7 @@ bool Qt5Widget::handleKeyEvent(Qt5Frame& rFrame, const QWidget& rWidget, QKeyEve
     return bStopProcessingKey;
 }
 
-bool Qt5Widget::handleEvent(Qt5Frame& rFrame, const QWidget& rWidget, QEvent* pEvent)
+bool QtWidget::handleEvent(QtFrame& rFrame, const QWidget& rWidget, QEvent* pEvent)
 {
     if (pEvent->type() == QEvent::ShortcutOverride)
     {
@@ -585,20 +582,20 @@ bool Qt5Widget::handleEvent(Qt5Frame& rFrame, const QWidget& rWidget, QEvent* pE
     return false;
 }
 
-bool Qt5Widget::event(QEvent* pEvent)
+bool QtWidget::event(QEvent* pEvent)
 {
     return handleEvent(m_rFrame, *this, pEvent) || QWidget::event(pEvent);
 }
 
-void Qt5Widget::keyReleaseEvent(QKeyEvent* pEvent)
+void QtWidget::keyReleaseEvent(QKeyEvent* pEvent)
 {
     if (!handleKeyReleaseEvent(m_rFrame, *this, pEvent))
         QWidget::keyReleaseEvent(pEvent);
 }
 
-void Qt5Widget::focusInEvent(QFocusEvent*) { m_rFrame.CallCallback(SalEvent::GetFocus, nullptr); }
+void QtWidget::focusInEvent(QFocusEvent*) { m_rFrame.CallCallback(SalEvent::GetFocus, nullptr); }
 
-void Qt5Widget::closePopup()
+void QtWidget::closePopup()
 {
     VclPtr<FloatingWindow> pFirstFloat = ImplGetSVData()->mpWinData->mpFirstFloat;
     if (pFirstFloat && !(pFirstFloat->GetPopupModeFlags() & FloatWinPopupFlags::NoAppFocusClose))
@@ -608,7 +605,7 @@ void Qt5Widget::closePopup()
     }
 }
 
-void Qt5Widget::focusOutEvent(QFocusEvent*)
+void QtWidget::focusOutEvent(QFocusEvent*)
 {
     m_rFrame.m_nKeyModifiers = ModKeyFlags::NONE;
     endExtTextInput();
@@ -616,7 +613,7 @@ void Qt5Widget::focusOutEvent(QFocusEvent*)
     closePopup();
 }
 
-Qt5Widget::Qt5Widget(Qt5Frame& rFrame, Qt::WindowFlags f)
+QtWidget::QtWidget(QtFrame& rFrame, Qt::WindowFlags f)
     : QWidget(Q_NULLPTR, f)
     , m_rFrame(rFrame)
     , m_bNonEmptyIMPreeditSeen(false)
@@ -646,7 +643,7 @@ static ExtTextInputAttr lcl_MapUndrelineStyle(QTextCharFormat::UnderlineStyle us
     }
 }
 
-void Qt5Widget::inputMethodEvent(QInputMethodEvent* pEvent)
+void QtWidget::inputMethodEvent(QInputMethodEvent* pEvent)
 {
     if (!pEvent->commitString().isEmpty())
         commitText(m_rFrame, pEvent->commitString());
@@ -765,7 +762,7 @@ static bool lcl_retrieveSurrounding(sal_Int32& rPosition, sal_Int32& rAnchor, QS
     return false;
 }
 
-QVariant Qt5Widget::inputMethodQuery(Qt::InputMethodQuery property) const
+QVariant QtWidget::inputMethodQuery(Qt::InputMethodQuery property) const
 {
     switch (property)
     {
@@ -812,7 +809,7 @@ QVariant Qt5Widget::inputMethodQuery(Qt::InputMethodQuery property) const
     }
 }
 
-void Qt5Widget::endExtTextInput()
+void QtWidget::endExtTextInput()
 {
     if (m_bNonEmptyIMPreeditSeen)
     {
@@ -821,7 +818,7 @@ void Qt5Widget::endExtTextInput()
     }
 }
 
-void Qt5Widget::changeEvent(QEvent* pEvent)
+void QtWidget::changeEvent(QEvent* pEvent)
 {
     switch (pEvent->type())
     {
@@ -831,7 +828,7 @@ void Qt5Widget::changeEvent(QEvent* pEvent)
             [[fallthrough]];
         case QEvent::StyleChange:
         {
-            auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+            auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
             assert(pSalInst);
             pSalInst->UpdateStyle(QEvent::FontChange == pEvent->type());
             break;
diff --git a/vcl/qt5/Qt5XAccessible.cxx b/vcl/qt5/Qt5XAccessible.cxx
index e9f0804d5061..8bb4f837d6d9 100644
--- a/vcl/qt5/Qt5XAccessible.cxx
+++ b/vcl/qt5/Qt5XAccessible.cxx
@@ -21,7 +21,7 @@
 using namespace css::accessibility;
 using namespace css::uno;
 
-Qt5XAccessible::Qt5XAccessible(Reference<XAccessible> xAccessible)
+QtXAccessible::QtXAccessible(Reference<XAccessible> xAccessible)
     : m_xAccessible(xAccessible)
 {
 }
diff --git a/vcl/unx/kf5/KF5FilePicker.cxx b/vcl/unx/kf5/KF5FilePicker.cxx
index c02ac7bc516b..b9f665925e47 100644
--- a/vcl/unx/kf5/KF5FilePicker.cxx
+++ b/vcl/unx/kf5/KF5FilePicker.cxx
@@ -48,10 +48,10 @@ uno::Sequence<OUString> FilePicker_getSupportedServiceNames()
 KF5FilePicker::KF5FilePicker(css::uno::Reference<css::uno::XComponentContext> const& context,
                              QFileDialog::FileMode eMode)
     // Native kf5 filepicker does not add file extension automatically
-    : Qt5FilePicker(context, eMode, true)
+    : QtFilePicker(context, eMode, true)
     , _layout(new QGridLayout(m_pExtraControls))
 {
-    // only columns 0 and 1 are used by controls (s. Qt5FilePicker::addCustomControl);
+    // only columns 0 and 1 are used by controls (s. QtFilePicker::addCustomControl);
     // set stretch for (unused) column 2 in order for the controls to only take the space
     // they actually need and avoid empty space in between
     _layout->setColumnStretch(2, 1);
@@ -78,13 +78,13 @@ void SAL_CALL KF5FilePicker::setValue(sal_Int16 controlId, sal_Int16 nControlAct
         // We ignore this one and rely on QFileDialog to provide the functionality
         return;
 
-    Qt5FilePicker::setValue(controlId, nControlAction, value);
+    QtFilePicker::setValue(controlId, nControlAction, value);
 }
 
 uno::Any SAL_CALL KF5FilePicker::getValue(sal_Int16 controlId, sal_Int16 nControlAction)
 {
     SolarMutexGuard g;
-    auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
+    auto* pSalInst(static_cast<QtInstance*>(GetSalData()->m_pInstance));
     assert(pSalInst);
     if (!pSalInst->IsMainThread())
     {
@@ -103,7 +103,7 @@ uno::Any SAL_CALL KF5FilePicker::getValue(sal_Int16 controlId, sal_Int16 nContro
         // saves the value of the setting, so LO core is not needed for that either.
         return uno::Any(false);
 
-    return Qt5FilePicker::getValue(controlId, nControlAction);
+    return QtFilePicker::getValue(controlId, nControlAction);
 }
 
 void SAL_CALL KF5FilePicker::enableControl(sal_Int16 controlId, sal_Bool enable)
@@ -112,7 +112,7 @@ void SAL_CALL KF5FilePicker::enableControl(sal_Int16 controlId, sal_Bool enable)
         // We ignore this one and rely on QFileDialog to provide the functionality
         return;
 
-    Qt5FilePicker::enableControl(controlId, enable);
+    QtFilePicker::enableControl(controlId, enable);
 }
 
 void SAL_CALL KF5FilePicker::setLabel(sal_Int16 controlId, const OUString& label)
@@ -121,7 +121,7 @@ void SAL_CALL KF5FilePicker::setLabel(sal_Int16 controlId, const OUString& label
         // We ignore this one and rely on QFileDialog to provide the functionality
         return;
 
-    Qt5FilePicker::setLabel(controlId, label);
+    QtFilePicker::setLabel(controlId, label);
 }
 
 OUString SAL_CALL KF5FilePicker::getLabel(sal_Int16 controlId)
@@ -130,7 +130,7 @@ OUString SAL_CALL KF5FilePicker::getLabel(sal_Int16 controlId)
     if (CHECKBOX_AUTOEXTENSION == controlId)
         return "";
 
-    return Qt5FilePicker::getLabel(controlId);
+    return QtFilePicker::getLabel(controlId);
 }
 
 void KF5FilePicker::addCustomControl(sal_Int16 controlId)
@@ -140,7 +140,7 @@ void KF5FilePicker::addCustomControl(sal_Int16 controlId)
     if (controlId == CHECKBOX_AUTOEXTENSION)
         return;
 
-    Qt5FilePicker::addCustomControl(controlId);
+    QtFilePicker::addCustomControl(controlId);
 }
 
 // XServiceInfo
diff --git a/vcl/unx/kf5/KF5FilePicker.hxx b/vcl/unx/kf5/KF5FilePicker.hxx
index 4cf84c7fecbd..81a0ca2a1e4b 100644
--- a/vcl/unx/kf5/KF5FilePicker.hxx
+++ b/vcl/unx/kf5/KF5FilePicker.hxx
@@ -24,7 +24,7 @@
 
 class QGridLayout;
 
-class KF5FilePicker final : public Qt5FilePicker
+class KF5FilePicker final : public QtFilePicker
 {
     Q_OBJECT
 
diff --git a/vcl/unx/kf5/KF5SalFrame.cxx b/vcl/unx/kf5/KF5SalFrame.cxx
index 8f14594586d2..198f8ccf28f8 100644
--- a/vcl/unx/kf5/KF5SalFrame.cxx
+++ b/vcl/unx/kf5/KF5SalFrame.cxx
@@ -44,7 +44,7 @@
 #include <optional>
 
 KF5SalFrame::KF5SalFrame(KF5SalFrame* pParent, SalFrameStyleFlags nState, bool bUseCairo)
-    : Qt5Frame(pParent, nState, bUseCairo)
+    : QtFrame(pParent, nState, bUseCairo)
 {
 }
 
@@ -62,9 +62,9 @@ static vcl::Font toFont(const QFont& rQFont, const css::lang::Locale& rLocale)
                                    strlen(static_cast<const char*>(rQFont.family().toUtf8())),
                                    RTL_TEXTENCODING_UTF8);
 
-    aInfo.m_eItalic = Qt5FontFace::toFontItalic(qFontInfo.style());
-    aInfo.m_eWeight = Qt5FontFace::toFontWeight(qFontInfo.weight());
-    aInfo.m_eWidth = Qt5FontFace::toFontWidth(rQFont.stretch());
+    aInfo.m_eItalic = QtFontFace::toFontItalic(qFontInfo.style());
+    aInfo.m_eWeight = QtFontFace::toFontWeight(qFontInfo.weight());
+    aInfo.m_eWidth = QtFontFace::toFontWidth(rQFont.stretch());
 
     SAL_INFO("vcl.kf5", "font name BEFORE system match: \"" << aInfo.m_aFamilyName << "\"");
 
@@ -97,7 +97,7 @@ static vcl::Font toFont(const QFont& rQFont, const css::lang::Locale& rLocale)
 */
 void KF5SalFrame::UpdateSettings(AllSettings& rSettings)
 {
-    Qt5Frame::UpdateSettings(rSettings);
+    QtFrame::UpdateSettings(rSettings);
 
     StyleSettings style(rSettings.GetStyleSettings());
     bool bSetTitleFont = false;
diff --git a/vcl/unx/kf5/KF5SalFrame.hxx b/vcl/unx/kf5/KF5SalFrame.hxx
index 613630b6c9d2..8633f5d37141 100644
--- a/vcl/unx/kf5/KF5SalFrame.hxx
+++ b/vcl/unx/kf5/KF5SalFrame.hxx
@@ -26,7 +26,7 @@
 
 class QWidget;
 
-class KF5SalFrame : public Qt5Frame
+class KF5SalFrame : public QtFrame
 {
 public:
     KF5SalFrame(KF5SalFrame* pParent, SalFrameStyleFlags nStyle, bool bUseCairo);
diff --git a/vcl/unx/kf5/KF5SalInstance.cxx b/vcl/unx/kf5/KF5SalInstance.cxx
index 9279ec50b98b..6cd974d59908 100644
--- a/vcl/unx/kf5/KF5SalInstance.cxx
+++ b/vcl/unx/kf5/KF5SalInstance.cxx
@@ -34,7 +34,7 @@
 using namespace com::sun::star;
 
 KF5SalInstance::KF5SalInstance(std::unique_ptr<QApplication>& pQApp, bool bUseCairo)
-    : Qt5Instance(pQApp, bUseCairo)
+    : QtInstance(pQApp, bUseCairo)
 {
     ImplSVData* pSVData = ImplGetSVData();
     pSVData->maAppData.mxToolkitName = constructToolkitID(u"kf5");
@@ -64,17 +64,17 @@ bool KF5SalInstance::hasNativeFileSelection() const
 {
     if (Application::GetDesktopEnvironment() == "PLASMA5")
         return true;
-    return Qt5Instance::hasNativeFileSelection();
+    return QtInstance::hasNativeFileSelection();
 }
 
-rtl::Reference<Qt5FilePicker>
+rtl::Reference<QtFilePicker>
 KF5SalInstance::createPicker(css::uno::Reference<css::uno::XComponentContext> const& context,
                              QFileDialog::FileMode eMode)
 {
     if (!IsMainThread())
     {
         SolarMutexGuard g;
-        rtl::Reference<Qt5FilePicker> pPicker;
+        rtl::Reference<QtFilePicker> pPicker;
         RunInMainThread([&, this]() { pPicker = createPicker(context, eMode); });
         assert(pPicker);
         return pPicker;
@@ -85,7 +85,7 @@ KF5SalInstance::createPicker(css::uno::Reference<css::uno::XComponentContext> co
     // Therefore, return the plain qt5 one in order to not lose custom controls.
     if (Application::GetDesktopEnvironment() == "PLASMA5")
         return new KF5FilePicker(context, eMode);
-    return Qt5Instance::createPicker(context, eMode);
+    return QtInstance::createPicker(context, eMode);
 }
 
 extern "C" {
@@ -96,15 +96,15 @@ VCLPLUG_KF5_PUBLIC SalInstance* create_SalInstance()
     std::unique_ptr<char* []> pFakeArgv;
     std::unique_ptr<int> pFakeArgc;
     std::vector<FreeableCStr> aFakeArgvFreeable;
-    Qt5Instance::AllocFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
+    QtInstance::AllocFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
 
     std::unique_ptr<QApplication> pQApp
-        = Qt5Instance::CreateQApplication(*pFakeArgc, pFakeArgv.get());
+        = QtInstance::CreateQApplication(*pFakeArgc, pFakeArgv.get());
 
     KF5SalInstance* pInstance = new KF5SalInstance(pQApp, bUseCairo);
     pInstance->MoveFakeCmdlineArgs(pFakeArgv, pFakeArgc, aFakeArgvFreeable);
 
-    new Qt5Data(pInstance);
+    new QtData(pInstance);
 
     return pInstance;
 }
diff --git a/vcl/unx/kf5/KF5SalInstance.hxx b/vcl/unx/kf5/KF5SalInstance.hxx
index 3009baecd3b0..a50efb75b9c5 100644
--- a/vcl/unx/kf5/KF5SalInstance.hxx
+++ b/vcl/unx/kf5/KF5SalInstance.hxx
@@ -21,10 +21,10 @@
 
 #include <Qt5Instance.hxx>
 
-class KF5SalInstance final : public Qt5Instance
+class KF5SalInstance final : public QtInstance
 {
     bool hasNativeFileSelection() const override;
-    rtl::Reference<Qt5FilePicker>
+    rtl::Reference<QtFilePicker>
     createPicker(css::uno::Reference<css::uno::XComponentContext> const& context,
                  QFileDialog::FileMode) override;