summaryrefslogtreecommitdiffstats
path: root/include/vcl/layout.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'include/vcl/layout.hxx')
-rw-r--r--include/vcl/layout.hxx865
1 files changed, 865 insertions, 0 deletions
diff --git a/include/vcl/layout.hxx b/include/vcl/layout.hxx
new file mode 100644
index 000000000..179a03421
--- /dev/null
+++ b/include/vcl/layout.hxx
@@ -0,0 +1,865 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDED_VCL_LAYOUT_HXX
+#define INCLUDED_VCL_LAYOUT_HXX
+
+#include <config_options.h>
+#include <vcl/dllapi.h>
+#include <vcl/ctrl.hxx>
+#include <vcl/help.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/window.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/event.hxx>
+#include <vcl/transfer.hxx>
+#include <vcl/vclptr.hxx>
+#include <vcl/IContext.hxx>
+#include <vcl/commandevent.hxx>
+#include <set>
+
+class ScrollBar;
+class ScrollBar;
+class ScrollBarBox;
+class Splitter;
+
+class VCL_DLLPUBLIC VclContainer : public vcl::Window,
+ public vcl::IContext
+{
+public:
+ VclContainer(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN);
+
+ //These take into account the external margins of the rWindow widget
+ //while GetOptimalSize/get_preferred_size and SetPosSizePixel are
+ //oblivious to them
+ static Size getLayoutRequisition(const vcl::Window &rWindow);
+ static void setLayoutPosSize(vcl::Window &rWindow, const Point &rPos, const Size &rSize);
+
+ //applies the allocation pos and size onto rWindow via setLayoutPosSize taking into account
+ //the rWindows alignment desires within that allocation
+ static void setLayoutAllocation(vcl::Window &rWindow, const Point &rPos, const Size &rSize);
+
+ virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override;
+protected:
+ //these are the two that need to be implemented by
+ //containers, figure out how much space you want...
+ virtual Size calculateRequisition() const = 0;
+ //..and decide what to do when set to this size
+ virtual void setAllocation(const Size &rAllocation) = 0;
+
+ virtual sal_uInt16 getDefaultAccessibleRole() const override;
+
+ // support for screenshot context menu
+ virtual void Command(const CommandEvent& rCEvt) override;
+
+public:
+ //you don't want to override these
+ virtual Size GetOptimalSize() const override;
+ virtual void SetPosSizePixel(const Point& rNewPos, const Size& rNewSize) override;
+ virtual void SetPosPixel(const Point& rAllocPos) override;
+ virtual void SetSizePixel(const Size& rAllocation) override;
+private:
+ bool m_bLayoutDirty;
+};
+
+class VCL_DLLPUBLIC VclBox : public VclContainer
+{
+protected:
+ bool m_bHomogeneous;
+ bool m_bVerticalContainer;
+ int m_nSpacing;
+public:
+ VclBox(vcl::Window *pParent, bool bHomogeneous, int nSpacing)
+ : VclContainer(pParent)
+ , m_bHomogeneous(bHomogeneous)
+ , m_bVerticalContainer(false)
+ , m_nSpacing(nSpacing)
+ {
+ }
+ void set_spacing(int nSpacing)
+ {
+ m_nSpacing = nSpacing;
+ }
+ int get_spacing() const
+ {
+ return m_nSpacing;
+ }
+ void set_homogeneous(bool bHomogeneous)
+ {
+ m_bHomogeneous = bHomogeneous;
+ }
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+ virtual boost::property_tree::ptree DumpAsPropertyTree() override;
+protected:
+ virtual sal_uInt16 getDefaultAccessibleRole() const override;
+ void accumulateMaxes(const Size &rChildSize, Size &rSize) const;
+ Size finalizeMaxes(const Size &rSize, sal_uInt16 nVisibleChildren) const;
+
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+
+ virtual long getPrimaryDimension(const Size &rSize) const = 0;
+ virtual void setPrimaryDimension(Size &rSize, long) const = 0;
+ virtual long getPrimaryCoordinate(const Point &rPos) const = 0;
+ virtual void setPrimaryCoordinate(Point &rPos, long) const = 0;
+ virtual long getSecondaryDimension(const Size &rSize) const = 0;
+ virtual void setSecondaryDimension(Size &rSize, long) const = 0;
+
+ virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const = 0;
+};
+
+class VCL_DLLPUBLIC VclVBox : public VclBox
+{
+public:
+ VclVBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0)
+ : VclBox(pParent, bHomogeneous, nSpacing)
+ {
+ m_bVerticalContainer = true;
+ }
+protected:
+ virtual long getPrimaryDimension(const Size &rSize) const override
+ {
+ return rSize.getHeight();
+ }
+ virtual void setPrimaryDimension(Size &rSize, long nHeight) const override
+ {
+ rSize.setHeight(nHeight);
+ }
+ virtual long getPrimaryCoordinate(const Point &rPos) const override
+ {
+ return rPos.getY();
+ }
+ virtual void setPrimaryCoordinate(Point &rPos, long nPos) const override
+ {
+ rPos.setY(nPos);
+ }
+ virtual long getSecondaryDimension(const Size &rSize) const override
+ {
+ return rSize.getWidth();
+ }
+ virtual void setSecondaryDimension(Size &rSize, long nWidth) const override
+ {
+ rSize.setWidth(nWidth);
+ }
+ virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
+ {
+ return rWindow.get_expand() || rWindow.get_vexpand();
+ }
+};
+
+class VCL_DLLPUBLIC VclHBox : public VclBox
+{
+public:
+ VclHBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0)
+ : VclBox(pParent, bHomogeneous, nSpacing)
+ {
+ m_bVerticalContainer = false;
+ }
+protected:
+ virtual long getPrimaryDimension(const Size &rSize) const override
+ {
+ return rSize.getWidth();
+ }
+ virtual void setPrimaryDimension(Size &rSize, long nWidth) const override
+ {
+ rSize.setWidth(nWidth);
+ }
+ virtual long getPrimaryCoordinate(const Point &rPos) const override
+ {
+ return rPos.getX();
+ }
+ virtual void setPrimaryCoordinate(Point &rPos, long nPos) const override
+ {
+ rPos.setX(nPos);
+ }
+ virtual long getSecondaryDimension(const Size &rSize) const override
+ {
+ return rSize.getHeight();
+ }
+ virtual void setSecondaryDimension(Size &rSize, long nHeight) const override
+ {
+ rSize.setHeight(nHeight);
+ }
+ virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
+ {
+ return rWindow.get_expand() || rWindow.get_hexpand();
+ }
+};
+
+enum class VclButtonBoxStyle
+{
+ Default,
+ Spread,
+ Edge,
+ Start,
+ End,
+ Center
+};
+
+class VCL_DLLPUBLIC VclButtonBox : public VclBox
+{
+public:
+ VclButtonBox(vcl::Window *pParent)
+ : VclBox(pParent, false, Application::GetSettings().GetStyleSettings().GetDialogStyle().button_spacing)
+ , m_eLayoutStyle(VclButtonBoxStyle::Default)
+ {
+ }
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+ void sort_native_button_order();
+protected:
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ Size addSpacing(const Size &rSize, sal_uInt16 nVisibleChildren) const;
+private:
+ VclButtonBoxStyle m_eLayoutStyle;
+ struct Requisition
+ {
+ std::vector<long> m_aMainGroupDimensions;
+ std::vector<long> m_aSubGroupDimensions;
+ Size m_aMainGroupSize;
+ Size m_aSubGroupSize;
+ };
+ Requisition calculatePrimarySecondaryRequisitions() const;
+ Size addReqGroups(const VclButtonBox::Requisition &rReq) const;
+};
+
+class VCL_DLLPUBLIC VclVButtonBox : public VclButtonBox
+{
+public:
+ VclVButtonBox(vcl::Window *pParent)
+ : VclButtonBox(pParent)
+ {
+ m_bVerticalContainer = true;
+ }
+protected:
+ virtual long getPrimaryDimension(const Size &rSize) const override
+ {
+ return rSize.getHeight();
+ }
+ virtual void setPrimaryDimension(Size &rSize, long nHeight) const override
+ {
+ rSize.setHeight(nHeight);
+ }
+ virtual long getPrimaryCoordinate(const Point &rPos) const override
+ {
+ return rPos.getY();
+ }
+ virtual void setPrimaryCoordinate(Point &rPos, long nPos) const override
+ {
+ rPos.setY(nPos);
+ }
+ virtual long getSecondaryDimension(const Size &rSize) const override
+ {
+ return rSize.getWidth();
+ }
+ virtual void setSecondaryDimension(Size &rSize, long nWidth) const override
+ {
+ rSize.setWidth(nWidth);
+ }
+ virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
+ {
+ return rWindow.get_expand() || rWindow.get_vexpand();
+ }
+};
+
+class VCL_DLLPUBLIC VclHButtonBox final : public VclButtonBox
+{
+public:
+ VclHButtonBox(vcl::Window *pParent)
+ : VclButtonBox(pParent)
+ {
+ m_bVerticalContainer = false;
+ }
+private:
+ virtual long getPrimaryDimension(const Size &rSize) const override
+ {
+ return rSize.getWidth();
+ }
+ virtual void setPrimaryDimension(Size &rSize, long nWidth) const override
+ {
+ rSize.setWidth(nWidth);
+ }
+ virtual long getPrimaryCoordinate(const Point &rPos) const override
+ {
+ return rPos.getX();
+ }
+ virtual void setPrimaryCoordinate(Point &rPos, long nPos) const override
+ {
+ rPos.setX(nPos);
+ }
+ virtual long getSecondaryDimension(const Size &rSize) const override
+ {
+ return rSize.getHeight();
+ }
+ virtual void setSecondaryDimension(Size &rSize, long nHeight) const override
+ {
+ rSize.setHeight(nHeight);
+ }
+ virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
+ {
+ return rWindow.get_expand() || rWindow.get_hexpand();
+ }
+};
+
+class VCL_DLLPUBLIC VclGrid final : public VclContainer
+{
+private:
+ bool m_bRowHomogeneous;
+ bool m_bColumnHomogeneous;
+ int m_nRowSpacing;
+ int m_nColumnSpacing;
+
+public:
+ struct Value
+ {
+ long m_nValue;
+ bool m_bExpand;
+ Value() : m_nValue(0), m_bExpand(false) {}
+ };
+private:
+
+ Size calculateRequisitionForSpacings(sal_Int32 nRowSpacing, sal_Int32 nColSpacing) const;
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ virtual boost::property_tree::ptree DumpAsPropertyTree() override;
+public:
+ VclGrid(vcl::Window *pParent)
+ : VclContainer(pParent)
+ , m_bRowHomogeneous(false), m_bColumnHomogeneous(false)
+ , m_nRowSpacing(0), m_nColumnSpacing(0)
+ {
+ }
+ bool get_row_homogeneous() const
+ {
+ return m_bRowHomogeneous;
+ }
+ bool get_column_homogeneous() const
+ {
+ return m_bColumnHomogeneous;
+ }
+ void set_row_spacing(int nSpacing)
+ {
+ m_nRowSpacing = nSpacing;
+ }
+ void set_column_spacing(int nSpacing)
+ {
+ m_nColumnSpacing = nSpacing;
+ }
+ int get_row_spacing() const
+ {
+ return m_nRowSpacing;
+ }
+ int get_column_spacing() const
+ {
+ return m_nColumnSpacing;
+ }
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclBin : public VclContainer
+{
+public:
+ VclBin(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN)
+ : VclContainer(pParent, nStyle)
+ {
+ }
+ virtual vcl::Window *get_child();
+ virtual const vcl::Window *get_child() const;
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+};
+
+class VclPaned : public VclContainer
+{
+protected:
+ VclPtr<Splitter> m_pSplitter;
+ long m_nPosition;
+
+ VclPaned(vcl::Window *pParent, bool bVertical);
+public:
+ virtual ~VclPaned() override;
+ virtual void dispose() override;
+ long get_position() const { return m_nPosition; }
+ virtual void set_position(long nPosition) { m_nPosition = nPosition; }
+};
+
+class VclVPaned final : public VclPaned
+{
+private:
+ DECL_LINK(SplitHdl, Splitter*, void);
+ void arrange(const Size& rAllocation, long nFirstHeight, long nSecondHeight);
+
+public:
+ VclVPaned(vcl::Window *pParent);
+ virtual ~VclVPaned() override;
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ virtual void set_position(long nPosition) override;
+};
+
+class VclHPaned final : public VclPaned
+{
+private:
+ DECL_LINK(SplitHdl, Splitter*, void);
+ void arrange(const Size& rAllocation, long nFirstHeight, long nSecondHeight);
+
+public:
+ VclHPaned(vcl::Window *pParent);
+ virtual ~VclHPaned() override;
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ virtual void set_position(long nPosition) override;
+};
+
+class VclFrame final : public VclBin
+{
+private:
+ VclPtr<vcl::Window> m_pLabel;
+private:
+ friend class VclBuilder;
+ void designate_label(vcl::Window *pWindow);
+ DECL_LINK(WindowEventListener, VclWindowEvent&, void);
+public:
+ VclFrame(vcl::Window *pParent)
+ : VclBin(pParent)
+ , m_pLabel(nullptr)
+ {
+ }
+ virtual ~VclFrame() override;
+ virtual void dispose() override;
+ void set_label(const OUString &rLabel);
+ OUString get_label() const;
+ virtual vcl::Window *get_child() override;
+ virtual const vcl::Window *get_child() const override;
+ vcl::Window *get_label_widget();
+ const vcl::Window *get_label_widget() const;
+ virtual boost::property_tree::ptree DumpAsPropertyTree() override;
+private:
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ virtual OUString getDefaultAccessibleName() const override;
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclAlignment final : public VclBin
+{
+public:
+ VclAlignment(vcl::Window *pParent)
+ : VclBin(pParent)
+ , m_nBottomPadding(0)
+ , m_nLeftPadding(0)
+ , m_nRightPadding(0)
+ , m_nTopPadding(0)
+ {
+ }
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+private:
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ sal_Int32 m_nBottomPadding;
+ sal_Int32 m_nLeftPadding;
+ sal_Int32 m_nRightPadding;
+ sal_Int32 m_nTopPadding;
+};
+
+class DisclosureButton;
+class CheckBox;
+
+class VclExpander final : public VclBin
+{
+public:
+ VclExpander(vcl::Window *pParent);
+ virtual ~VclExpander() override;
+ virtual void dispose() override;
+ virtual vcl::Window *get_child() override;
+ virtual const vcl::Window *get_child() const override;
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+ bool get_expanded() const;
+ void set_expanded(bool bExpanded);
+ void set_label(const OUString& rLabel);
+ virtual void StateChanged(StateChangedType nType) override;
+ void SetExpandedHdl( const Link<VclExpander&,void>& rLink ) { maExpandedHdl = rLink; }
+private:
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ bool m_bResizeTopLevel;
+ VclPtr<DisclosureButton> m_pDisclosureButton;
+ Link<VclExpander&,void> maExpandedHdl;
+ DECL_LINK(ClickHdl, CheckBox&, void);
+};
+
+class VCL_DLLPUBLIC VclScrolledWindow final : public VclBin
+{
+public:
+ VclScrolledWindow(vcl::Window *pParent );
+ virtual ~VclScrolledWindow() override;
+ virtual void dispose() override;
+ virtual vcl::Window *get_child() override;
+ virtual const vcl::Window *get_child() const override;
+ virtual bool set_property(const OString &rKey, const OUString &rValue) override;
+ virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
+ ScrollBar& getVertScrollBar() { return *m_pVScroll; }
+ ScrollBar& getHorzScrollBar() { return *m_pHScroll; }
+ Size getVisibleChildSize() const;
+ //set to true to disable the built-in scrolling callbacks to allow the user
+ //to override it
+ void setUserManagedScrolling(bool bUserManagedScrolling) { m_bUserManagedScrolling = bUserManagedScrolling;}
+ void doSetAllocation(const Size &rAllocation, bool bRetryOnFailure);
+private:
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+ DECL_LINK(ScrollBarHdl, ScrollBar*, void);
+ void InitScrollBars(const Size &rRequest);
+ virtual bool EventNotify(NotifyEvent& rNEvt) override;
+ bool m_bUserManagedScrolling;
+ DrawFrameStyle m_eDrawFrameStyle;
+ VclPtr<ScrollBar> m_pVScroll;
+ VclPtr<ScrollBar> m_pHScroll;
+ VclPtr<ScrollBarBox> m_aScrollBarBox;
+};
+
+class VclViewport final : public VclBin
+{
+public:
+ VclViewport(vcl::Window *pParent)
+ : VclBin(pParent, WB_HIDE | WB_CLIPCHILDREN)
+ , m_bInitialAllocation(true)
+ {
+ }
+private:
+ virtual void setAllocation(const Size &rAllocation) override;
+ bool m_bInitialAllocation;
+};
+
+//Enforces that its children are always the same size as itself.
+//Intercepts any Commands intended for its children.
+//
+//by default the Commands are discarded, inherit from this
+//and implement "Command" to get them
+class VclEventBox final : public VclBin
+{
+private:
+ //Any Commands an EventBoxHelper receives are forwarded to its parent
+ //The VclEventBox ensures that m_aEventBoxHelper is the
+ //first child and is transparent, but covers the rest of the children
+ class EventBoxHelper : public vcl::Window
+ {
+ public:
+ EventBoxHelper(vcl::Window* pParent)
+ : Window(pParent, 0)
+ {
+ SetSizePixel(pParent->GetSizePixel());
+ EnableChildTransparentMode();
+ SetPaintTransparent(true);
+ SetBackground();
+ }
+ virtual void Command(const CommandEvent& rCEvt) override
+ {
+ GetParent()->Command(rCEvt);
+ }
+ };
+
+ VclPtr<EventBoxHelper> m_aEventBoxHelper;
+ virtual void dispose() override;
+ virtual ~VclEventBox() override;
+public:
+ VclEventBox(vcl::Window* pParent)
+ : VclBin(pParent)
+ , m_aEventBoxHelper(VclPtr<EventBoxHelper>::Create(this))
+ {
+ m_aEventBoxHelper->Show();
+ }
+ virtual vcl::Window *get_child() override;
+ virtual const vcl::Window *get_child() const override;
+ virtual Size calculateRequisition() const override;
+ virtual void setAllocation(const Size &rAllocation) override;
+
+ virtual void Command(const CommandEvent& rCEvt) override;
+};
+
+class VclSizeGroup
+{
+private:
+ std::set< VclPtr<vcl::Window> > m_aWindows;
+ bool m_bIgnoreHidden;
+ VclSizeGroupMode m_eMode;
+
+ void trigger_queue_resize();
+public:
+ VclSizeGroup()
+ : m_bIgnoreHidden(false)
+ , m_eMode(VclSizeGroupMode::Horizontal)
+ {
+ }
+ void insert(vcl::Window *pWindow)
+ {
+ m_aWindows.insert(VclPtr<vcl::Window>(pWindow));
+ }
+ void erase(vcl::Window *pWindow)
+ {
+ m_aWindows.erase(VclPtr<vcl::Window>(pWindow));
+ }
+ const std::set< VclPtr<vcl::Window> >& get_widgets() const
+ {
+ return m_aWindows;
+ }
+ std::set< VclPtr<vcl::Window> >& get_widgets()
+ {
+ return m_aWindows;
+ }
+ void set_ignore_hidden(bool bIgnoreHidden);
+ bool get_ignore_hidden() const
+ {
+ return m_bIgnoreHidden;
+ }
+ void set_mode(VclSizeGroupMode eMode);
+ VclSizeGroupMode get_mode() const
+ {
+ return m_eMode;
+ }
+ void set_property(const OString &rKey, const OUString &rValue);
+};
+
+class VCL_DLLPUBLIC VclDrawingArea final : public Control
+ , public DragSourceHelper
+{
+private:
+ FactoryFunction m_pFactoryFunction;
+ void* m_pUserData;
+ rtl::Reference<TransferDataContainer> m_xTransferHelper;
+ sal_Int8 m_nDragAction;
+ Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void> m_aPaintHdl;
+ Link<const Size&, void> m_aResizeHdl;
+ Link<const MouseEvent&, bool> m_aMousePressHdl;
+ Link<const MouseEvent&, bool> m_aMouseMotionHdl;
+ Link<const MouseEvent&, bool> m_aMouseReleaseHdl;
+ Link<const KeyEvent&, bool> m_aKeyPressHdl;
+ Link<const KeyEvent&, bool> m_aKeyReleaseHdl;
+ Link<VclDrawingArea&, void> m_aStyleUpdatedHdl;
+ Link<const CommandEvent&, bool> m_aCommandHdl;
+ Link<tools::Rectangle&, OUString> m_aQueryTooltipHdl;
+ Link<OUString&, int> m_aGetSurroundingHdl;
+ Link<VclDrawingArea*, bool> m_aStartDragHdl;
+
+ virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override
+ {
+ m_aPaintHdl.Call(std::pair<vcl::RenderContext&, const tools::Rectangle&>(rRenderContext, rRect));
+ }
+ virtual void Resize() override
+ {
+ m_aResizeHdl.Call(GetOutputSizePixel());
+ }
+ virtual void MouseMove(const MouseEvent& rMEvt) override
+ {
+ if (!m_aMouseMotionHdl.Call(rMEvt))
+ Control::MouseMove(rMEvt);
+ }
+ virtual void MouseButtonDown(const MouseEvent& rMEvt) override
+ {
+ if (!m_aMousePressHdl.Call(rMEvt))
+ Control::MouseButtonDown(rMEvt);
+ }
+ virtual void MouseButtonUp(const MouseEvent& rMEvt) override
+ {
+ if (!m_aMouseReleaseHdl.Call(rMEvt))
+ Control::MouseButtonUp(rMEvt);
+ }
+ virtual void KeyInput(const KeyEvent& rKEvt) override
+ {
+ if (!m_aKeyPressHdl.Call(rKEvt))
+ Control::KeyInput(rKEvt);
+
+ }
+ virtual void KeyUp(const KeyEvent& rKEvt) override
+ {
+ if (!m_aKeyReleaseHdl.Call(rKEvt))
+ Control::KeyUp(rKEvt);
+ }
+ virtual void StateChanged(StateChangedType nType) override
+ {
+ Control::StateChanged(nType);
+ if (nType == StateChangedType::ControlForeground || nType == StateChangedType::ControlBackground)
+ {
+ m_aStyleUpdatedHdl.Call(*this);
+ Invalidate();
+ }
+ }
+ virtual void DataChanged(const DataChangedEvent& rDCEvt) override
+ {
+ Control::DataChanged(rDCEvt);
+ if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
+ {
+ m_aStyleUpdatedHdl.Call(*this);
+ Invalidate();
+ }
+ }
+ virtual void Command(const CommandEvent& rEvent) override
+ {
+ if (m_aCommandHdl.Call(rEvent))
+ return;
+ Control::Command(rEvent);
+ }
+ virtual void RequestHelp(const HelpEvent& rHelpEvent) override
+ {
+ if (rHelpEvent.GetMode() & (HelpEventMode::QUICK | HelpEventMode::BALLOON))
+ {
+ Point aPos(ScreenToOutputPixel(rHelpEvent.GetMousePosPixel()));
+ tools::Rectangle aHelpArea(aPos.X(), aPos.Y());
+ OUString sHelpTip = m_aQueryTooltipHdl.Call(aHelpArea);
+ if (sHelpTip.isEmpty())
+ return;
+ Point aPt = OutputToScreenPixel(aHelpArea.TopLeft());
+ aHelpArea.SetLeft(aPt.X());
+ aHelpArea.SetTop(aPt.Y());
+ aPt = OutputToScreenPixel(aHelpArea.BottomRight());
+ aHelpArea.SetRight(aPt.X());
+ aHelpArea.SetBottom(aPt.Y());
+ // tdf#125369 recover newline support of tdf#101779
+ QuickHelpFlags eHelpWinStyle = sHelpTip.indexOf('\n') != -1 ? QuickHelpFlags::TipStyleBalloon : QuickHelpFlags::NONE;
+ Help::ShowQuickHelp(this, aHelpArea, sHelpTip, eHelpWinStyle);
+ }
+ }
+ virtual void StartDrag(sal_Int8 nAction, const Point& rPosPixel) override;
+ virtual FactoryFunction GetUITestFactory() const override
+ {
+ if (m_pFactoryFunction)
+ return m_pFactoryFunction;
+ return Control::GetUITestFactory();
+ }
+
+public:
+ VclDrawingArea(vcl::Window *pParent, WinBits nStyle)
+ : Control(pParent, nStyle)
+ , DragSourceHelper(this)
+ , m_pFactoryFunction(nullptr)
+ , m_pUserData(nullptr)
+ , m_nDragAction(0)
+ {
+ SetBackground();
+ }
+ virtual OUString GetSurroundingText() const override;
+ virtual Selection GetSurroundingTextSelection() const override;
+ void SetUITestFactory(FactoryFunction pFactoryFunction, void* pUserData)
+ {
+ m_pFactoryFunction = pFactoryFunction;
+ m_pUserData = pUserData;
+ }
+ void* GetUserData() const
+ {
+ return m_pUserData;
+ }
+ void SetPaintHdl(const Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void>& rLink)
+ {
+ m_aPaintHdl = rLink;
+ }
+ void SetResizeHdl(const Link<const Size&, void>& rLink)
+ {
+ m_aResizeHdl = rLink;
+ }
+ void SetMousePressHdl(const Link<const MouseEvent&, bool>& rLink)
+ {
+ m_aMousePressHdl = rLink;
+ }
+ void SetMouseMoveHdl(const Link<const MouseEvent&, bool>& rLink)
+ {
+ m_aMouseMotionHdl = rLink;
+ }
+ void SetMouseReleaseHdl(const Link<const MouseEvent&, bool>& rLink)
+ {
+ m_aMouseReleaseHdl = rLink;
+ }
+ void SetKeyPressHdl(const Link<const KeyEvent&, bool>& rLink)
+ {
+ m_aKeyPressHdl = rLink;
+ }
+ void SetKeyReleaseHdl(const Link<const KeyEvent&, bool>& rLink)
+ {
+ m_aKeyReleaseHdl = rLink;
+ }
+ void SetStyleUpdatedHdl(const Link<VclDrawingArea&, void>& rLink)
+ {
+ m_aStyleUpdatedHdl = rLink;
+ }
+ void SetCommandHdl(const Link<const CommandEvent&, bool>& rLink)
+ {
+ m_aCommandHdl = rLink;
+ }
+ void SetQueryTooltipHdl(const Link<tools::Rectangle&, OUString>& rLink)
+ {
+ m_aQueryTooltipHdl = rLink;
+ }
+ void SetGetSurroundingHdl(const Link<OUString&, int>& rLink)
+ {
+ m_aGetSurroundingHdl = rLink;
+ }
+ void SetStartDragHdl(const Link<VclDrawingArea*, bool>& rLink)
+ {
+ m_aStartDragHdl = rLink;
+ }
+ void SetDragHelper(rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants)
+ {
+ m_xTransferHelper = rHelper;
+ m_nDragAction = eDNDConstants;
+ }
+};
+
+//Get first window of a pTopLevel window as
+//if any intermediate layout widgets didn't exist
+//i.e. acts like pChild = pChild->GetWindow(GetWindowType::FirstChild);
+//in a flat hierarchy where dialogs only have one layer
+//of children
+vcl::Window* firstLogicalChildOfParent(const vcl::Window *pTopLevel);
+
+//Get last window of a pTopLevel window as
+//if any intermediate layout widgets didn't exist
+//i.e. acts like pChild = pChild->GetWindow(GetWindowType::LastChild);
+//in a flat hierarchy where dialogs only have one layer
+//of children
+vcl::Window* lastLogicalChildOfParent(const vcl::Window *pTopLevel);
+
+//Get next window after pChild of a pTopLevel window as
+//if any intermediate layout widgets didn't exist
+//i.e. acts like pChild = pChild->GetWindow(GetWindowType::Next);
+//in a flat hierarchy where dialogs only have one layer
+//of children
+vcl::Window* nextLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
+
+//Get previous window before pChild of a pTopLevel window as
+//if any intermediate layout widgets didn't exist
+//i.e. acts like pChild = pChild->GetWindow(GetWindowType::Prev);
+//in a flat hierarchy where dialogs only have one layer
+//of children
+vcl::Window* prevLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
+
+//Returns true is the Window has a single child which is a container
+VCL_DLLPUBLIC bool isLayoutEnabled(const vcl::Window *pWindow);
+
+inline bool isContainerWindow(const vcl::Window &rWindow)
+{
+ WindowType eType = rWindow.GetType();
+ return eType == WindowType::CONTAINER || eType == WindowType::SCROLLWINDOW ||
+ (eType == WindowType::DOCKINGWINDOW && ::isLayoutEnabled(&rWindow));
+}
+
+inline bool isContainerWindow(const vcl::Window *pWindow)
+{
+ return pWindow && isContainerWindow(*pWindow);
+}
+
+// retro-fitting utilities
+
+//Get a Size which is large enough to contain all children with
+//an equal amount of space at top left and bottom right
+Size getLegacyBestSizeForChildren(const vcl::Window &rWindow);
+
+//Get first parent which is not a layout widget
+vcl::Window* getNonLayoutParent(vcl::Window *pParent);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */