include/vcl/layout.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #ifndef INCLUDED_VCL_LAYOUT_HXX
  11 #define INCLUDED_VCL_LAYOUT_HXX
  12
  13 #include <config_options.h>
  14 #include <vcl/dllapi.h>
  15 #include <vcl/ctrl.hxx>
  16 #include <vcl/svapp.hxx>
  17 #include <vcl/window.hxx>
  18 #include <vcl/settings.hxx>
  19 #include <vcl/event.hxx>
  20 #include <vcl/transfer.hxx>
  21 #include <vcl/vclptr.hxx>
  22 #include <vcl/IContext.hxx>
  23 #include <vcl/commandevent.hxx>
  24 #include <set>
  25
  26 class HelpEvent;
  27 class ScrollBar;
  28 class ScrollBarBox;
  29 class Splitter;
  30
  31 class VCL_DLLPUBLIC VclContainer : public vcl::Window,
  32                                    public vcl::IContext
  33 {
  34 public:
  35     VclContainer(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN);
  36
  37     //These take into account the external margins of the rWindow widget
  38     //while GetOptimalSize/get_preferred_size and SetPosSizePixel are
  39     //oblivious to them
  40     static Size getLayoutRequisition(const vcl::Window &rWindow);
  41     static void setLayoutPosSize(vcl::Window &rWindow, const Point &rPos, const Size &rSize);
  42
  43     //applies the allocation pos and size onto rWindow via setLayoutPosSize taking into account
  44     //the rWindows alignment desires within that allocation
  45     static void setLayoutAllocation(vcl::Window &rWindow, const Point &rPos, const Size &rSize);
  46
  47     virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override;
  48 protected:
  49     //these are the two that need to be implemented by
  50     //containers, figure out how much space you want...
  51     virtual Size calculateRequisition() const = 0;
  52     //..and decide what to do when set to this size
  53     virtual void setAllocation(const Size &rAllocation) = 0;
  54
  55     virtual sal_uInt16 getDefaultAccessibleRole() const override;
  56
  57     // support for screenshot context menu
  58     virtual void Command(const CommandEvent& rCEvt) override;
  59
  60 public:
  61     //you don't want to override these
  62     virtual Size GetOptimalSize() const override;
  63     virtual void SetPosSizePixel(const Point& rNewPos, const Size& rNewSize) override;
  64     virtual void SetPosPixel(const Point& rAllocPos) override;
  65     virtual void SetSizePixel(const Size& rAllocation) override;
  66 private:
  67     bool m_bLayoutDirty;
  68 };
  69
  70 class VCL_DLLPUBLIC VclBox : public VclContainer
  71 {
  72 protected:
  73     bool m_bHomogeneous;
  74     bool m_bVerticalContainer;
  75     int m_nSpacing;
  76 public:
  77     VclBox(vcl::Window *pParent, bool bHomogeneous, int nSpacing)
  78         : VclContainer(pParent)
  79         , m_bHomogeneous(bHomogeneous)
  80         , m_bVerticalContainer(false)
  81         , m_nSpacing(nSpacing)
  82     {
  83     }
  84     void set_spacing(int nSpacing)
  85     {
  86         m_nSpacing = nSpacing;
  87     }
  88     int get_spacing() const
  89     {
  90         return m_nSpacing;
  91     }
  92     void set_homogeneous(bool bHomogeneous)
  93     {
  94         m_bHomogeneous = bHomogeneous;
  95     }
  96     bool get_orientation() const
  97     {
  98         return m_bVerticalContainer;
  99     }
 100     virtual bool set_property(const OUString &rKey, const OUString &rValue) override;
 101     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 102 protected:
 103     virtual sal_uInt16 getDefaultAccessibleRole() const override;
 104     void accumulateMaxes(const Size &rChildSize, Size &rSize) const;
 105     Size finalizeMaxes(const Size &rSize, sal_uInt16 nVisibleChildren) const;
 106
 107     virtual Size calculateRequisition() const override;
 108     virtual void setAllocation(const Size &rAllocation) override;
 109
 110     virtual tools::Long getPrimaryDimension(const Size &rSize) const = 0;
 111     virtual void setPrimaryDimension(Size &rSize, tools::Long) const = 0;
 112     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const = 0;
 113     virtual void setPrimaryCoordinate(Point &rPos, tools::Long) const = 0;
 114     virtual tools::Long getSecondaryDimension(const Size &rSize) const = 0;
 115     virtual void setSecondaryDimension(Size &rSize, tools::Long) const = 0;
 116
 117     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const = 0;
 118 };
 119
 120 class VCL_DLLPUBLIC VclVBox : public VclBox
 121 {
 122 public:
 123     VclVBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0)
 124         : VclBox(pParent, bHomogeneous, nSpacing)
 125     {
 126         m_bVerticalContainer = true;
 127     }
 128 protected:
 129     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 130     {
 131         return rSize.getHeight();
 132     }
 133     virtual void setPrimaryDimension(Size &rSize, tools::Long nHeight) const override
 134     {
 135         rSize.setHeight(nHeight);
 136     }
 137     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 138     {
 139         return rPos.getY();
 140     }
 141     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 142     {
 143         rPos.setY(nPos);
 144     }
 145     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 146     {
 147         return rSize.getWidth();
 148     }
 149     virtual void setSecondaryDimension(Size &rSize, tools::Long nWidth) const override
 150     {
 151         rSize.setWidth(nWidth);
 152     }
 153     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 154     {
 155         return rWindow.get_expand() || rWindow.get_vexpand();
 156     }
 157 };
 158
 159 class VCL_DLLPUBLIC VclHBox : public VclBox
 160 {
 161 public:
 162     VclHBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0)
 163         : VclBox(pParent, bHomogeneous, nSpacing)
 164     {
 165         m_bVerticalContainer = false;
 166     }
 167 protected:
 168     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 169     {
 170         return rSize.getWidth();
 171     }
 172     virtual void setPrimaryDimension(Size &rSize, tools::Long nWidth) const override
 173     {
 174         rSize.setWidth(nWidth);
 175     }
 176     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 177     {
 178         return rPos.getX();
 179     }
 180     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 181     {
 182         rPos.setX(nPos);
 183     }
 184     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 185     {
 186         return rSize.getHeight();
 187     }
 188     virtual void setSecondaryDimension(Size &rSize, tools::Long nHeight) const override
 189     {
 190         rSize.setHeight(nHeight);
 191     }
 192     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 193     {
 194         return rWindow.get_expand() || rWindow.get_hexpand();
 195     }
 196 };
 197
 198 enum class VclButtonBoxStyle
 199 {
 200     Default,
 201     Spread,
 202     Edge,
 203     Start,
 204     End,
 205     Center
 206 };
 207
 208 class VCL_DLLPUBLIC VclButtonBox : public VclBox
 209 {
 210 public:
 211     VclButtonBox(vcl::Window *pParent)
 212         : VclBox(pParent, false, Application::GetSettings().GetStyleSettings().GetDialogStyle().button_spacing)
 213         , m_eLayoutStyle(VclButtonBoxStyle::Default)
 214     {
 215     }
 216     virtual bool set_property(const OUString &rKey, const OUString &rValue) override;
 217     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 218 protected:
 219     virtual Size calculateRequisition() const override;
 220     virtual void setAllocation(const Size &rAllocation) override;
 221     Size addSpacing(const Size &rSize, sal_uInt16 nVisibleChildren) const;
 222 private:
 223     VclButtonBoxStyle m_eLayoutStyle;
 224     struct Requisition
 225     {
 226         std::vector<tools::Long> m_aMainGroupDimensions;
 227         std::vector<tools::Long> m_aSubGroupDimensions;
 228         Size m_aMainGroupSize;
 229         Size m_aSubGroupSize;
 230     };
 231     Requisition calculatePrimarySecondaryRequisitions() const;
 232     Size addReqGroups(const VclButtonBox::Requisition &rReq) const;
 233 };
 234
 235 class VCL_DLLPUBLIC VclVButtonBox : public VclButtonBox
 236 {
 237 public:
 238     VclVButtonBox(vcl::Window *pParent)
 239         : VclButtonBox(pParent)
 240     {
 241         m_bVerticalContainer = true;
 242     }
 243 protected:
 244     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 245     {
 246         return rSize.getHeight();
 247     }
 248     virtual void setPrimaryDimension(Size &rSize, tools::Long nHeight) const override
 249     {
 250         rSize.setHeight(nHeight);
 251     }
 252     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 253     {
 254         return rPos.getY();
 255     }
 256     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 257     {
 258         rPos.setY(nPos);
 259     }
 260     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 261     {
 262         return rSize.getWidth();
 263     }
 264     virtual void setSecondaryDimension(Size &rSize, tools::Long nWidth) const override
 265     {
 266         rSize.setWidth(nWidth);
 267     }
 268     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 269     {
 270         return rWindow.get_expand() || rWindow.get_vexpand();
 271     }
 272 };
 273
 274 class VCL_DLLPUBLIC VclHButtonBox final : public VclButtonBox
 275 {
 276 public:
 277     VclHButtonBox(vcl::Window *pParent)
 278         : VclButtonBox(pParent)
 279     {
 280         m_bVerticalContainer = false;
 281     }
 282 private:
 283     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 284     {
 285         return rSize.getWidth();
 286     }
 287     virtual void setPrimaryDimension(Size &rSize, tools::Long nWidth) const override
 288     {
 289         rSize.setWidth(nWidth);
 290     }
 291     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 292     {
 293         return rPos.getX();
 294     }
 295     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 296     {
 297         rPos.setX(nPos);
 298     }
 299     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 300     {
 301         return rSize.getHeight();
 302     }
 303     virtual void setSecondaryDimension(Size &rSize, tools::Long nHeight) const override
 304     {
 305         rSize.setHeight(nHeight);
 306     }
 307     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 308     {
 309         return rWindow.get_expand() || rWindow.get_hexpand();
 310     }
 311 };
 312
 313 class VCL_DLLPUBLIC VclGrid final : public VclContainer
 314 {
 315 private:
 316     bool m_bRowHomogeneous;
 317     bool m_bColumnHomogeneous;
 318     int m_nRowSpacing;
 319     int m_nColumnSpacing;
 320
 321 public:
 322     struct Value
 323     {
 324         tools::Long m_nValue;
 325         bool m_bExpand;
 326         Value() : m_nValue(0), m_bExpand(false) {}
 327     };
 328 private:
 329
 330     Size calculateRequisitionForSpacings(sal_Int32 nRowSpacing, sal_Int32 nColSpacing) const;
 331     virtual Size calculateRequisition() const override;
 332     virtual void setAllocation(const Size &rAllocation) override;
 333     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 334 public:
 335     VclGrid(vcl::Window *pParent)
 336         : VclContainer(pParent)
 337         , m_bRowHomogeneous(false), m_bColumnHomogeneous(false)
 338         , m_nRowSpacing(0), m_nColumnSpacing(0)
 339     {
 340     }
 341     bool get_row_homogeneous() const
 342     {
 343         return m_bRowHomogeneous;
 344     }
 345     bool get_column_homogeneous() const
 346     {
 347         return m_bColumnHomogeneous;
 348     }
 349     void set_row_spacing(int nSpacing)
 350     {
 351         m_nRowSpacing = nSpacing;
 352     }
 353     void set_column_spacing(int nSpacing)
 354     {
 355         m_nColumnSpacing = nSpacing;
 356     }
 357     int get_row_spacing() const
 358     {
 359         return m_nRowSpacing;
 360     }
 361     int get_column_spacing() const
 362     {
 363         return m_nColumnSpacing;
 364     }
 365     virtual bool set_property(const OUString &rKey, const OUString &rValue) override;
 366 };
 367
 368 class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclBin : public VclContainer
 369 {
 370 public:
 371     VclBin(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN)
 372         : VclContainer(pParent, nStyle)
 373     {
 374     }
 375     virtual vcl::Window *get_child();
 376     virtual const vcl::Window *get_child() const;
 377     virtual Size calculateRequisition() const override;
 378     virtual void setAllocation(const Size &rAllocation) override;
 379 };
 380
 381 class VclPaned : public VclContainer
 382 {
 383 protected:
 384     VclPtr<Splitter> m_pSplitter;
 385     tools::Long m_nPosition;
 386
 387     VclPaned(vcl::Window *pParent, bool bVertical);
 388 public:
 389     virtual ~VclPaned() override;
 390     virtual void dispose() override;
 391     tools::Long get_position() const { return m_nPosition; }
 392     virtual void set_position(tools::Long nPosition) { m_nPosition = nPosition; }
 393 };
 394
 395 class VclVPaned final : public VclPaned
 396 {
 397 private:
 398     DECL_LINK(SplitHdl, Splitter*, void);
 399     void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight);
 400
 401 public:
 402     VclVPaned(vcl::Window *pParent);
 403     virtual ~VclVPaned() override;
 404     virtual Size calculateRequisition() const override;
 405     virtual void setAllocation(const Size &rAllocation) override;
 406     virtual void set_position(tools::Long nPosition) override;
 407 };
 408
 409 class VclHPaned final : public VclPaned
 410 {
 411 private:
 412     DECL_LINK(SplitHdl, Splitter*, void);
 413     void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight);
 414
 415 public:
 416     VclHPaned(vcl::Window *pParent);
 417     virtual ~VclHPaned() override;
 418     virtual Size calculateRequisition() const override;
 419     virtual void setAllocation(const Size &rAllocation) override;
 420     virtual void set_position(tools::Long nPosition) override;
 421 };
 422
 423 class VclFrame final : public VclBin
 424 {
 425 private:
 426     VclPtr<vcl::Window> m_pLabel;
 427 private:
 428     friend class VclBuilder;
 429     void designate_label(vcl::Window *pWindow);
 430     DECL_LINK(WindowEventListener, VclWindowEvent&, void);
 431 public:
 432     VclFrame(vcl::Window *pParent)
 433         : VclBin(pParent)
 434         , m_pLabel(nullptr)
 435     {
 436     }
 437     virtual ~VclFrame() override;
 438     virtual void dispose() override;
 439     void set_label(const OUString &rLabel);
 440     OUString get_label() const;
 441     virtual vcl::Window *get_child() override;
 442     virtual const vcl::Window *get_child() const override;
 443     vcl::Window *get_label_widget();
 444     const vcl::Window *get_label_widget() const;
 445     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 446 private:
 447     virtual Size calculateRequisition() const override;
 448     virtual void setAllocation(const Size &rAllocation) override;
 449     virtual OUString getDefaultAccessibleName() const override;
 450 };
 451
 452 class DisclosureButton;
 453 class CheckBox;
 454
 455 class VclExpander final : public VclBin
 456 {
 457 public:
 458     VclExpander(vcl::Window *pParent);
 459     virtual ~VclExpander() override;
 460     virtual void dispose() override;
 461     virtual vcl::Window *get_child() override;
 462     virtual const vcl::Window *get_child() const override;
 463     virtual bool set_property(const OUString &rKey, const OUString &rValue) override;
 464     bool get_expanded() const;
 465     void set_expanded(bool bExpanded);
 466     void set_label(const OUString& rLabel);
 467     OUString get_label() const;
 468     vcl::Window *get_label_widget();
 469     const vcl::Window *get_label_widget() const;
 470     virtual void StateChanged(StateChangedType nType) override;
 471     void  SetExpandedHdl( const Link<VclExpander&,void>& rLink ) { maExpandedHdl = rLink; }
 472     virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override;
 473     virtual FactoryFunction GetUITestFactory() const override;
 474 private:
 475     virtual Size calculateRequisition() const override;
 476     virtual void setAllocation(const Size &rAllocation) override;
 477     bool m_bResizeTopLevel;
 478     VclPtr<DisclosureButton> m_pDisclosureButton;
 479     Link<VclExpander&,void> maExpandedHdl;
 480     DECL_LINK(ClickHdl, CheckBox&, void);
 481 };
 482
 483 class VclScrolledWindow final : public VclBin
 484 {
 485 public:
 486     VclScrolledWindow(vcl::Window *pParent );
 487     virtual ~VclScrolledWindow() override;
 488     virtual void dispose() override;
 489     virtual vcl::Window *get_child() override;
 490     virtual const vcl::Window *get_child() const override;
 491     virtual bool set_property(const OUString &rKey, const OUString &rValue) override;
 492     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
 493     bool HasVisibleBorder() const { return m_eDrawFrameStyle != DrawFrameStyle::NONE; }
 494     ScrollBar& getVertScrollBar() { return *m_pVScroll; }
 495     ScrollBar& getHorzScrollBar() { return *m_pHScroll; }
 496     Size getVisibleChildSize() const;
 497     //set to true to disable the built-in scrolling callbacks to allow the user
 498     //to override it
 499     void setUserManagedScrolling(bool bUserManagedScrolling) { m_bUserManagedScrolling = bUserManagedScrolling;}
 500     void doSetAllocation(const Size &rAllocation, bool bRetryOnFailure);
 501     virtual void DumpAsPropertyTree(::tools::JsonWriter& rJsonWriter) override;
 502 private:
 503     virtual Size calculateRequisition() const override;
 504     virtual void setAllocation(const Size &rAllocation) override;
 505     int CalcBorderWidth() const;
 506     DECL_LINK(ScrollBarHdl, ScrollBar*, void);
 507     void InitScrollBars(const Size &rRequest);
 508     virtual bool EventNotify(NotifyEvent& rNEvt) override;
 509     bool m_bUserManagedScrolling;
 510     tools::Long m_nBorderWidth;
 511     DrawFrameStyle m_eDrawFrameStyle;
 512     DrawFrameFlags m_eDrawFrameFlags;
 513     VclPtr<ScrollBar> m_pVScroll;
 514     VclPtr<ScrollBar> m_pHScroll;
 515     VclPtr<ScrollBarBox> m_aScrollBarBox;
 516 };
 517
 518 class VclViewport final : public VclBin
 519 {
 520 public:
 521     VclViewport(vcl::Window *pParent)
 522         : VclBin(pParent, WB_HIDE | WB_CLIPCHILDREN)
 523         , m_bInitialAllocation(true)
 524     {
 525     }
 526 private:
 527     virtual void setAllocation(const Size &rAllocation) override;
 528     bool m_bInitialAllocation;
 529 };
 530
 531 //Enforces that its children are always the same size as itself.
 532 //Intercepts any Commands intended for its children.
 533 //
 534 //by default the Commands are discarded, inherit from this
 535 //and implement "Command" to get them
 536 class VclEventBox final : public VclBin
 537 {
 538 private:
 539     //Any Commands an EventBoxHelper receives are forwarded to its parent
 540     //The VclEventBox ensures that m_aEventBoxHelper is the
 541     //first child and is transparent, but covers the rest of the children
 542     class EventBoxHelper final : public vcl::Window
 543     {
 544     public:
 545         EventBoxHelper(vcl::Window* pParent)
 546             : Window(pParent, 0)
 547         {
 548             SetSizePixel(pParent->GetSizePixel());
 549             EnableChildTransparentMode();
 550             SetPaintTransparent(true);
 551             SetBackground();
 552         }
 553         virtual void Command(const CommandEvent& rCEvt) override
 554         {
 555             GetParent()->Command(rCEvt);
 556         }
 557     };
 558
 559     VclPtr<EventBoxHelper> m_aEventBoxHelper;
 560     virtual void dispose() override;
 561     virtual ~VclEventBox() override;
 562 public:
 563     VclEventBox(vcl::Window* pParent)
 564         : VclBin(pParent)
 565         , m_aEventBoxHelper(VclPtr<EventBoxHelper>::Create(this))
 566     {
 567         m_aEventBoxHelper->Show();
 568     }
 569     virtual vcl::Window *get_child() override;
 570     virtual const vcl::Window *get_child() const override;
 571     virtual Size calculateRequisition() const override;
 572     virtual void setAllocation(const Size &rAllocation) override;
 573
 574     virtual void Command(const CommandEvent& rCEvt) override;
 575 };
 576
 577 class VclSizeGroup
 578 {
 579 private:
 580     std::set< VclPtr<vcl::Window> > m_aWindows;
 581     bool m_bIgnoreHidden;
 582     VclSizeGroupMode m_eMode;
 583
 584     void trigger_queue_resize();
 585 public:
 586     VclSizeGroup()
 587         : m_bIgnoreHidden(false)
 588         , m_eMode(VclSizeGroupMode::Horizontal)
 589     {
 590     }
 591     void insert(vcl::Window *pWindow)
 592     {
 593         m_aWindows.insert(VclPtr<vcl::Window>(pWindow));
 594     }
 595     void erase(vcl::Window *pWindow)
 596     {
 597         m_aWindows.erase(VclPtr<vcl::Window>(pWindow));
 598     }
 599     const std::set< VclPtr<vcl::Window> >& get_widgets() const
 600     {
 601         return m_aWindows;
 602     }
 603     std::set< VclPtr<vcl::Window> >& get_widgets()
 604     {
 605         return m_aWindows;
 606     }
 607     void set_ignore_hidden(bool bIgnoreHidden);
 608     bool get_ignore_hidden() const
 609     {
 610         return m_bIgnoreHidden;
 611     }
 612     void set_mode(VclSizeGroupMode eMode);
 613     VclSizeGroupMode get_mode() const
 614     {
 615         return m_eMode;
 616     }
 617     void set_property(const OUString &rKey, const OUString &rValue);
 618 };
 619
 620 class VCL_DLLPUBLIC VclDrawingArea final : public Control
 621                                          , public DragSourceHelper
 622 {
 623 private:
 624     FactoryFunction m_pFactoryFunction;
 625     void* m_pUserData;
 626     rtl::Reference<TransferDataContainer> m_xTransferHelper;
 627     sal_Int8 m_nDragAction;
 628     Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void> m_aPaintHdl;
 629     Link<const Size&, void> m_aResizeHdl;
 630     Link<const MouseEvent&, bool> m_aMousePressHdl;
 631     Link<const MouseEvent&, bool> m_aMouseMotionHdl;
 632     Link<const MouseEvent&, bool> m_aMouseReleaseHdl;
 633     Link<const KeyEvent&, bool> m_aKeyPressHdl;
 634     Link<const KeyEvent&, bool> m_aKeyReleaseHdl;
 635     Link<VclDrawingArea&, void> m_aStyleUpdatedHdl;
 636     Link<const CommandEvent&, bool> m_aCommandHdl;
 637     Link<tools::Rectangle&, OUString> m_aQueryTooltipHdl;
 638     Link<OUString&, int> m_aGetSurroundingHdl;
 639     Link<const Selection&, bool> m_aDeleteSurroundingHdl;
 640     Link<VclDrawingArea*, bool> m_aStartDragHdl;
 641
 642     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override
 643     {
 644         m_aPaintHdl.Call(std::pair<vcl::RenderContext&, const tools::Rectangle&>(rRenderContext, rRect));
 645     }
 646     virtual void Resize() override
 647     {
 648         m_aResizeHdl.Call(GetOutputSizePixel());
 649     }
 650     virtual void KeyInput(const KeyEvent& rKEvt) override
 651     {
 652         if (!m_aKeyPressHdl.Call(rKEvt))
 653             Control::KeyInput(rKEvt);
 654
 655     }
 656     virtual void KeyUp(const KeyEvent& rKEvt) override
 657     {
 658         if (!m_aKeyReleaseHdl.Call(rKEvt))
 659             Control::KeyUp(rKEvt);
 660     }
 661     virtual void StateChanged(StateChangedType nType) override
 662     {
 663         Control::StateChanged(nType);
 664         if (nType == StateChangedType::ControlForeground || nType == StateChangedType::ControlBackground)
 665         {
 666             m_aStyleUpdatedHdl.Call(*this);
 667             Invalidate();
 668         }
 669     }
 670     virtual void DataChanged(const DataChangedEvent& rDCEvt) override
 671     {
 672         Control::DataChanged(rDCEvt);
 673         if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
 674         {
 675             m_aStyleUpdatedHdl.Call(*this);
 676             Invalidate();
 677         }
 678     }
 679     virtual void Command(const CommandEvent& rEvent) override
 680     {
 681         if (m_aCommandHdl.Call(rEvent))
 682             return;
 683         Control::Command(rEvent);
 684     }
 685     virtual void RequestHelp(const HelpEvent& rHelpEvent) override;
 686     virtual void StartDrag(sal_Int8 nAction, const Point& rPosPixel) override;
 687     virtual FactoryFunction GetUITestFactory() const override;
 688
 689 public:
 690     VclDrawingArea(vcl::Window *pParent, WinBits nStyle)
 691         : Control(pParent, nStyle)
 692         , DragSourceHelper(this)
 693         , m_pFactoryFunction(nullptr)
 694         , m_pUserData(nullptr)
 695         , m_nDragAction(0)
 696     {
 697         SetBackground();
 698     }
 699     virtual void MouseButtonDown(const MouseEvent& rMEvt) override
 700     {
 701         if (!m_aMousePressHdl.Call(rMEvt))
 702             Control::MouseButtonDown(rMEvt);
 703     }
 704     virtual void MouseButtonUp(const MouseEvent& rMEvt) override
 705     {
 706         if (!m_aMouseReleaseHdl.Call(rMEvt))
 707             Control::MouseButtonUp(rMEvt);
 708     }
 709     virtual void MouseMove(const MouseEvent& rMEvt) override
 710     {
 711         if (!m_aMouseMotionHdl.Call(rMEvt))
 712             Control::MouseMove(rMEvt);
 713     }
 714     virtual OUString GetSurroundingText() const override;
 715     virtual Selection GetSurroundingTextSelection() const override;
 716     virtual bool DeleteSurroundingText(const Selection& rSelection) override;
 717     void SetUITestFactory(FactoryFunction pFactoryFunction, void* pUserData)
 718     {
 719         m_pFactoryFunction = pFactoryFunction;
 720         m_pUserData = pUserData;
 721     }
 722     void* GetUserData() const
 723     {
 724         return m_pUserData;
 725     }
 726     void SetPaintHdl(const Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void>& rLink)
 727     {
 728         m_aPaintHdl = rLink;
 729     }
 730     void SetResizeHdl(const Link<const Size&, void>& rLink)
 731     {
 732         m_aResizeHdl = rLink;
 733     }
 734     void SetMousePressHdl(const Link<const MouseEvent&, bool>& rLink)
 735     {
 736         m_aMousePressHdl = rLink;
 737     }
 738     void SetMouseMoveHdl(const Link<const MouseEvent&, bool>& rLink)
 739     {
 740         m_aMouseMotionHdl = rLink;
 741     }
 742     void SetMouseReleaseHdl(const Link<const MouseEvent&, bool>& rLink)
 743     {
 744         m_aMouseReleaseHdl = rLink;
 745     }
 746     void SetKeyPressHdl(const Link<const KeyEvent&, bool>& rLink)
 747     {
 748         m_aKeyPressHdl = rLink;
 749     }
 750     void SetKeyReleaseHdl(const Link<const KeyEvent&, bool>& rLink)
 751     {
 752         m_aKeyReleaseHdl = rLink;
 753     }
 754     void SetStyleUpdatedHdl(const Link<VclDrawingArea&, void>& rLink)
 755     {
 756         m_aStyleUpdatedHdl = rLink;
 757     }
 758     void SetCommandHdl(const Link<const CommandEvent&, bool>& rLink)
 759     {
 760         m_aCommandHdl = rLink;
 761     }
 762     void SetQueryTooltipHdl(const Link<tools::Rectangle&, OUString>& rLink)
 763     {
 764         m_aQueryTooltipHdl = rLink;
 765     }
 766     void SetGetSurroundingHdl(const Link<OUString&, int>& rLink)
 767     {
 768         m_aGetSurroundingHdl = rLink;
 769     }
 770     void SetDeleteSurroundingHdl(const Link<const Selection&, bool>& rLink)
 771     {
 772         m_aDeleteSurroundingHdl = rLink;
 773     }
 774     void SetStartDragHdl(const Link<VclDrawingArea*, bool>& rLink)
 775     {
 776         m_aStartDragHdl = rLink;
 777     }
 778     void SetDragHelper(const rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants)
 779     {
 780         m_xTransferHelper = rHelper;
 781         m_nDragAction = eDNDConstants;
 782     }
 783     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 784 };
 785
 786 //Get first window of a pTopLevel window as
 787 //if any intermediate layout widgets didn't exist
 788 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::FirstChild);
 789 //in a flat hierarchy where dialogs only have one layer
 790 //of children
 791 vcl::Window* firstLogicalChildOfParent(const vcl::Window *pTopLevel);
 792
 793 //Get last window of a pTopLevel window as
 794 //if any intermediate layout widgets didn't exist
 795 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::LastChild);
 796 //in a flat hierarchy where dialogs only have one layer
 797 //of children
 798 vcl::Window* lastLogicalChildOfParent(const vcl::Window *pTopLevel);
 799
 800 //Get next window after pChild of a pTopLevel window as
 801 //if any intermediate layout widgets didn't exist
 802 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::Next);
 803 //in a flat hierarchy where dialogs only have one layer
 804 //of children
 805 vcl::Window* nextLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
 806
 807 //Get previous window before pChild of a pTopLevel window as
 808 //if any intermediate layout widgets didn't exist
 809 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::Prev);
 810 //in a flat hierarchy where dialogs only have one layer
 811 //of children
 812 vcl::Window* prevLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
 813
 814 //Returns true is the Window has a single child which is a container
 815 VCL_DLLPUBLIC bool isLayoutEnabled(const vcl::Window *pWindow);
 816
 817 inline bool isContainerWindow(const vcl::Window &rWindow)
 818 {
 819     WindowType eType = rWindow.GetType();
 820     return eType == WindowType::CONTAINER || eType == WindowType::SCROLLWINDOW ||
 821            (eType == WindowType::DOCKINGWINDOW && ::isLayoutEnabled(&rWindow));
 822 }
 823
 824 inline bool isContainerWindow(const vcl::Window *pWindow)
 825 {
 826     return pWindow && isContainerWindow(*pWindow);
 827 }
 828
 829 // retro-fitting utilities
 830
 831 //Get a Size which is large enough to contain all children with
 832 //an equal amount of space at top left and bottom right
 833 Size getLegacyBestSizeForChildren(const vcl::Window &rWindow);
 834
 835 //Get first parent which is not a layout widget
 836 vcl::Window* getNonLayoutParent(vcl::Window *pParent);
 837
 838 //Sort ok/cancel etc buttons in platform order
 839 void sort_native_button_order(const VclBox& rContainer);
 840
 841 #endif
 842
 843 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */