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