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