vcl/Executable_lo_kde5filepicker.mk | 5 vcl/Library_vclplug_gtk3_kde5.mk | 3 vcl/Library_vclplug_kf5.mk | 7 vcl/Library_vclplug_qt5.mk | 7 vcl/inc/qt5/Qt5AccessibleEventListener.hxx | 8 - vcl/inc/qt5/Qt5AccessibleWidget.hxx | 26 +-- vcl/inc/qt5/Qt5Bitmap.hxx | 6 vcl/inc/qt5/Qt5Clipboard.hxx | 8 - vcl/inc/qt5/Qt5Data.hxx | 6 vcl/inc/qt5/Qt5DragAndDrop.hxx | 18 +- vcl/inc/qt5/Qt5FilePicker.hxx | 14 - vcl/inc/qt5/Qt5Font.hxx | 6 vcl/inc/qt5/Qt5FontFace.hxx | 10 - vcl/inc/qt5/Qt5Frame.hxx | 48 +++--- vcl/inc/qt5/Qt5Graphics.hxx | 40 ++--- vcl/inc/qt5/Qt5GraphicsBase.hxx | 4 vcl/inc/qt5/Qt5Graphics_Controls.hxx | 8 - vcl/inc/qt5/Qt5Instance.hxx | 16 +- vcl/inc/qt5/Qt5MainWindow.hxx | 6 vcl/inc/qt5/Qt5Menu.hxx | 48 +++--- vcl/inc/qt5/Qt5Object.hxx | 20 +- vcl/inc/qt5/Qt5OpenGLContext.hxx | 2 vcl/inc/qt5/Qt5Painter.hxx | 10 - vcl/inc/qt5/Qt5Printer.hxx | 4 vcl/inc/qt5/Qt5SvpGraphics.hxx | 10 - vcl/inc/qt5/Qt5SvpSurface.hxx | 12 - vcl/inc/qt5/Qt5System.hxx | 2 vcl/inc/qt5/Qt5Timer.hxx | 4 vcl/inc/qt5/Qt5Tools.hxx | 6 vcl/inc/qt5/Qt5Transferable.hxx | 28 +-- vcl/inc/qt5/Qt5VirtualDevice.hxx | 8 - vcl/inc/qt5/Qt5Widget.hxx | 34 ++-- vcl/inc/qt5/Qt5XAccessible.hxx | 8 - vcl/qt5/Qt5AccessibleEventListener.cxx | 9 - vcl/qt5/Qt5AccessibleWidget.cxx | 197 +++++++++++++-------------- vcl/qt5/Qt5Bitmap.cxx | 46 +++--- vcl/qt5/Qt5Clipboard.cxx | 60 ++++---- vcl/qt5/Qt5Data.cxx | 12 - vcl/qt5/Qt5DragAndDrop.cxx | 78 +++++----- vcl/qt5/Qt5FilePicker.cxx | 132 +++++++++--------- vcl/qt5/Qt5Font.cxx | 16 +- vcl/qt5/Qt5FontFace.cxx | 44 +++--- vcl/qt5/Qt5Frame.cxx | 206 ++++++++++++++--------------- vcl/qt5/Qt5Graphics.cxx | 42 ++--- vcl/qt5/Qt5Graphics_Controls.cxx | 93 ++++++------- vcl/qt5/Qt5Graphics_GDI.cxx | 200 +++++++++++++--------------- vcl/qt5/Qt5Graphics_Text.cxx | 82 +++++------ vcl/qt5/Qt5Instance.cxx | 179 ++++++++++++------------- vcl/qt5/Qt5Instance_Print.cxx | 20 +- vcl/qt5/Qt5MainWindow.cxx | 8 - vcl/qt5/Qt5Menu.cxx | 128 +++++++++--------- vcl/qt5/Qt5Object.cxx | 44 +++--- vcl/qt5/Qt5OpenGLContext.cxx | 20 +- vcl/qt5/Qt5Painter.cxx | 2 vcl/qt5/Qt5Printer.cxx | 2 vcl/qt5/Qt5SvpGraphics.cxx | 30 ++-- vcl/qt5/Qt5SvpSurface.cxx | 16 +- vcl/qt5/Qt5SvpVirtualDevice.hxx | 6 vcl/qt5/Qt5System.cxx | 6 vcl/qt5/Qt5Timer.cxx | 12 - vcl/qt5/Qt5Transferable.cxx | 45 +++--- vcl/qt5/Qt5VirtualDevice.cxx | 27 +-- vcl/qt5/Qt5Widget.cxx | 79 +++++------ vcl/qt5/Qt5XAccessible.cxx | 2 vcl/unx/kf5/KF5FilePicker.cxx | 18 +- vcl/unx/kf5/KF5FilePicker.hxx | 2 vcl/unx/kf5/KF5SalFrame.cxx | 10 - vcl/unx/kf5/KF5SalFrame.hxx | 2 vcl/unx/kf5/KF5SalInstance.cxx | 16 +- vcl/unx/kf5/KF5SalInstance.hxx | 4 70 files changed, 1153 insertions(+), 1184 deletions(-)
New commits: commit dfd3fdfe664e214ca1bba72b96d19b89ff25e7bc Author: Michael Weghorn <m.wegh...@posteo.de> AuthorDate: Tue Sep 28 15:02:47 2021 +0200 Commit: Michael Weghorn <m.wegh...@posteo.de> CommitDate: Wed Sep 29 13:50:16 2021 +0200 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.wegh...@posteo.de> 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, ... etc. - the rest is truncated