QSizePolicy - A layout attribute describing horizontal and
       vertical resizing

       #include <qsizepolicy.h>

   Public Members
       enum SizeType { Fixed = 0, Minimum = MayGrow, Maximum =
           MayShrink, Preferred = MayGrow|MayShrink,
           MinimumExpanding = Minimum|ExpMask, Expanding =
           MinimumExpanding|MayShrink }
       enum ExpandData { NoDirection = 0, Horizontal = 1,
           Vertical = 2, BothDirections = Horizontal | Vertical }
       QSizePolicy ()
       QSizePolicy ( SizeType hor, SizeType ver, bool hfw = FALSE
           )
       SizeType horData () const
       SizeType verData () const
       bool mayShrinkHorizontally () const
       bool mayShrinkVertically () const
       bool mayGrowHorizontally () const
       bool mayGrowVertically () const
       ExpandData expanding () const
       void setHorData ( SizeType d )
       void setVerData ( SizeType d )
       void setHeightForWidth ( bool b )
       bool hasHeightForWidth () const
       bool operator== ( const QSizePolicy & s ) const
       bool operator!= ( const QSizePolicy & s ) const


DESCRIPTION

       A layout attribute describing horizontal and vertical
       resizing.

       The size policy of a widget is an expression of its
       willingness to be resized in various ways.

       Widgets which reimplement QWidget::sizePolicy() return a
       QSizePolicy describing the horizontal and vertical
       resizing policy best used when laying out the widget. Only
       one of the constructors is of interest in most
       applications.

       QSizePolicy contains two independent SizeType objects, one
       which describes the widgets's horizontal size policy and
       one which describes its vertical size policy, and it
       contains a flag to indicate whether the height and width
       of its preferred size are related.

       The per-dimension SizeType objects are set in the usual
       constructor, and can be queried using a variety of
       functions, none of which are really interesting to
       application programmers.

       widget's sizeHint() is width-dependent (like a word-
       wrapping label).

       See also QSizePolicy::SizeType.

       Examples: xform/xform.cpp

   Member Type Documentation

QSizePolicy::ExpandData

       This enum type describes in which directions a widget can
       make use of extra space. There are four possible values:

       NoDirection - the widget cannot make us of extra space in
              any direction.

       Horizontal - the widget can usefully be wider than
              sizeHint() says.

       Vertical - the widget can usefully be taller than
              sizeHint() says.

       BothDirections - the widget can usefully be both wider and
              taller than sizeHint() says.


QSizePolicy::SizeType

       The per-dimension sizing types used when constructing a
       QSizePolicy are:

       Fixed - the sizeHint() is the only acceptable alternative,
              so widget can never grow or shrink (eg. the
              vertical direction of a pushbutton).

       Minimum - the sizeHint() is minimal, and sufficient. The
              widget can be expanded, but there is no advantage
              to it being larger (eg. the horizontal direction of
              a pushbutton).

       Maximum - the sizeHint() is a maximum. The widget can be
              shrunk any amount without detriment if other
              widgets need the space (eg. a separator line).

       Preferred - the sizeHint() is best, but the widget can be
              shrunk below that and still be useful. The widget
              can be expanded, but there is no advantage to it
              being larger than sizeHint() (the default QWidget
              policy).

       MinimumExpanding - the sizeHint() is a minimum. The widget
              can make use of extra space, so it should get as
              much space as possible (not currently used by any
              standard Qt widgets).

              widget can be shrunk below that and still be
              useful. The widget can make use of extra space, so
              it should get as much space as possible (eg. the
              horizontal direction of a slider).


MEMBER FUNCTION DOCUMENTATION


QSizePolicy::QSizePolicy ()

       Default constructor, produces a minimally initialized
       QSizePolicy.


QSizePolicy::QSizePolicy ( SizeType hor, SizeType ver, bool hfw =

       FALSE )
       This is the constructor normally used to return a value in
       the overridden QWidget::sizePolicy() function of a QWidget
       subclass.

       It constructs a QSizePolicy with independent horizontal
       and vertical sizing types, hor and ver respectively. These
       sizing types affect how the widget is treated by the
       layout engine.

       If hfw is TRUE, the preferred height of the widget is
       dependent on the width of the widget (for example, a
       QLabel with automatic word-breaking).


QSizePolicy::ExpandData QSizePolicy::expanding() const

       Returns a value indicating if the widget can make use of
       extra space (ie. if it "wants" to grow) horizontally
       and/or vertically.


bool QSizePolicy::hasHeightForWidth () const

       Returns TRUE if the widget's preferred height depends on
       its width.


QSizePolicy::SizeType QSizePolicy::horData() const

       Returns the horizontal component of the size policy.


bool QSizePolicy::mayGrowHorizontally () const

       Returns TRUE if the widget can sensibly be wider than its
       sizeHint().


bool QSizePolicy::mayGrowVertically () const

       Returns TRUE if the widget can sensibly be taller than its
       sizeHint().


bool QSizePolicy::mayShrinkHorizontally () const

       Returns TRUE if the widget can sensibly be narrower than
       its sizeHint().


bool QSizePolicy::mayShrinkVertically () const

       Returns TRUE if the widget can sensibly be lower than its
       sizeHint().

       Sets the hasHeightForWidth() flag to b.


void QSizePolicy::setHorData ( SizeType d )

       Sets the horizontal component of the size policy to d.


void QSizePolicy::setVerData ( SizeType d )

       Sets the vertical component of the size policy to d.


QSizePolicy::SizeType QSizePolicy::verData() const

       Returns the vertical component of the size policy.


SEE ALSO

       http://doc.trolltech.com/qsizepolicy.html
       http://www.trolltech.com/faq/tech.html


COPYRIGHT

       Copyright 1992-2001 Trolltech AS,
       http://www.trolltech.com.  See the license file included
       in the distribution for a complete license statement.


AUTHOR

       Generated automatically from the source code.


BUGS

       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.  Good bug reports
       make our job much simpler. Thank you.

       In case of content or formattting problems with this
       manual page, please report them to qt-bugs@trolltech.com.
       Please include the name of the manual page
       (qsizepolicy.3qt) and the Qt version (2.3.1).


Man(1) output converted with man2html