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