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/help.hxx>
  17 #include <vcl/svapp.hxx>
  18 #include <vcl/window.hxx>
  19 #include <vcl/settings.hxx>
  20 #include <vcl/event.hxx>
  21 #include <vcl/transfer.hxx>
  22 #include <vcl/vclptr.hxx>
  23 #include <vcl/IContext.hxx>
  24 #include <vcl/commandevent.hxx>
  25 #include <set>
  26
  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 OString &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 OString &rKey, const OUString &rValue) override;
 217 protected:
 218     virtual Size calculateRequisition() const override;
 219     virtual void setAllocation(const Size &rAllocation) override;
 220     Size addSpacing(const Size &rSize, sal_uInt16 nVisibleChildren) const;
 221 private:
 222     VclButtonBoxStyle m_eLayoutStyle;
 223     struct Requisition
 224     {
 225         std::vector<tools::Long> m_aMainGroupDimensions;
 226         std::vector<tools::Long> m_aSubGroupDimensions;
 227         Size m_aMainGroupSize;
 228         Size m_aSubGroupSize;
 229     };
 230     Requisition calculatePrimarySecondaryRequisitions() const;
 231     Size addReqGroups(const VclButtonBox::Requisition &rReq) const;
 232 };
 233
 234 class VCL_DLLPUBLIC VclVButtonBox : public VclButtonBox
 235 {
 236 public:
 237     VclVButtonBox(vcl::Window *pParent)
 238         : VclButtonBox(pParent)
 239     {
 240         m_bVerticalContainer = true;
 241     }
 242 protected:
 243     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 244     {
 245         return rSize.getHeight();
 246     }
 247     virtual void setPrimaryDimension(Size &rSize, tools::Long nHeight) const override
 248     {
 249         rSize.setHeight(nHeight);
 250     }
 251     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 252     {
 253         return rPos.getY();
 254     }
 255     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 256     {
 257         rPos.setY(nPos);
 258     }
 259     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 260     {
 261         return rSize.getWidth();
 262     }
 263     virtual void setSecondaryDimension(Size &rSize, tools::Long nWidth) const override
 264     {
 265         rSize.setWidth(nWidth);
 266     }
 267     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 268     {
 269         return rWindow.get_expand() || rWindow.get_vexpand();
 270     }
 271 };
 272
 273 class VCL_DLLPUBLIC VclHButtonBox final : public VclButtonBox
 274 {
 275 public:
 276     VclHButtonBox(vcl::Window *pParent)
 277         : VclButtonBox(pParent)
 278     {
 279         m_bVerticalContainer = false;
 280     }
 281 private:
 282     virtual tools::Long getPrimaryDimension(const Size &rSize) const override
 283     {
 284         return rSize.getWidth();
 285     }
 286     virtual void setPrimaryDimension(Size &rSize, tools::Long nWidth) const override
 287     {
 288         rSize.setWidth(nWidth);
 289     }
 290     virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override
 291     {
 292         return rPos.getX();
 293     }
 294     virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override
 295     {
 296         rPos.setX(nPos);
 297     }
 298     virtual tools::Long getSecondaryDimension(const Size &rSize) const override
 299     {
 300         return rSize.getHeight();
 301     }
 302     virtual void setSecondaryDimension(Size &rSize, tools::Long nHeight) const override
 303     {
 304         rSize.setHeight(nHeight);
 305     }
 306     virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override
 307     {
 308         return rWindow.get_expand() || rWindow.get_hexpand();
 309     }
 310 };
 311
 312 class VCL_DLLPUBLIC VclGrid final : public VclContainer
 313 {
 314 private:
 315     bool m_bRowHomogeneous;
 316     bool m_bColumnHomogeneous;
 317     int m_nRowSpacing;
 318     int m_nColumnSpacing;
 319
 320 public:
 321     struct Value
 322     {
 323         tools::Long m_nValue;
 324         bool m_bExpand;
 325         Value() : m_nValue(0), m_bExpand(false) {}
 326     };
 327 private:
 328
 329     Size calculateRequisitionForSpacings(sal_Int32 nRowSpacing, sal_Int32 nColSpacing) const;
 330     virtual Size calculateRequisition() const override;
 331     virtual void setAllocation(const Size &rAllocation) override;
 332     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 333 public:
 334     VclGrid(vcl::Window *pParent)
 335         : VclContainer(pParent)
 336         , m_bRowHomogeneous(false), m_bColumnHomogeneous(false)
 337         , m_nRowSpacing(0), m_nColumnSpacing(0)
 338     {
 339     }
 340     bool get_row_homogeneous() const
 341     {
 342         return m_bRowHomogeneous;
 343     }
 344     bool get_column_homogeneous() const
 345     {
 346         return m_bColumnHomogeneous;
 347     }
 348     void set_row_spacing(int nSpacing)
 349     {
 350         m_nRowSpacing = nSpacing;
 351     }
 352     void set_column_spacing(int nSpacing)
 353     {
 354         m_nColumnSpacing = nSpacing;
 355     }
 356     int get_row_spacing() const
 357     {
 358         return m_nRowSpacing;
 359     }
 360     int get_column_spacing() const
 361     {
 362         return m_nColumnSpacing;
 363     }
 364     virtual bool set_property(const OString &rKey, const OUString &rValue) override;
 365 };
 366
 367 class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclBin : public VclContainer
 368 {
 369 public:
 370     VclBin(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN)
 371         : VclContainer(pParent, nStyle)
 372     {
 373     }
 374     virtual vcl::Window *get_child();
 375     virtual const vcl::Window *get_child() const;
 376     virtual Size calculateRequisition() const override;
 377     virtual void setAllocation(const Size &rAllocation) override;
 378 };
 379
 380 class VclPaned : public VclContainer
 381 {
 382 protected:
 383     VclPtr<Splitter> m_pSplitter;
 384     tools::Long m_nPosition;
 385
 386     VclPaned(vcl::Window *pParent, bool bVertical);
 387 public:
 388     virtual ~VclPaned() override;
 389     virtual void dispose() override;
 390     tools::Long get_position() const { return m_nPosition; }
 391     virtual void set_position(tools::Long nPosition) { m_nPosition = nPosition; }
 392 };
 393
 394 class VclVPaned final : public VclPaned
 395 {
 396 private:
 397     DECL_LINK(SplitHdl, Splitter*, void);
 398     void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight);
 399
 400 public:
 401     VclVPaned(vcl::Window *pParent);
 402     virtual ~VclVPaned() override;
 403     virtual Size calculateRequisition() const override;
 404     virtual void setAllocation(const Size &rAllocation) override;
 405     virtual void set_position(tools::Long nPosition) override;
 406 };
 407
 408 class VclHPaned final : public VclPaned
 409 {
 410 private:
 411     DECL_LINK(SplitHdl, Splitter*, void);
 412     void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight);
 413
 414 public:
 415     VclHPaned(vcl::Window *pParent);
 416     virtual ~VclHPaned() override;
 417     virtual Size calculateRequisition() const override;
 418     virtual void setAllocation(const Size &rAllocation) override;
 419     virtual void set_position(tools::Long nPosition) override;
 420 };
 421
 422 class VclFrame final : public VclBin
 423 {
 424 private:
 425     VclPtr<vcl::Window> m_pLabel;
 426 private:
 427     friend class VclBuilder;
 428     void designate_label(vcl::Window *pWindow);
 429     DECL_LINK(WindowEventListener, VclWindowEvent&, void);
 430 public:
 431     VclFrame(vcl::Window *pParent)
 432         : VclBin(pParent)
 433         , m_pLabel(nullptr)
 434     {
 435     }
 436     virtual ~VclFrame() override;
 437     virtual void dispose() override;
 438     void set_label(const OUString &rLabel);
 439     OUString get_label() const;
 440     virtual vcl::Window *get_child() override;
 441     virtual const vcl::Window *get_child() const override;
 442     vcl::Window *get_label_widget();
 443     const vcl::Window *get_label_widget() const;
 444     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 445 private:
 446     virtual Size calculateRequisition() const override;
 447     virtual void setAllocation(const Size &rAllocation) override;
 448     virtual OUString getDefaultAccessibleName() const override;
 449 };
 450
 451 class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclAlignment final : public VclBin
 452 {
 453 public:
 454     VclAlignment(vcl::Window *pParent)
 455         : VclBin(pParent)
 456         , m_nBottomPadding(0)
 457         , m_nLeftPadding(0)
 458         , m_nRightPadding(0)
 459         , m_nTopPadding(0)
 460     {
 461     }
 462     virtual bool set_property(const OString &rKey, const OUString &rValue) override;
 463 private:
 464     virtual Size calculateRequisition() const override;
 465     virtual void setAllocation(const Size &rAllocation) override;
 466     sal_Int32 m_nBottomPadding;
 467     sal_Int32 m_nLeftPadding;
 468     sal_Int32 m_nRightPadding;
 469     sal_Int32 m_nTopPadding;
 470 };
 471
 472 class DisclosureButton;
 473 class CheckBox;
 474
 475 class VclExpander final : public VclBin
 476 {
 477 public:
 478     VclExpander(vcl::Window *pParent);
 479     virtual ~VclExpander() override;
 480     virtual void dispose() override;
 481     virtual vcl::Window *get_child() override;
 482     virtual const vcl::Window *get_child() const override;
 483     virtual bool set_property(const OString &rKey, const OUString &rValue) override;
 484     bool get_expanded() const;
 485     void set_expanded(bool bExpanded);
 486     void set_label(const OUString& rLabel);
 487     OUString get_label() const;
 488     vcl::Window *get_label_widget();
 489     const vcl::Window *get_label_widget() const;
 490     virtual void StateChanged(StateChangedType nType) override;
 491     void  SetExpandedHdl( const Link<VclExpander&,void>& rLink ) { maExpandedHdl = rLink; }
 492 private:
 493     virtual Size calculateRequisition() const override;
 494     virtual void setAllocation(const Size &rAllocation) override;
 495     bool m_bResizeTopLevel;
 496     VclPtr<DisclosureButton> m_pDisclosureButton;
 497     Link<VclExpander&,void> maExpandedHdl;
 498     DECL_LINK(ClickHdl, CheckBox&, void);
 499 };
 500
 501 class VCL_DLLPUBLIC VclScrolledWindow final : public VclBin
 502 {
 503 public:
 504     VclScrolledWindow(vcl::Window *pParent );
 505     virtual ~VclScrolledWindow() override;
 506     virtual void dispose() override;
 507     virtual vcl::Window *get_child() override;
 508     virtual const vcl::Window *get_child() const override;
 509     virtual bool set_property(const OString &rKey, const OUString &rValue) override;
 510     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
 511     bool HasVisibleBorder() const { return m_eDrawFrameStyle != DrawFrameStyle::NONE; }
 512     ScrollBar& getVertScrollBar() { return *m_pVScroll; }
 513     ScrollBar& getHorzScrollBar() { return *m_pHScroll; }
 514     Size getVisibleChildSize() const;
 515     //set to true to disable the built-in scrolling callbacks to allow the user
 516     //to override it
 517     void setUserManagedScrolling(bool bUserManagedScrolling) { m_bUserManagedScrolling = bUserManagedScrolling;}
 518     void doSetAllocation(const Size &rAllocation, bool bRetryOnFailure);
 519 private:
 520     virtual Size calculateRequisition() const override;
 521     virtual void setAllocation(const Size &rAllocation) override;
 522     // sets new border size and adapts scrollbar and child widget position/size as needed
 523     void updateBorderWidth(tools::Long nBorderWidth);
 524     DECL_LINK(ScrollBarHdl, ScrollBar*, void);
 525     void InitScrollBars(const Size &rRequest);
 526     virtual bool EventNotify(NotifyEvent& rNEvt) override;
 527     bool m_bUserManagedScrolling;
 528     tools::Long m_nBorderWidth;
 529     DrawFrameStyle m_eDrawFrameStyle;
 530     DrawFrameFlags m_eDrawFrameFlags;
 531     VclPtr<ScrollBar> m_pVScroll;
 532     VclPtr<ScrollBar> m_pHScroll;
 533     VclPtr<ScrollBarBox> m_aScrollBarBox;
 534 };
 535
 536 class VclViewport final : public VclBin
 537 {
 538 public:
 539     VclViewport(vcl::Window *pParent)
 540         : VclBin(pParent, WB_HIDE | WB_CLIPCHILDREN)
 541         , m_bInitialAllocation(true)
 542     {
 543     }
 544 private:
 545     virtual void setAllocation(const Size &rAllocation) override;
 546     bool m_bInitialAllocation;
 547 };
 548
 549 //Enforces that its children are always the same size as itself.
 550 //Intercepts any Commands intended for its children.
 551 //
 552 //by default the Commands are discarded, inherit from this
 553 //and implement "Command" to get them
 554 class VclEventBox final : public VclBin
 555 {
 556 private:
 557     //Any Commands an EventBoxHelper receives are forwarded to its parent
 558     //The VclEventBox ensures that m_aEventBoxHelper is the
 559     //first child and is transparent, but covers the rest of the children
 560     class EventBoxHelper : public vcl::Window
 561     {
 562     public:
 563         EventBoxHelper(vcl::Window* pParent)
 564             : Window(pParent, 0)
 565         {
 566             SetSizePixel(pParent->GetSizePixel());
 567             EnableChildTransparentMode();
 568             SetPaintTransparent(true);
 569             SetBackground();
 570         }
 571         virtual void Command(const CommandEvent& rCEvt) override
 572         {
 573             GetParent()->Command(rCEvt);
 574         }
 575     };
 576
 577     VclPtr<EventBoxHelper> m_aEventBoxHelper;
 578     virtual void dispose() override;
 579     virtual ~VclEventBox() override;
 580 public:
 581     VclEventBox(vcl::Window* pParent)
 582         : VclBin(pParent)
 583         , m_aEventBoxHelper(VclPtr<EventBoxHelper>::Create(this))
 584     {
 585         m_aEventBoxHelper->Show();
 586     }
 587     virtual vcl::Window *get_child() override;
 588     virtual const vcl::Window *get_child() const override;
 589     virtual Size calculateRequisition() const override;
 590     virtual void setAllocation(const Size &rAllocation) override;
 591
 592     virtual void Command(const CommandEvent& rCEvt) override;
 593 };
 594
 595 class VclSizeGroup
 596 {
 597 private:
 598     std::set< VclPtr<vcl::Window> > m_aWindows;
 599     bool m_bIgnoreHidden;
 600     VclSizeGroupMode m_eMode;
 601
 602     void trigger_queue_resize();
 603 public:
 604     VclSizeGroup()
 605         : m_bIgnoreHidden(false)
 606         , m_eMode(VclSizeGroupMode::Horizontal)
 607     {
 608     }
 609     void insert(vcl::Window *pWindow)
 610     {
 611         m_aWindows.insert(VclPtr<vcl::Window>(pWindow));
 612     }
 613     void erase(vcl::Window *pWindow)
 614     {
 615         m_aWindows.erase(VclPtr<vcl::Window>(pWindow));
 616     }
 617     const std::set< VclPtr<vcl::Window> >& get_widgets() const
 618     {
 619         return m_aWindows;
 620     }
 621     std::set< VclPtr<vcl::Window> >& get_widgets()
 622     {
 623         return m_aWindows;
 624     }
 625     void set_ignore_hidden(bool bIgnoreHidden);
 626     bool get_ignore_hidden() const
 627     {
 628         return m_bIgnoreHidden;
 629     }
 630     void set_mode(VclSizeGroupMode eMode);
 631     VclSizeGroupMode get_mode() const
 632     {
 633         return m_eMode;
 634     }
 635     void set_property(const OString &rKey, const OUString &rValue);
 636 };
 637
 638 class VCL_DLLPUBLIC VclDrawingArea final : public Control
 639                                          , public DragSourceHelper
 640 {
 641 private:
 642     FactoryFunction m_pFactoryFunction;
 643     void* m_pUserData;
 644     rtl::Reference<TransferDataContainer> m_xTransferHelper;
 645     sal_Int8 m_nDragAction;
 646     Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void> m_aPaintHdl;
 647     Link<const Size&, void> m_aResizeHdl;
 648     Link<const MouseEvent&, bool> m_aMousePressHdl;
 649     Link<const MouseEvent&, bool> m_aMouseMotionHdl;
 650     Link<const MouseEvent&, bool> m_aMouseReleaseHdl;
 651     Link<const KeyEvent&, bool> m_aKeyPressHdl;
 652     Link<const KeyEvent&, bool> m_aKeyReleaseHdl;
 653     Link<VclDrawingArea&, void> m_aStyleUpdatedHdl;
 654     Link<const CommandEvent&, bool> m_aCommandHdl;
 655     Link<tools::Rectangle&, OUString> m_aQueryTooltipHdl;
 656     Link<OUString&, int> m_aGetSurroundingHdl;
 657     Link<const Selection&, bool> m_aDeleteSurroundingHdl;
 658     Link<VclDrawingArea*, bool> m_aStartDragHdl;
 659
 660     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override
 661     {
 662         m_aPaintHdl.Call(std::pair<vcl::RenderContext&, const tools::Rectangle&>(rRenderContext, rRect));
 663     }
 664     virtual void Resize() override
 665     {
 666         m_aResizeHdl.Call(GetOutputSizePixel());
 667     }
 668     virtual void MouseMove(const MouseEvent& rMEvt) override
 669     {
 670         if (!m_aMouseMotionHdl.Call(rMEvt))
 671             Control::MouseMove(rMEvt);
 672     }
 673     virtual void KeyInput(const KeyEvent& rKEvt) override
 674     {
 675         if (!m_aKeyPressHdl.Call(rKEvt))
 676             Control::KeyInput(rKEvt);
 677
 678     }
 679     virtual void KeyUp(const KeyEvent& rKEvt) override
 680     {
 681         if (!m_aKeyReleaseHdl.Call(rKEvt))
 682             Control::KeyUp(rKEvt);
 683     }
 684     virtual void StateChanged(StateChangedType nType) override
 685     {
 686         Control::StateChanged(nType);
 687         if (nType == StateChangedType::ControlForeground || nType == StateChangedType::ControlBackground)
 688         {
 689             m_aStyleUpdatedHdl.Call(*this);
 690             Invalidate();
 691         }
 692     }
 693     virtual void DataChanged(const DataChangedEvent& rDCEvt) override
 694     {
 695         Control::DataChanged(rDCEvt);
 696         if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
 697         {
 698             m_aStyleUpdatedHdl.Call(*this);
 699             Invalidate();
 700         }
 701     }
 702     virtual void Command(const CommandEvent& rEvent) override
 703     {
 704         if (m_aCommandHdl.Call(rEvent))
 705             return;
 706         Control::Command(rEvent);
 707     }
 708     virtual void RequestHelp(const HelpEvent& rHelpEvent) override
 709     {
 710         if (rHelpEvent.GetMode() & (HelpEventMode::QUICK | HelpEventMode::BALLOON))
 711         {
 712             Point aPos(ScreenToOutputPixel(rHelpEvent.GetMousePosPixel()));
 713             tools::Rectangle aHelpArea(aPos.X(), aPos.Y());
 714             OUString sHelpTip = m_aQueryTooltipHdl.Call(aHelpArea);
 715             if (sHelpTip.isEmpty())
 716                 return;
 717             Point aPt = OutputToScreenPixel(aHelpArea.TopLeft());
 718             aHelpArea.SetLeft(aPt.X());
 719             aHelpArea.SetTop(aPt.Y());
 720             aPt = OutputToScreenPixel(aHelpArea.BottomRight());
 721             aHelpArea.SetRight(aPt.X());
 722             aHelpArea.SetBottom(aPt.Y());
 723             // tdf#125369 recover newline support of tdf#101779
 724             QuickHelpFlags eHelpWinStyle = sHelpTip.indexOf('\n') != -1 ? QuickHelpFlags::TipStyleBalloon : QuickHelpFlags::NONE;
 725             Help::ShowQuickHelp(this, aHelpArea, sHelpTip, eHelpWinStyle);
 726         }
 727     }
 728     virtual void StartDrag(sal_Int8 nAction, const Point& rPosPixel) override;
 729     virtual FactoryFunction GetUITestFactory() const override
 730     {
 731         if (m_pFactoryFunction)
 732             return m_pFactoryFunction;
 733         return Control::GetUITestFactory();
 734     }
 735
 736 public:
 737     VclDrawingArea(vcl::Window *pParent, WinBits nStyle)
 738         : Control(pParent, nStyle)
 739         , DragSourceHelper(this)
 740         , m_pFactoryFunction(nullptr)
 741         , m_pUserData(nullptr)
 742         , m_nDragAction(0)
 743     {
 744         SetBackground();
 745     }
 746     virtual void MouseButtonDown(const MouseEvent& rMEvt) override
 747     {
 748         if (!m_aMousePressHdl.Call(rMEvt))
 749             Control::MouseButtonDown(rMEvt);
 750     }
 751     virtual void MouseButtonUp(const MouseEvent& rMEvt) override
 752     {
 753         if (!m_aMouseReleaseHdl.Call(rMEvt))
 754             Control::MouseButtonUp(rMEvt);
 755     }
 756     virtual OUString GetSurroundingText() const override;
 757     virtual Selection GetSurroundingTextSelection() const override;
 758     virtual bool DeleteSurroundingText(const Selection& rSelection) override;
 759     void SetUITestFactory(FactoryFunction pFactoryFunction, void* pUserData)
 760     {
 761         m_pFactoryFunction = pFactoryFunction;
 762         m_pUserData = pUserData;
 763     }
 764     void* GetUserData() const
 765     {
 766         return m_pUserData;
 767     }
 768     void SetPaintHdl(const Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void>& rLink)
 769     {
 770         m_aPaintHdl = rLink;
 771     }
 772     void SetResizeHdl(const Link<const Size&, void>& rLink)
 773     {
 774         m_aResizeHdl = rLink;
 775     }
 776     void SetMousePressHdl(const Link<const MouseEvent&, bool>& rLink)
 777     {
 778         m_aMousePressHdl = rLink;
 779     }
 780     void SetMouseMoveHdl(const Link<const MouseEvent&, bool>& rLink)
 781     {
 782         m_aMouseMotionHdl = rLink;
 783     }
 784     void SetMouseReleaseHdl(const Link<const MouseEvent&, bool>& rLink)
 785     {
 786         m_aMouseReleaseHdl = rLink;
 787     }
 788     void SetKeyPressHdl(const Link<const KeyEvent&, bool>& rLink)
 789     {
 790         m_aKeyPressHdl = rLink;
 791     }
 792     void SetKeyReleaseHdl(const Link<const KeyEvent&, bool>& rLink)
 793     {
 794         m_aKeyReleaseHdl = rLink;
 795     }
 796     void SetStyleUpdatedHdl(const Link<VclDrawingArea&, void>& rLink)
 797     {
 798         m_aStyleUpdatedHdl = rLink;
 799     }
 800     void SetCommandHdl(const Link<const CommandEvent&, bool>& rLink)
 801     {
 802         m_aCommandHdl = rLink;
 803     }
 804     void SetQueryTooltipHdl(const Link<tools::Rectangle&, OUString>& rLink)
 805     {
 806         m_aQueryTooltipHdl = rLink;
 807     }
 808     void SetGetSurroundingHdl(const Link<OUString&, int>& rLink)
 809     {
 810         m_aGetSurroundingHdl = rLink;
 811     }
 812     void SetDeleteSurroundingHdl(const Link<const Selection&, bool>& rLink)
 813     {
 814         m_aDeleteSurroundingHdl = rLink;
 815     }
 816     void SetStartDragHdl(const Link<VclDrawingArea*, bool>& rLink)
 817     {
 818         m_aStartDragHdl = rLink;
 819     }
 820     void SetDragHelper(const rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants)
 821     {
 822         m_xTransferHelper = rHelper;
 823         m_nDragAction = eDNDConstants;
 824     }
 825     virtual void DumpAsPropertyTree(tools::JsonWriter&) override;
 826 };
 827
 828 //Get first window of a pTopLevel window as
 829 //if any intermediate layout widgets didn't exist
 830 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::FirstChild);
 831 //in a flat hierarchy where dialogs only have one layer
 832 //of children
 833 vcl::Window* firstLogicalChildOfParent(const vcl::Window *pTopLevel);
 834
 835 //Get last window of a pTopLevel window as
 836 //if any intermediate layout widgets didn't exist
 837 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::LastChild);
 838 //in a flat hierarchy where dialogs only have one layer
 839 //of children
 840 vcl::Window* lastLogicalChildOfParent(const vcl::Window *pTopLevel);
 841
 842 //Get next window after pChild of a pTopLevel window as
 843 //if any intermediate layout widgets didn't exist
 844 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::Next);
 845 //in a flat hierarchy where dialogs only have one layer
 846 //of children
 847 vcl::Window* nextLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
 848
 849 //Get previous window before pChild of a pTopLevel window as
 850 //if any intermediate layout widgets didn't exist
 851 //i.e. acts like pChild = pChild->GetWindow(GetWindowType::Prev);
 852 //in a flat hierarchy where dialogs only have one layer
 853 //of children
 854 vcl::Window* prevLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild);
 855
 856 //Returns true is the Window has a single child which is a container
 857 VCL_DLLPUBLIC bool isLayoutEnabled(const vcl::Window *pWindow);
 858
 859 inline bool isContainerWindow(const vcl::Window &rWindow)
 860 {
 861     WindowType eType = rWindow.GetType();
 862     return eType == WindowType::CONTAINER || eType == WindowType::SCROLLWINDOW ||
 863            (eType == WindowType::DOCKINGWINDOW && ::isLayoutEnabled(&rWindow));
 864 }
 865
 866 inline bool isContainerWindow(const vcl::Window *pWindow)
 867 {
 868     return pWindow && isContainerWindow(*pWindow);
 869 }
 870
 871 // retro-fitting utilities
 872
 873 //Get a Size which is large enough to contain all children with
 874 //an equal amount of space at top left and bottom right
 875 Size getLegacyBestSizeForChildren(const vcl::Window &rWindow);
 876
 877 //Get first parent which is not a layout widget
 878 vcl::Window* getNonLayoutParent(vcl::Window *pParent);
 879
 880 //Sort ok/cancel etc buttons in platform order
 881 void sort_native_button_order(const VclBox& rContainer);
 882
 883 #endif
 884
 885 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */