You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2109 lines
53 KiB
2109 lines
53 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of the abstract tqlayout base class
|
|
**
|
|
** Created : 960416
|
|
**
|
|
** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
|
|
**
|
|
** This file is part of the kernel module of the TQt GUI Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
** Alternatively you may (at your option) use any later version
|
|
** of the GNU General Public License if such license has been
|
|
** publicly approved by Trolltech ASA (or its successors, if any)
|
|
** and the KDE Free TQt Foundation.
|
|
**
|
|
** Please review the following information to ensure GNU General
|
|
** Public Licensing requirements will be met:
|
|
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
|
|
** If you are unsure which license is appropriate for your use, please
|
|
** review the following information:
|
|
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
|
|
** or contact the sales department at sales@trolltech.com.
|
|
**
|
|
** This file may be used under the terms of the Q Public License as
|
|
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
|
|
** included in the packaging of this file. Licensees holding valid TQt
|
|
** Commercial licenses may use this file in accordance with the TQt
|
|
** Commercial License Agreement provided with the Software.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "tqlayout.h"
|
|
|
|
#ifndef TQT_NO_LAYOUT
|
|
#include "tqapplication.h"
|
|
#include "tqlayoutengine_p.h"
|
|
#include "tqmenubar.h"
|
|
#include "tqtoolbar.h"
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Sets the value returned by supportsMargin(). If \a b is TRUE,
|
|
margin() handling is implemented by the subclass. If \a b is
|
|
FALSE (the default), TQLayout will add margin() around top-level
|
|
layouts.
|
|
|
|
If \a b is TRUE, margin handling needs to be implemented in
|
|
setGeometry(), tqmaximumSize(), tqminimumSize(), tqsizeHint() and
|
|
heightForWidth().
|
|
|
|
\sa supportsMargin()
|
|
*/
|
|
void TQLayout::setSupportsMargin( bool b )
|
|
{
|
|
printf("[FIXME] void TQLayout::setSupportsMargin( bool b ) unimplemented!\n\r");
|
|
}
|
|
|
|
/*!
|
|
Removes and deletes all items in this tqlayout.
|
|
*/
|
|
void TQLayout::deleteAllItems()
|
|
{
|
|
TQLayoutIterator it = iterator();
|
|
TQLayoutItem *l;
|
|
while ( (l = it.takeCurrent()) )
|
|
delete l;
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
static int menuBarHeightForWidth( TQMenuBar *menubar, int w )
|
|
{
|
|
#ifndef TQT_NO_MENUBAR
|
|
if ( menubar && !menubar->isHidden() && !menubar->isTopLevel() )
|
|
return menubar->heightForWidth( TQMAX(w, menubar->minimumWidth()) );
|
|
else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
\class TQLayoutItem
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
\brief The TQLayoutItem class provides an abstract item that a
|
|
TQLayout manipulates.
|
|
|
|
This is used by custom layouts.
|
|
|
|
Pure virtual functions are provided to return information about
|
|
the tqlayout, including, tqsizeHint(), tqminimumSize(), tqmaximumSize()
|
|
and expandingDirections().
|
|
|
|
The tqlayout's tqgeometry can be set and retrieved with setGeometry()
|
|
and tqgeometry(), and its tqalignment with tqsetAlignment() and
|
|
tqalignment().
|
|
|
|
isEmpty() returns whether the tqlayout is empty. iterator() returns
|
|
an iterator for the tqlayout's tqchildren. If the concrete item is a
|
|
TQWidget, it can be retrieved using widget(). Similarly for
|
|
tqlayout() and tqspacerItem().
|
|
|
|
\sa TQLayout
|
|
*/
|
|
|
|
/*!
|
|
\class TQSpacerItem
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
\brief The TQSpacerItem class provides blank space in a tqlayout.
|
|
|
|
This class is used by custom layouts.
|
|
|
|
\sa TQLayout TQLayout::tqspacerItem()
|
|
*/
|
|
|
|
/*!
|
|
\class TQWidgetItem
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
\brief The TQWidgetItem class is a tqlayout item that represents a widget.
|
|
|
|
This is used by custom layouts.
|
|
|
|
\sa TQLayout TQLayout::widget()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem::TQLayoutItem( int tqalignment )
|
|
|
|
Constructs a tqlayout item with an \a tqalignment that is a bitwise OR
|
|
of the \l{TQt::AlignmentFlags}. Not all subclasses support
|
|
tqalignment.
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQLayoutItem::tqalignment() const
|
|
|
|
Returns the tqalignment of this item.
|
|
*/
|
|
|
|
/*!
|
|
Sets the tqalignment of this item to \a a, which is a bitwise OR of
|
|
the \l{TQt::AlignmentFlags}. Not all subclasses support tqalignment.
|
|
*/
|
|
// void TQLayoutItem::tqsetAlignment( int a )
|
|
// {
|
|
// align = (Qt::AlignmentFlag)a;
|
|
// }
|
|
|
|
/*!
|
|
\fn TQSize TQLayoutItem::tqmaximumSize() const
|
|
|
|
Implemented in subclasses to return the maximum size of this item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSize TQLayoutItem::tqminimumSize() const
|
|
|
|
Implemented in subclasses to return the minimum size of this item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSize TQLayoutItem::tqsizeHint() const
|
|
|
|
Implemented in subclasses to return the preferred size of this item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQ_SPExpandData TQLayoutItem::expandingDirections() const
|
|
|
|
Implemented in subclasses to return the direction(s) this item
|
|
"wants" to expand in (if any).
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQLayoutItem::setGeometry( const TQRect &r )
|
|
|
|
Implemented in subclasses to set this item's tqgeometry to \a r.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQRect TQLayoutItem::tqgeometry() const
|
|
|
|
Returns the rectangle covered by this tqlayout item.
|
|
*/
|
|
|
|
/*!
|
|
\fn virtual bool TQLayoutItem::isEmpty() const
|
|
|
|
Implemented in subclasses to return whether this item is empty,
|
|
i.e. whether it contains any widgets.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSpacerItem::TQSpacerItem( int w, int h, TQSizePolicy::SizeType hData, TQSizePolicy::SizeType vData )
|
|
|
|
Constructs a spacer item with preferred width \a w, preferred
|
|
height \a h, horizontal size policy \a hData and vertical size
|
|
policy \a vData.
|
|
|
|
The default values provide a gap that is able to stretch if
|
|
nothing else wants the space.
|
|
*/
|
|
|
|
#ifdef USE_QT4
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Changes this spacer item to have preferred width \a w, preferred
|
|
height \a h, horizontal size policy \a hData and vertical size
|
|
policy \a vData.
|
|
|
|
The default values provide a gap that is able to stretch if
|
|
nothing else wants the space.
|
|
*/
|
|
void TQSpacerItem::changeSize( int w, int h, TQSizePolicy::SizeType hData,
|
|
TQSizePolicy::SizeType vData )
|
|
{
|
|
width = w;
|
|
height = h;
|
|
sizeP = TQSizePolicy( hData, vData );
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
\fn TQWidgetItem::TQWidgetItem (TQWidget * w)
|
|
|
|
Creates an item containing widget \a w.
|
|
*/
|
|
|
|
/*!
|
|
Destroys the TQLayoutItem.
|
|
*/
|
|
// TQLayoutItem::~TQLayoutItem()
|
|
// {
|
|
// }
|
|
|
|
/*!
|
|
Invalidates any cached information in this tqlayout item.
|
|
*/
|
|
// void TQLayoutItem::tqinvalidate()
|
|
// {
|
|
// }
|
|
|
|
/*!
|
|
If this item is a TQLayout, it is returned as a TQLayout; otherwise
|
|
0 is returned. This function provides type-safe casting.
|
|
*/
|
|
// TQLayout * TQLayoutItem::tqlayout()
|
|
// {
|
|
// return 0;
|
|
// }
|
|
|
|
/*!
|
|
If this item is a TQSpacerItem, it is returned as a TQSpacerItem;
|
|
otherwise 0 is returned. This function provides type-safe casting.
|
|
*/
|
|
// TQSpacerItem * TQLayoutItem::tqspacerItem()
|
|
// {
|
|
// return 0;
|
|
// }
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
// TQLayout * TQLayout::tqlayout()
|
|
// {
|
|
// return this;
|
|
// }
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQSpacerItem * TQSpacerItem::tqspacerItem()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
/*!
|
|
If this item is a TQWidget, it is returned as a TQWidget; otherwise
|
|
0 is returned. This function provides type-safe casting.
|
|
*/
|
|
// TQWidget * TQLayoutItem::widget()
|
|
// {
|
|
// return 0;
|
|
// }
|
|
|
|
/*!
|
|
Returns the widget managed by this item.
|
|
*/
|
|
TQWidget * TQWidgetItem::widget()
|
|
{
|
|
return wid;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if this tqlayout's preferred height depends on its
|
|
width; otherwise returns FALSE. The default implementation returns
|
|
FALSE.
|
|
|
|
Reimplement this function in tqlayout managers that support height
|
|
for width.
|
|
|
|
\sa heightForWidth(), TQWidget::heightForWidth()
|
|
*/
|
|
// bool TQLayoutItem::hasHeightForWidth() const
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
|
|
/*!
|
|
Returns an iterator over this item's TQLayoutItem tqchildren. The
|
|
default implementation returns an empty iterator.
|
|
|
|
Reimplement this function in subclasses that can have tqchildren.
|
|
*/
|
|
// TQLayoutIterator TQLayoutItem::iterator()
|
|
// {
|
|
// return TQLayoutIterator( 0 );
|
|
// }
|
|
|
|
/*!
|
|
Returns the preferred height for this tqlayout item, given the width
|
|
\a w.
|
|
|
|
The default implementation returns -1, indicating that the
|
|
preferred height is independent of the width of the item. Using
|
|
the function hasHeightForWidth() will typically be much faster
|
|
than calling this function and testing for -1.
|
|
|
|
Reimplement this function in tqlayout managers that support height
|
|
for width. A typical implementation will look like this:
|
|
\code
|
|
int MyLayout::heightForWidth( int w ) const
|
|
{
|
|
if ( cache_dirty || cached_width != w ) {
|
|
// not all C++ compilers support "mutable"
|
|
MyLayout *that = (MyLayout*)this;
|
|
int h = calculateHeightForWidth( w );
|
|
that->cached_hfw = h;
|
|
return h;
|
|
}
|
|
return cached_hfw;
|
|
}
|
|
\endcode
|
|
|
|
Caching is strongly recommended; without it tqlayout will take
|
|
exponential time.
|
|
|
|
\sa hasHeightForWidth()
|
|
*/
|
|
// int TQLayoutItem::heightForWidth( int /* w */ ) const
|
|
// {
|
|
// return -1;
|
|
// }
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Stores the spacer item's rect \a r so that it can be returned by
|
|
tqgeometry().
|
|
*/
|
|
void TQSpacerItem::setGeometry( const TQRect &r )
|
|
{
|
|
QSpacerItem::setGeometry(r);
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Stores the spacer item's rect \a r so that it can be returned by
|
|
tqgeometry().
|
|
*/
|
|
void TQSpacerItem::setGeometry( const TQRect &r )
|
|
{
|
|
rect = r;
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
Sets the tqgeometry of this item's widget to be contained within
|
|
rect \a r, taking tqalignment and maximum size into account.
|
|
*/
|
|
void TQWidgetItem::setGeometry( const TQRect &r )
|
|
{
|
|
TQSize s = r.size().boundedTo( tqSmartMaxSize( this ) );
|
|
int x = r.x();
|
|
int y = r.y();
|
|
if ( align & (TQt::AlignHorizontal_Mask | TQt::AlignVertical_Mask) ) {
|
|
TQSize pref = wid->tqsizeHint().expandedTo( wid->tqminimumSize() ); //###
|
|
if ( align & TQt::AlignHorizontal_Mask )
|
|
s.setWidth( TQMIN( s.width(), pref.width() ) );
|
|
if ( align & TQt::AlignVertical_Mask ) {
|
|
if ( hasHeightForWidth() )
|
|
s.setHeight( TQMIN( s.height(), heightForWidth(s.width()) ) );
|
|
else
|
|
s.setHeight( TQMIN( s.height(), pref.height() ) );
|
|
}
|
|
}
|
|
int alignHoriz = TQApplication::horizontalAlignment( align );
|
|
if ( alignHoriz & TQt::AlignRight )
|
|
x = x + ( r.width() - s.width() );
|
|
else if ( !(alignHoriz & TQt::AlignLeft) )
|
|
x = x + ( r.width() - s.width() ) / 2;
|
|
|
|
if ( align & TQt::AlignBottom )
|
|
y = y + ( r.height() - s.height() );
|
|
else if ( !(align & TQt::AlignTop) )
|
|
y = y + ( r.height() - s.height() ) / 2;
|
|
|
|
if ( !isEmpty() ) {
|
|
wid->setGeometry( x, y, s.width(), s.height() );
|
|
}
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQRect TQSpacerItem::tqgeometry() const
|
|
{
|
|
return QSpacerItem::geometry();
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQRect TQSpacerItem::tqgeometry() const
|
|
{
|
|
return rect;
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQRect TQWidgetItem::tqgeometry() const
|
|
{
|
|
return wid->tqgeometry();
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQRect TQLayout::tqgeometry() const
|
|
{
|
|
return rect;
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQWidgetItem::hasHeightForWidth() const
|
|
{
|
|
if ( isEmpty() )
|
|
return FALSE;
|
|
if ( wid->tqlayout() )
|
|
return wid->tqlayout()->hasHeightForWidth();
|
|
return wid->sizePolicy().hasHeightForWidth();
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
int TQWidgetItem::heightForWidth( int w ) const
|
|
{
|
|
if ( isEmpty() )
|
|
return -1;
|
|
int hfw;
|
|
if ( wid->tqlayout() )
|
|
hfw = wid->tqlayout()->totalHeightForWidth( w );
|
|
else
|
|
hfw = wid->heightForWidth( w );
|
|
|
|
if ( hfw > wid->maximumHeight() )
|
|
hfw = wid->maximumHeight();
|
|
if ( hfw < wid->minimumHeight() )
|
|
hfw = wid->minimumHeight();
|
|
if ( hfw < 1 )
|
|
hfw = 1;
|
|
return hfw;
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Returns the direction in which this spacer item will expand.
|
|
|
|
\sa TQ_SPExpandData
|
|
*/
|
|
TQ_SPExpandData TQSpacerItem::expandingDirections() const
|
|
{
|
|
return QSpacerItem::expandingDirections();
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Returns the direction in which this spacer item will expand.
|
|
|
|
\sa TQ_SPExpandData
|
|
*/
|
|
TQ_SPExpandData TQSpacerItem::expandingDirections() const
|
|
{
|
|
return sizeP.expandingDirections();
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
Returns whether this item's widget can make use of more space than
|
|
tqsizeHint(). A value of \c Vertical or \c Horizontal means that it wants
|
|
to grow in only one dimension, whereas \c BothDirections means that
|
|
it wants to grow in both dimensions and \c NoDirection means that
|
|
it doesn't want to grow at all.
|
|
*/
|
|
TQ_SPExpandData TQWidgetItem::expandingDirections() const
|
|
{
|
|
if ( isEmpty() )
|
|
return (TQ_SPExpandData)TQSizePolicy::NoDirection;
|
|
|
|
int e = TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).expandingDirections();
|
|
/*
|
|
If the tqlayout is expanding, we make the widget expanding, even if
|
|
its own size policy isn't expanding. This behavior should be
|
|
reconsidered in TQt 4.0. (###)
|
|
*/
|
|
#ifdef USE_QT4
|
|
if ( wid->layout() ) {
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).mayGrowHorizontally()
|
|
&& (wid->layout()->expandingDirections() & TQSizePolicy::Horizontally) )
|
|
e |= TQSizePolicy::Horizontally;
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).mayGrowVertically()
|
|
&& (wid->layout()->expandingDirections() & TQSizePolicy::Vertically) )
|
|
e |= TQSizePolicy::Vertically;
|
|
}
|
|
#else // USE_QT4
|
|
if ( wid->tqlayout() ) {
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).mayGrowHorizontally()
|
|
&& (wid->tqlayout()->expandingDirections() & TQSizePolicy::Horizontally) )
|
|
e |= TQSizePolicy::Horizontally;
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).mayGrowVertically()
|
|
&& (wid->tqlayout()->expandingDirections() & TQSizePolicy::Vertically) )
|
|
e |= TQSizePolicy::Vertically;
|
|
}
|
|
#endif // USE_QT4
|
|
|
|
if ( align & TQt::AlignHorizontal_Mask )
|
|
e &= ~TQSizePolicy::Horizontally;
|
|
if ( align & TQt::AlignVertical_Mask)
|
|
e &= ~TQSizePolicy::Vertically;
|
|
|
|
// [FIXME]
|
|
// For some reason, the above (commented out) code causes a weird crash that currupts the stack or heap, making debugging extremely difficult
|
|
// printf("[WARNING] TQ_SPExpandData TQWidgetItem::expandingDirections() const partially implemented\n\r");
|
|
|
|
return (TQ_SPExpandData)e;
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Returns the minimum size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqminimumSize() const
|
|
{
|
|
|
|
return QSpacerItem::minimumSize();
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Returns the minimum size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqminimumSize() const
|
|
{
|
|
return TQSize( sizeP.mayShrinkHorizontally() ? 0 : width,
|
|
sizeP.mayShrinkVertically() ? 0 : height );
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
Returns the minimum size of this item.
|
|
*/
|
|
TQSize TQWidgetItem::tqminimumSize() const
|
|
{
|
|
if ( isEmpty() )
|
|
return TQSize( 0, 0 );
|
|
return tqSmartMinSize( this );
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Returns the maximum size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqmaximumSize() const
|
|
{
|
|
return QSpacerItem::maximumSize();
|
|
}
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Returns the maximum size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqmaximumSize() const
|
|
{
|
|
return TQSize( sizeP.mayGrowHorizontally() ? TQLAYOUTSIZE_MAX : width,
|
|
sizeP.mayGrowVertically() ? TQLAYOUTSIZE_MAX : height );
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
Returns the maximum size of this item.
|
|
*/
|
|
TQSize TQWidgetItem::tqmaximumSize() const
|
|
{
|
|
if ( isEmpty() ) {
|
|
return TQSize( 0, 0 );
|
|
} else {
|
|
return tqSmartMaxSize( this, align );
|
|
}
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
/*!
|
|
Returns the preferred size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqsizeHint() const
|
|
{
|
|
return QSpacerItem::sizeHint();
|
|
}
|
|
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
Returns the preferred size of this spacer item.
|
|
*/
|
|
TQSize TQSpacerItem::tqsizeHint() const
|
|
{
|
|
return TQSize( width, height );
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
Returns the preferred size of this item.
|
|
*/
|
|
TQSize TQWidgetItem::tqsizeHint() const
|
|
{
|
|
TQSize s;
|
|
if ( isEmpty() ) {
|
|
s = TQSize( 0, 0 );
|
|
} else {
|
|
s = wid->tqsizeHint();
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).horData() == TQSizePolicy::Ignored )
|
|
s.setWidth( 1 );
|
|
if ( TQT_TQSIZEPOLICY_OBJECT(wid->sizePolicy()).verData() == TQSizePolicy::Ignored )
|
|
s.setHeight( 1 );
|
|
s = s.boundedTo( wid->tqmaximumSize() )
|
|
.expandedTo( wid->tqminimumSize() ).expandedTo( TQSize(1, 1) );
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE because a spacer item never contains widgets.
|
|
*/
|
|
bool TQSpacerItem::isEmpty() const
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the widget has been hidden; otherwise returns
|
|
FALSE.
|
|
*/
|
|
bool TQWidgetItem::isEmpty() const
|
|
{
|
|
return wid->isHidden() || wid->isTopLevel();
|
|
}
|
|
|
|
#ifdef USE_QT4
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
\class TQLayout
|
|
\brief The TQLayout class is the base class of tqgeometry managers.
|
|
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
|
|
This is an abstract base class inherited by the concrete classes,
|
|
TQBoxLayout and TQGridLayout.
|
|
|
|
For users of TQLayout subclasses or of TQMainWindow there is seldom
|
|
any need to use the basic functions provided by TQLayout, such as
|
|
\l setResizeMode() or setMenuBar(). See the \link tqlayout.html tqlayout
|
|
overview page \endlink for more information.
|
|
|
|
To make your own tqlayout manager, subclass TQGLayoutIterator and
|
|
implement the functions addItem(), tqsizeHint(), setGeometry(), and
|
|
iterator(). You should also implement tqminimumSize() to ensure your
|
|
tqlayout isn't resized to zero size if there is too little space. To
|
|
support tqchildren whose heights depend on their widths, implement
|
|
hasHeightForWidth() and heightForWidth(). See the \link
|
|
customtqlayout.html custom tqlayout page \endlink for an in-depth
|
|
description.
|
|
|
|
Geometry management stops when the tqlayout manager is deleted.
|
|
*/
|
|
|
|
/*!
|
|
Constructs a new top-level TQLayout called \a name, with main
|
|
widget \a parent. \a parent may not be 0.
|
|
|
|
The \a margin is the number of pixels between the edge of the
|
|
widget and the managed tqchildren. The \a spacing sets the value of
|
|
spacing(), which gives the spacing between the managed widgets. If
|
|
\a spacing is -1 (the default), spacing is set to the value of \a
|
|
margin.
|
|
|
|
There can be only one top-level tqlayout for a widget. It is
|
|
returned by TQWidget::tqlayout()
|
|
*/
|
|
TQLayout::TQLayout( QWidget *parent, int margin, int spacing, const char *name )
|
|
: TQObject( parent, name )
|
|
{
|
|
init();
|
|
if ( parent ) {
|
|
if ( parent->tqlayout() ) {
|
|
qWarning( "TQLayout \"%s\" added to %s \"%s\", which already has a"
|
|
" tqlayout", TQObject::name(), parent->className(),
|
|
parent->name() );
|
|
parent->removeChild( this );
|
|
} else {
|
|
topLevel = TRUE;
|
|
parent->installEventFilter( this );
|
|
setWidgetLayout( parent, this );
|
|
}
|
|
}
|
|
outsideBorder = margin;
|
|
if ( spacing < 0 )
|
|
insideSpacing = margin;
|
|
else
|
|
insideSpacing = spacing;
|
|
}
|
|
|
|
void TQLayout::init()
|
|
{
|
|
insideSpacing = 0;
|
|
outsideBorder = 0;
|
|
topLevel = FALSE;
|
|
enabled = TRUE;
|
|
autoNewChild = FALSE;
|
|
frozen = FALSE;
|
|
activated = FALSE;
|
|
marginImpl = FALSE;
|
|
autoMinimum = FALSE;
|
|
autoResizeMode = TRUE;
|
|
extraData = 0;
|
|
#ifndef TQT_NO_MENUBAR
|
|
menubar = 0;
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
Constructs a new child TQLayout called \a name, and places it
|
|
inside \a parentLayout by using the default placement defined by
|
|
addItem().
|
|
|
|
If \a spacing is -1, this TQLayout inherits \a parentLayout's
|
|
spacing(), otherwise the value of \a spacing is used.
|
|
*/
|
|
TQLayout::TQLayout( QLayout *parentLayout, int spacing, const char *name )
|
|
: TQObject( parentLayout, name )
|
|
|
|
{
|
|
init();
|
|
insideSpacing = spacing < 0 ? parentLayout->insideSpacing : spacing;
|
|
parentLayout->addItem( this );
|
|
}
|
|
|
|
/*!
|
|
Constructs a new child TQLayout called \a name. If \a spacing is
|
|
-1, this TQLayout inherits its parent's spacing(); otherwise the
|
|
value of \a spacing is used.
|
|
|
|
This tqlayout has to be inserted into another tqlayout before tqgeometry
|
|
management will work.
|
|
*/
|
|
TQLayout::TQLayout( int spacing, const char *name )
|
|
: TQObject( 0, name )
|
|
{
|
|
init();
|
|
insideSpacing = spacing;
|
|
}
|
|
|
|
/*!
|
|
\fn void TQLayout::addItem( TQLayoutItem *item )
|
|
|
|
Implemented in subclasses to add an \a item. How it is added is
|
|
specific to each subclass.
|
|
|
|
The ownership of \a item is transferred to the tqlayout, and it's
|
|
the tqlayout's responsibility to delete it.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutIterator TQLayout::iterator()
|
|
|
|
Implemented in subclasses to return an iterator that iterates over
|
|
this tqlayout's tqchildren.
|
|
|
|
A typical implementation will be:
|
|
\code
|
|
TQLayoutIterator MyLayout::iterator()
|
|
{
|
|
TQGLayoutIterator *i = new MyLayoutIterator( internal_data );
|
|
return TQLayoutIterator( i );
|
|
}
|
|
\endcode
|
|
where MyLayoutIterator is a subclass of TQGLayoutIterator.
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQLayout::add( TQWidget *w )
|
|
|
|
Adds widget \a w to this tqlayout in a manner specific to the
|
|
tqlayout. This function uses addItem().
|
|
*/
|
|
|
|
/*!
|
|
\fn TQMenuBar* TQLayout::menuBar () const
|
|
|
|
Returns the menu bar set for this tqlayout, or 0 if no menu bar is
|
|
set.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQLayout::isTopLevel () const
|
|
|
|
Returns TRUE if this tqlayout is a top-level tqlayout, i.e. not a
|
|
child of another tqlayout; otherwise returns FALSE.
|
|
*/
|
|
|
|
/*!
|
|
\property TQLayout::margin
|
|
\brief the width of the outside border of the tqlayout
|
|
|
|
For some tqlayout classes this property has an effect only on
|
|
top-level layouts; TQBoxLayout and TQGridLayout support margins for
|
|
child layouts. The default value is 0.
|
|
|
|
\sa spacing
|
|
*/
|
|
|
|
/*!
|
|
\property TQLayout::spacing
|
|
\brief the spacing between widgets inside the tqlayout
|
|
|
|
The default value is -1, which signifies that the tqlayout's spacing
|
|
should not override the widget's spacing.
|
|
|
|
\sa margin
|
|
*/
|
|
void TQLayout::setMargin( int margin )
|
|
{
|
|
outsideBorder = margin;
|
|
tqinvalidate();
|
|
if ( mainWidget() ) {
|
|
TQEvent *lh = new TQEvent( TQEvent::LayoutHint );
|
|
TQApplication::postEvent( mainWidget(), lh );
|
|
}
|
|
}
|
|
|
|
void TQLayout::setSpacing( int spacing )
|
|
{
|
|
insideSpacing = spacing;
|
|
if ( spacing >= 0 )
|
|
propagateSpacing( this );
|
|
tqinvalidate();
|
|
if ( mainWidget() ) {
|
|
TQEvent *lh = new TQEvent( TQEvent::LayoutHint );
|
|
TQApplication::postEvent( mainWidget(), lh );
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the main widget (parent widget) of this tqlayout, or 0 if
|
|
this tqlayout is a sub-tqlayout that is not yet inserted.
|
|
*/
|
|
TQWidget *TQLayout::mainWidget()
|
|
{
|
|
if ( !topLevel ) {
|
|
if ( parent() ) {
|
|
TQLayout *parentLayout = ::tqqt_cast<TQLayout*>(parent());
|
|
TQ_ASSERT(parentLayout);
|
|
return parentLayout->mainWidget();
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
TQ_ASSERT(parent() && parent()->isWidgetType());
|
|
return (TQWidget*)parent();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if this tqlayout is empty. The default implementation
|
|
returns FALSE.
|
|
*/
|
|
bool TQLayout::isEmpty() const
|
|
{
|
|
return FALSE; //### should check
|
|
}
|
|
|
|
/*!
|
|
Sets widget \a w's tqlayout to tqlayout \a l.
|
|
*/
|
|
void TQLayout::setWidgetLayout( TQWidget *w, TQLayout *l )
|
|
{
|
|
w->setLayout( l );
|
|
}
|
|
|
|
/*!
|
|
This function is reimplemented in subclasses to perform tqlayout.
|
|
|
|
The default implementation maintains the tqgeometry() information
|
|
given by rect \a r. Reimplementors must call this function.
|
|
*/
|
|
void TQLayout::setGeometry( const TQRect &r )
|
|
{
|
|
rect = r;
|
|
}
|
|
|
|
/*!
|
|
Invalidates cached information. Reimplementations must call this.
|
|
*/
|
|
void TQLayout::tqinvalidate()
|
|
{
|
|
rect = TQRect();
|
|
}
|
|
|
|
static bool removeWidgetRecursively( TQLayoutItem *lay, TQWidget *w )
|
|
{
|
|
bool didSomething = FALSE;
|
|
TQLayoutIterator it = lay->iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) != 0 ) {
|
|
if ( child->widget() == w ) {
|
|
it.deleteCurrent();
|
|
lay->tqinvalidate(); // maybe redundant
|
|
didSomething = TRUE;
|
|
} else if ( removeWidgetRecursively(child, w) ) {
|
|
lay->tqinvalidate(); // maybe redundant
|
|
didSomething = TRUE;
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
return didSomething;
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
Performs child widget tqlayout when the parent widget is resized.
|
|
Also handles removal of widgets and child layouts. \a e is the
|
|
event the occurred on object \a o.
|
|
*/
|
|
bool TQLayout::eventFilter( TQObject *o, TQEvent *e )
|
|
{
|
|
if ( !enabled )
|
|
return FALSE;
|
|
|
|
if ( !o->isWidgetType() )
|
|
return FALSE;
|
|
|
|
switch ( e->type() ) {
|
|
case TQEvent::Resize:
|
|
if ( activated ) {
|
|
TQResizeEvent *r = (TQResizeEvent *)e;
|
|
int mbh = 0;
|
|
#ifndef TQT_NO_MENUBAR
|
|
mbh = menuBarHeightForWidth( menubar, r->size().width() );
|
|
#endif
|
|
int b = marginImpl ? 0 : outsideBorder;
|
|
setGeometry( TQRect( b, mbh + b, r->size().width() - 2 * b,
|
|
r->size().height() - mbh - 2 * b ) );
|
|
} else {
|
|
activate();
|
|
}
|
|
break;
|
|
case TQEvent::ChildRemoved:
|
|
{
|
|
TQChildEvent *c = (TQChildEvent *)e;
|
|
if ( c->child()->isWidgetType() ) {
|
|
TQWidget *w = (TQWidget *)c->child();
|
|
#ifndef TQT_NO_MENUBAR
|
|
if ( w == menubar )
|
|
menubar = 0;
|
|
#endif
|
|
if ( removeWidgetRecursively( this, w ) ) {
|
|
TQEvent *lh = new TQEvent( TQEvent::LayoutHint );
|
|
TQApplication::postEvent( o, lh );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case TQEvent::ChildInserted:
|
|
if ( topLevel && autoNewChild ) {
|
|
TQChildEvent *c = (TQChildEvent *)e;
|
|
if ( c->child()->isWidgetType() ) {
|
|
TQWidget *w = (TQWidget *)c->child();
|
|
if ( !w->isTopLevel() ) {
|
|
#if !defined(TQT_NO_MENUBAR) && !defined(TQT_NO_TOOLBAR)
|
|
if ( ::tqqt_cast<TQMenuBar*>(w) && !::tqqt_cast<TQToolBar*>(w->parentWidget()) )
|
|
menubar = (TQMenuBar *)w;
|
|
else
|
|
#endif
|
|
addItem( new TQWidgetItem( w ) );
|
|
TQEvent *lh = new TQEvent( TQEvent::LayoutHint );
|
|
TQApplication::postEvent( o, lh );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case TQEvent::LayoutHint:
|
|
activate();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TQObject::eventFilter( o, e );
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQLayout::childEvent( TQChildEvent *e )
|
|
{
|
|
if ( !enabled )
|
|
return;
|
|
|
|
if ( e->type() == TQEvent::ChildRemoved ) {
|
|
TQChildEvent *c = (TQChildEvent*)e;
|
|
TQLayoutIterator it = iterator();
|
|
TQLayoutItem *item;
|
|
while ( (item = it.current() ) ) {
|
|
if ( item == (TQLayout*)c->child() ) {
|
|
it.takeCurrent();
|
|
tqinvalidate();
|
|
break;
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Also takes margin() and menu bar into account.
|
|
*/
|
|
int TQLayout::totalHeightForWidth( int w ) const
|
|
{
|
|
if ( topLevel ) {
|
|
TQWidget *mw = (TQWidget*)parent();
|
|
if ( mw && !mw->testWState(WState_Polished) ) {
|
|
mw->polish();
|
|
}
|
|
}
|
|
int b = ( topLevel && !marginImpl ) ? 2 * outsideBorder : 0;
|
|
int h = heightForWidth( w - b ) + b;
|
|
#ifndef TQT_NO_MENUBAR
|
|
h += menuBarHeightForWidth( menubar, w );
|
|
#endif
|
|
return h;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Also takes margin() and menu bar into account.
|
|
*/
|
|
TQSize TQLayout::totalMinimumSize() const
|
|
{
|
|
if ( topLevel ) {
|
|
TQWidget *mw = (TQWidget*)parent();
|
|
if ( mw && !mw->testWState(WState_Polished) )
|
|
mw->polish();
|
|
}
|
|
int b = ( topLevel && !marginImpl ) ? 2 * outsideBorder : 0;
|
|
|
|
TQSize s = tqminimumSize();
|
|
int h = b;
|
|
#ifndef TQT_NO_MENUBAR
|
|
h += menuBarHeightForWidth( menubar, s.width() );
|
|
#endif
|
|
return s + TQSize( b, h );
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Also takes margin() and menu bar into account.
|
|
*/
|
|
TQSize TQLayout::totalSizeHint() const
|
|
{
|
|
if ( topLevel ) {
|
|
TQWidget *mw = (TQWidget*)parent();
|
|
if ( mw && !mw->testWState(WState_Polished) )
|
|
mw->polish();
|
|
}
|
|
int b = ( topLevel && !marginImpl ) ? 2 * outsideBorder : 0;
|
|
|
|
TQSize s = tqsizeHint();
|
|
if ( hasHeightForWidth() )
|
|
s.setHeight( heightForWidth(s.width()) );
|
|
int h = b;
|
|
#ifndef TQT_NO_MENUBAR
|
|
h += menuBarHeightForWidth( menubar, s.width() );
|
|
#endif
|
|
return s + TQSize( b, h );
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Also takes margin() and menu bar into account.
|
|
*/
|
|
TQSize TQLayout::totalMaximumSize() const
|
|
{
|
|
if ( topLevel ) {
|
|
TQWidget *mw = (TQWidget*)parent();
|
|
if ( mw && !mw->testWState(WState_Polished) ) {
|
|
mw->polish();
|
|
}
|
|
}
|
|
int b = ( topLevel && !marginImpl ) ? 2 * outsideBorder : 0;
|
|
|
|
TQSize s = tqmaximumSize();
|
|
int h = b;
|
|
#ifndef TQT_NO_MENUBAR
|
|
h += menuBarHeightForWidth( menubar, s.width() );
|
|
#endif
|
|
|
|
if ( isTopLevel() )
|
|
s = TQSize( TQMIN( s.width() + b, TQLAYOUTSIZE_MAX ),
|
|
TQMIN( s.height() + h, TQLAYOUTSIZE_MAX ) );
|
|
return s;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Destroys the tqlayout, deleting all child layouts.
|
|
Geometry management stops when a top-level tqlayout is deleted.
|
|
|
|
The tqlayout classes will probably be fatally confused if you delete
|
|
a subtqlayout.
|
|
*/
|
|
TQLayout::~TQLayout()
|
|
{
|
|
/*
|
|
This function may be called during the TQObject destructor,
|
|
when the parent no longer is a TQWidget.
|
|
*/
|
|
if ( isTopLevel() && parent() && parent()->isWidgetType() &&
|
|
((TQWidget*)parent())->tqlayout() == this )
|
|
setWidgetLayout( (TQWidget*)parent(), 0 );
|
|
}
|
|
|
|
/*!
|
|
Removes and deletes all items in this tqlayout.
|
|
*/
|
|
void TQLayout::deleteAllItems()
|
|
{
|
|
TQLayoutIterator it = iterator();
|
|
TQLayoutItem *l;
|
|
while ( (l = it.takeCurrent()) )
|
|
delete l;
|
|
}
|
|
|
|
/*!
|
|
This function is called from addLayout() functions in subclasses
|
|
to add tqlayout \a l as a sub-tqlayout.
|
|
*/
|
|
void TQLayout::addChildLayout( TQLayout *l )
|
|
{
|
|
if ( l->parent() ) {
|
|
#if defined(TQT_CHECK_NULL)
|
|
qWarning( "TQLayout::addChildLayout: tqlayout already has a parent" );
|
|
#endif
|
|
return;
|
|
}
|
|
insertChild( l );
|
|
if ( l->insideSpacing < 0 ) {
|
|
l->insideSpacing = insideSpacing;
|
|
propagateSpacing( l );
|
|
}
|
|
}
|
|
|
|
/*! \fn int TQLayout::defaultBorder() const
|
|
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void TQLayout::freeze()
|
|
|
|
\internal
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
Fixes the size of the main widget and distributes the available
|
|
space to the child widgets. For widgets which should not be
|
|
resizable, but where a TQLayout subclass is used to set up the initial
|
|
tqgeometry.
|
|
|
|
As a special case, freeze(0, 0) is equivalent to setResizeMode(Fixed).
|
|
*/
|
|
void TQLayout::freeze( int w, int h )
|
|
{
|
|
if ( w <= 0 || h <= 0 ) {
|
|
setResizeMode( Fixed );
|
|
} else {
|
|
setResizeMode( FreeResize ); // tqlayout will not change min/max size
|
|
mainWidget()->setFixedSize( w, h );
|
|
}
|
|
}
|
|
|
|
#ifndef TQT_NO_MENUBAR
|
|
|
|
/*!
|
|
Makes the tqgeometry manager take account of the menu bar \a w. All
|
|
child widgets are placed below the bottom edge of the menu bar.
|
|
|
|
A menu bar does its own tqgeometry management: never do addWidget()
|
|
on a TQMenuBar.
|
|
*/
|
|
void TQLayout::setMenuBar( TQMenuBar *w )
|
|
{
|
|
menubar = w;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
Returns the minimum size of this tqlayout. This is the smallest size
|
|
that the tqlayout can have while still respecting the
|
|
specifications. Does not include what's needed by margin() or
|
|
menuBar().
|
|
|
|
The default implementation allows unlimited resizing.
|
|
*/
|
|
TQSize TQLayout::tqminimumSize() const
|
|
{
|
|
return TQSize( 0, 0 );
|
|
}
|
|
|
|
/*!
|
|
Returns the maximum size of this tqlayout. This is the largest size
|
|
that the tqlayout can have while still respecting the
|
|
specifications. Does not include what's needed by margin() or
|
|
menuBar().
|
|
|
|
The default implementation allows unlimited resizing.
|
|
*/
|
|
TQSize TQLayout::tqmaximumSize() const
|
|
{
|
|
return TQSize( TQLAYOUTSIZE_MAX, TQLAYOUTSIZE_MAX );
|
|
}
|
|
|
|
/*!
|
|
Returns whether this tqlayout can make use of more space than
|
|
tqsizeHint(). A value of \c Vertical or \c Horizontal means that it wants
|
|
to grow in only one dimension, whereas \c BothDirections means that
|
|
it wants to grow in both dimensions.
|
|
|
|
The default implementation returns \c BothDirections.
|
|
*/
|
|
TQ_SPExpandData TQLayout::expandingDirections() const
|
|
{
|
|
return TQSizePolicy::BothDirections;
|
|
}
|
|
|
|
static void invalidateRecursive( TQLayoutItem *lay )
|
|
{
|
|
lay->tqinvalidate();
|
|
TQLayoutIterator it = lay->iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) != 0 ) {
|
|
invalidateRecursive( child );
|
|
++it;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Redoes the tqlayout for mainWidget(). You should generally not need
|
|
to call this because it is automatically called at the most
|
|
appropriate times.
|
|
|
|
However, if you set up a TQLayout for a visible widget without
|
|
resizing that widget, you will need to call this function in order
|
|
to lay it out.
|
|
|
|
\sa TQWidget::updateGeometry()
|
|
*/
|
|
bool TQLayout::activate()
|
|
{
|
|
invalidateRecursive( this );
|
|
if ( !topLevel )
|
|
return FALSE;
|
|
|
|
TQWidget *mw = mainWidget();
|
|
if (!mw) {
|
|
#if defined( TQT_CHECK_NULL )
|
|
qWarning( "TQLayout::activate: %s \"%s\" does not have a main widget",
|
|
TQObject::className(), TQObject::name() );
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
activated = TRUE;
|
|
TQSize s = mw->size();
|
|
TQSize ms;
|
|
int mbh = 0;
|
|
#ifndef TQT_NO_MENUBAR
|
|
mbh = menuBarHeightForWidth( menubar, s.width() );
|
|
#endif
|
|
int b = marginImpl ? 0 : outsideBorder;
|
|
setGeometry(TQRect(b, mbh + b, s.width() - 2 * b, s.height() - mbh - 2 * b));
|
|
if ( frozen ) {
|
|
// will trigger resize
|
|
mw->setFixedSize( totalSizeHint() );
|
|
} else if ( autoMinimum ) {
|
|
ms = totalMinimumSize();
|
|
} else if ( autoResizeMode && topLevel && mw->isTopLevel() ) {
|
|
ms = totalMinimumSize();
|
|
if ( hasHeightForWidth() ) {
|
|
int h;
|
|
int mmbh = menuBarHeightForWidth( menubar, ms.width() );
|
|
// ### 4.0: remove this 'if' when minimumHeightForWidth() is virtual
|
|
if ( inherits("TQBoxLayout") )
|
|
h = ((TQBoxLayout *) this)->minimumHeightForWidth( ms.width() );
|
|
else if ( inherits("TQGridLayout") )
|
|
h = ((TQGridLayout *) this)->minimumHeightForWidth( ms.width() );
|
|
else
|
|
h = heightForWidth( ms.width() );
|
|
if ( h + mmbh > ms.height() )
|
|
#if 1
|
|
//old behaviour:
|
|
ms = TQSize( 0, 0 );
|
|
#else
|
|
//better, but too big a change for a patch release in a stable branch:
|
|
ms.setHeight( 0 );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (ms.isValid())
|
|
mw->setMinimumSize( ms );
|
|
|
|
// ideally only if tqsizeHint() or sizePolicy() has changed
|
|
mw->updateGeometry();
|
|
return TRUE;
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
/*!
|
|
\class TQSizePolicy
|
|
\brief The TQSizePolicy class is a tqlayout attribute describing horizontal
|
|
and vertical resizing policy.
|
|
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
|
|
The size policy of a widget is an expression of its willingness to
|
|
be resized in various ways.
|
|
|
|
Widgets that reimplement TQWidget::sizePolicy() return a TQSizePolicy
|
|
that describes the horizontal and vertical resizing policy they
|
|
prefer when being laid out. Only \link #interesting one of the
|
|
constructors\endlink is of interest in most applications.
|
|
|
|
TQSizePolicy contains two independent SizeType objects; one describes
|
|
the widgets's horizontal size policy, and the other describes its
|
|
vertical size policy. It also contains a flag to indicate whether the
|
|
height and width of its preferred size are related.
|
|
|
|
The horizontal and vertical \l{SizeType}s are set in the usual constructor
|
|
and can be queried using a variety of functions.
|
|
|
|
The hasHeightForWidth() flag indicates whether the widget's tqsizeHint()
|
|
is width-dependent (such as a word-wrapping label) or not.
|
|
|
|
\sa TQSizePolicy::SizeType
|
|
*/
|
|
|
|
/*!
|
|
\enum TQSizePolicy::SizeType
|
|
|
|
The per-dimension sizing types used when constructing a
|
|
TQSizePolicy are:
|
|
|
|
\value Fixed The TQWidget::tqsizeHint() is the only acceptable
|
|
alternative, so the widget can never grow or shrink (e.g. the
|
|
vertical direction of a push button).
|
|
|
|
\value Minimum The tqsizeHint() is minimal, and sufficient. The
|
|
widget can be expanded, but there is no advantage to it being
|
|
larger (e.g. the horizontal direction of a push button).
|
|
It cannot be smaller than the size provided by tqsizeHint().
|
|
|
|
\value Maximum The tqsizeHint() is a maximum. The widget can be
|
|
shrunk any amount without detriment if other widgets need the
|
|
space (e.g. a separator line).
|
|
It cannot be larger than the size provided by tqsizeHint().
|
|
|
|
\value Preferred The tqsizeHint() is best, but the widget can be
|
|
shrunk and still be useful. The widget can be expanded, but there
|
|
is no advantage to it being larger than tqsizeHint() (the default
|
|
TQWidget policy).
|
|
|
|
\value Expanding The tqsizeHint() is a sensible size, but the
|
|
widget can be shrunk and still be useful. The widget can make use
|
|
of extra space, so it should get as much space as possible (e.g.
|
|
the horizontal direction of a slider).
|
|
|
|
\value MinimumExpanding The tqsizeHint() is minimal, and sufficient.
|
|
The widget can make use of extra space, so it should get as much
|
|
space as possible (e.g. the horizontal direction of a slider).
|
|
|
|
\value Ignored the tqsizeHint() is ignored. The widget will get as
|
|
much space as possible.
|
|
*/
|
|
|
|
/*!
|
|
\enum TQ_SPExpandData
|
|
|
|
This enum type describes in which directions a widget can make use
|
|
of extra space. There are four possible values:
|
|
|
|
\value NoDirection the widget cannot make use of extra space in
|
|
any direction.
|
|
|
|
\value Horizontally the widget can usefully be wider than the
|
|
tqsizeHint().
|
|
|
|
\value Vertically the widget can usefully be taller than the
|
|
tqsizeHint().
|
|
|
|
\value BothDirections the widget can usefully be both wider and
|
|
taller than the tqsizeHint().
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSizePolicy::TQSizePolicy()
|
|
|
|
Constructs a minimally initialized TQSizePolicy.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSizePolicy::TQSizePolicy( SizeType hor, SizeType ver, bool hfw )
|
|
|
|
\target interesting
|
|
This is the constructor normally used to return a value in the
|
|
overridden \l TQWidget::sizePolicy() function of a TQWidget
|
|
subclass.
|
|
|
|
It constructs a TQSizePolicy with independent horizontal and
|
|
vertical sizing types, \a hor and \a ver respectively. These \link
|
|
TQSizePolicy::SizeType sizing types\endlink affect how the widget
|
|
is treated by the \link TQLayout tqlayout engine\endlink.
|
|
|
|
If \a hfw is TRUE, the preferred height of the widget is dependent
|
|
on the width of the widget (for example, a TQLabel with line
|
|
wrapping).
|
|
|
|
\sa horData() verData() hasHeightForWidth()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSizePolicy::TQSizePolicy( SizeType hor, SizeType ver, uchar horStretch, uchar verStretch, bool hfw )
|
|
|
|
Constructs a TQSizePolicy with independent horizontal and vertical
|
|
sizing types \a hor and \a ver, and stretch factors \a horStretch
|
|
and \a verStretch.
|
|
|
|
If \a hfw is TRUE, the preferred height of the widget is dependent on the
|
|
width of the widget.
|
|
|
|
\sa horStretch() verStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSizePolicy::SizeType TQSizePolicy::horData() const
|
|
|
|
Returns the horizontal component of the size policy.
|
|
|
|
\sa setHorData() verData() horStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSizePolicy::SizeType TQSizePolicy::verData() const
|
|
|
|
Returns the vertical component of the size policy.
|
|
|
|
\sa setVerData() horData() verStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::mayShrinkHorizontally() const
|
|
|
|
Returns TRUE if the widget can sensibly be narrower than its
|
|
tqsizeHint(); otherwise returns FALSE.
|
|
|
|
\sa mayShrinkVertically() mayGrowHorizontally()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::mayShrinkVertically() const
|
|
|
|
Returns TRUE if the widget can sensibly be shorter than its
|
|
tqsizeHint(); otherwise returns FALSE.
|
|
|
|
\sa mayShrinkHorizontally() mayGrowVertically()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::mayGrowHorizontally() const
|
|
|
|
Returns TRUE if the widget can sensibly be wider than its
|
|
tqsizeHint(); otherwise returns FALSE.
|
|
|
|
\sa mayGrowVertically() mayShrinkHorizontally()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::mayGrowVertically() const
|
|
|
|
Returns TRUE if the widget can sensibly be taller than its
|
|
tqsizeHint(); otherwise returns FALSE.
|
|
|
|
\sa mayGrowHorizontally() mayShrinkVertically()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQ_SPExpandData TQSizePolicy::expandingDirections() const
|
|
|
|
Returns whether this tqlayout can make use of more space than
|
|
tqsizeHint(). A value of \c Vertical or \c Horizontal means that it wants
|
|
to grow in only one dimension, whereas \c BothDirections means that
|
|
it wants to grow in both dimensions.
|
|
|
|
\sa mayShrinkHorizontally() mayGrowHorizontally()
|
|
mayShrinkVertically() mayGrowVertically()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::setHorData( SizeType d )
|
|
|
|
Sets the horizontal component of the size policy to size type \a
|
|
d.
|
|
|
|
\sa horData() setVerData()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::setVerData( SizeType d )
|
|
|
|
Sets the vertical component of the size policy to size type \a d.
|
|
|
|
\sa verData() setHorData()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::hasHeightForWidth() const
|
|
|
|
Returns TRUE if the widget's preferred height depends on its
|
|
width; otherwise returns FALSE.
|
|
|
|
\sa setHeightForWidth()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::setHeightForWidth( bool b )
|
|
|
|
Sets the hasHeightForWidth() flag to \a b.
|
|
|
|
\sa hasHeightForWidth()
|
|
*/
|
|
|
|
/*!
|
|
\fn uint TQSizePolicy::horStretch() const
|
|
|
|
Returns the horizontal stretch factor of the size policy.
|
|
|
|
\sa setHorStretch() verStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn uint TQSizePolicy::verStretch() const
|
|
|
|
Returns the vertical stretch factor of the size policy.
|
|
|
|
\sa setVerStretch() horStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::setHorStretch( uchar sf )
|
|
|
|
Sets the horizontal stretch factor of the size policy to \a sf.
|
|
|
|
\sa horStretch() setVerStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::setVerStretch( uchar sf )
|
|
|
|
Sets the vertical stretch factor of the size policy to \a sf.
|
|
|
|
\sa verStretch() setHorStretch()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQSizePolicy::transpose()
|
|
|
|
Swaps the horizontal and vertical policies and stretches.
|
|
*/
|
|
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::operator==( const TQSizePolicy &s ) const
|
|
|
|
Returns TRUE if this policy is equal to \a s; otherwise returns
|
|
FALSE.
|
|
|
|
\sa operator!=()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQSizePolicy::operator!=( const TQSizePolicy &s ) const
|
|
|
|
Returns TRUE if this policy is different from \a s; otherwise
|
|
returns FALSE.
|
|
|
|
\sa operator==()
|
|
*/
|
|
|
|
/*!
|
|
\class TQGLayoutIterator
|
|
\brief The TQGLayoutIterator class is an abstract base class of internal tqlayout iterators.
|
|
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
|
|
(This class is \e not OpenGL related, it just happens to start with
|
|
the letters TQGL...)
|
|
|
|
Subclass this class to create a custom tqlayout. The functions that
|
|
must be implemented are next(), current(), and takeCurrent().
|
|
|
|
The TQGLayoutIterator implements the functionality of
|
|
TQLayoutIterator. Each subclass of TQLayout needs a
|
|
TQGLayoutIterator subclass.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQGLayoutIterator::next()
|
|
|
|
Implemented in subclasses to move the iterator to the next item
|
|
and return that item, or 0 if there is no next item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQGLayoutIterator::current()
|
|
|
|
Implemented in subclasses to return the current item, or 0 if
|
|
there is no current item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQGLayoutIterator::takeCurrent()
|
|
|
|
Implemented in subclasses. The function must remove the current
|
|
item from the tqlayout without deleting it, move the iterator to the
|
|
next item and return the removed item, or 0 if no item was
|
|
removed.
|
|
*/
|
|
|
|
/*!
|
|
Destroys the iterator
|
|
*/
|
|
TQGLayoutIterator::~TQGLayoutIterator()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\class TQLayoutIterator
|
|
\brief The TQLayoutIterator class provides iterators over TQLayoutItem.
|
|
|
|
\ingroup appearance
|
|
\ingroup geomanagement
|
|
|
|
Use TQLayoutItem::iterator() to create an iterator over a tqlayout.
|
|
|
|
TQLayoutIterator uses \e explicit sharing with a reference count.
|
|
If an iterator is copied and one of the copies is modified, both
|
|
iterators will be modified.
|
|
|
|
A TQLayoutIterator is not protected against changes in its tqlayout. If
|
|
the tqlayout is modified or deleted the iterator will become invalid.
|
|
It is not possible to test for validity. It is safe to delete an
|
|
invalid tqlayout; any other access may lead to an illegal memory
|
|
reference and the abnormal termination of the program.
|
|
|
|
Calling takeCurrent() or deleteCurrent() leaves the iterator in a
|
|
valid state, but may tqinvalidate any other iterators that access the
|
|
same tqlayout.
|
|
|
|
The following code will draw a rectangle for each tqlayout item in
|
|
the tqlayout structure of the widget.
|
|
\code
|
|
static void paintLayout( TQPainter *p, TQLayoutItem *lay )
|
|
{
|
|
TQLayoutIterator it = lay->iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) != 0 ) {
|
|
paintLayout( p, child );
|
|
++it;
|
|
}
|
|
p->drawRect( lay->tqgeometry() );
|
|
}
|
|
void ExampleWidget::paintEvent( TQPaintEvent * )
|
|
{
|
|
TQPainter p( this );
|
|
if ( tqlayout() )
|
|
paintLayout( &p, tqlayout() );
|
|
}
|
|
\endcode
|
|
|
|
All the functionality of TQLayoutIterator is implemented by
|
|
subclasses of \l TQGLayoutIterator. TQLayoutIterator itself is not
|
|
designed to be subclassed.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutIterator::TQLayoutIterator( TQGLayoutIterator *gi )
|
|
|
|
Constructs an iterator based on \a gi. The constructed iterator
|
|
takes ownership of \a gi and will delete it.
|
|
|
|
This constructor is provided for tqlayout implementors. Application
|
|
programmers should use TQLayoutItem::iterator() to create an
|
|
iterator over a tqlayout.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutIterator::TQLayoutIterator( const TQLayoutIterator &i )
|
|
|
|
Creates a shallow copy of \a i, i.e. if the copy is modified, then
|
|
the original will also be modified.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutIterator::~TQLayoutIterator()
|
|
|
|
Destroys the iterator.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutIterator &TQLayoutIterator::operator=( const TQLayoutIterator &i )
|
|
|
|
Assigns \a i to this iterator and returns a reference to this
|
|
iterator.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQLayoutIterator::operator++()
|
|
|
|
Moves the iterator to the next child item and returns that item,
|
|
or 0 if there is no such item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQLayoutIterator::current()
|
|
|
|
Returns the current item, or 0 if there is no current item.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQLayoutItem *TQLayoutIterator::takeCurrent()
|
|
|
|
Removes the current child item from the tqlayout without deleting
|
|
it, and moves the iterator to the next item. Returns the removed
|
|
item, or 0 if there was no item to be removed. This iterator will
|
|
still be valid, but any other iterator over the same tqlayout may
|
|
become invalid.
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQLayoutIterator::deleteCurrent()
|
|
|
|
Removes and deletes the current child item from the tqlayout and
|
|
moves the iterator to the next item. This iterator will still be
|
|
valid, but any other iterator over the same tqlayout may become
|
|
invalid.
|
|
*/
|
|
|
|
/*!
|
|
\enum TQLayout::ResizeMode
|
|
|
|
The possible values are:
|
|
|
|
\value Auto If the main widget is a top-level widget with no
|
|
height-for-width (hasHeightForWidth()), this is
|
|
the same as \c Minimium; otherwise, this is the
|
|
same as \c FreeResize.
|
|
\value Fixed The main widget's size is set to tqsizeHint(); it
|
|
cannot be resized at all.
|
|
\value Minimum The main widget's minimum size is set to
|
|
tqminimumSize(); it cannot be smaller.
|
|
\value FreeResize The widget is not constrained.
|
|
*/
|
|
|
|
#ifdef USE_QT4
|
|
|
|
#else // USE_QT4
|
|
|
|
/*!
|
|
\property TQLayout::resizeMode
|
|
\brief the resize mode of the tqlayout
|
|
|
|
The default mode is \c Auto.
|
|
|
|
\sa TQLayout::ResizeMode
|
|
*/
|
|
|
|
void TQLayout::setResizeMode( ResizeMode mode )
|
|
{
|
|
if ( mode == resizeMode() )
|
|
return;
|
|
|
|
switch ( mode ) {
|
|
case Auto:
|
|
frozen = FALSE;
|
|
autoMinimum = FALSE;
|
|
autoResizeMode = TRUE;
|
|
break;
|
|
case Fixed:
|
|
frozen = TRUE;
|
|
autoMinimum = FALSE;
|
|
autoResizeMode = FALSE;
|
|
break;
|
|
case FreeResize:
|
|
frozen = FALSE;
|
|
autoMinimum = FALSE;
|
|
autoResizeMode = FALSE;
|
|
break;
|
|
case Minimum:
|
|
frozen = FALSE;
|
|
autoMinimum = TRUE;
|
|
autoResizeMode = FALSE;
|
|
}
|
|
if ( mainWidget() && mainWidget()->isVisible() )
|
|
activate();
|
|
}
|
|
|
|
TQLayout::ResizeMode TQLayout::resizeMode() const
|
|
{
|
|
return ( autoResizeMode ? Auto :
|
|
(frozen ? Fixed : (autoMinimum ? Minimum : FreeResize)) );
|
|
}
|
|
|
|
/*!
|
|
\fn bool TQLayout::autoAdd() const
|
|
|
|
Returns TRUE if this tqlayout automatically grabs all new
|
|
mainWidget()'s new tqchildren and adds them as defined by addItem();
|
|
otherwise returns FALSE. This has effect only for top-level
|
|
layouts, i.e. layouts that are direct tqchildren of their
|
|
mainWidget().
|
|
|
|
autoAdd() is disabled by default.
|
|
|
|
Note that a top-level tqlayout is not necessarily associated with
|
|
the top-level widget.
|
|
|
|
\sa setAutoAdd()
|
|
*/
|
|
|
|
/*!
|
|
If \a b is TRUE, auto-add is enabled; otherwise auto-add is
|
|
disabled.
|
|
|
|
\warning If auto-add is enabled, you cannot set stretch factors
|
|
on the child widgets until the widgets are actually inserted in
|
|
the tqlayout (after control returned to the event loop). We
|
|
therefore recommend that you avoid the auto-add feature in new
|
|
programs.
|
|
|
|
\sa autoAdd()
|
|
*/
|
|
void TQLayout::setAutoAdd( bool b )
|
|
{
|
|
autoNewChild = b;
|
|
}
|
|
|
|
/*!
|
|
\fn bool TQLayout::supportsMargin() const
|
|
|
|
Returns TRUE if this tqlayout supports \l TQLayout::margin on
|
|
non-top-level layouts; otherwise returns FALSE.
|
|
|
|
\sa margin
|
|
*/
|
|
|
|
/*!
|
|
Sets the value returned by supportsMargin(). If \a b is TRUE,
|
|
margin() handling is implemented by the subclass. If \a b is
|
|
FALSE (the default), TQLayout will add margin() around top-level
|
|
layouts.
|
|
|
|
If \a b is TRUE, margin handling needs to be implemented in
|
|
setGeometry(), tqmaximumSize(), tqminimumSize(), tqsizeHint() and
|
|
heightForWidth().
|
|
|
|
\sa supportsMargin()
|
|
*/
|
|
void TQLayout::setSupportsMargin( bool b )
|
|
{
|
|
marginImpl = b;
|
|
}
|
|
|
|
/*!
|
|
Returns the rectangle that should be covered when the tqgeometry of
|
|
this tqlayout is set to \a r, provided that this tqlayout supports
|
|
tqsetAlignment().
|
|
|
|
The result is derived from tqsizeHint() and expandingDirections(). It is never
|
|
larger than \a r.
|
|
*/
|
|
TQRect TQLayout::alignmentRect( const TQRect &r ) const
|
|
{
|
|
TQSize s = tqsizeHint();
|
|
int a = tqalignment();
|
|
|
|
/*
|
|
This is a hack to obtain the real maximum size, not
|
|
TQSize(TQLAYOUTSIZE_MAX, TQLAYOUTSIZE_MAX), the value consistently
|
|
returned by TQLayoutItems that have an tqalignment.
|
|
*/
|
|
TQLayout *that = (TQLayout *) this;
|
|
that->tqsetAlignment( 0 );
|
|
TQSize ms = tqmaximumSize();
|
|
that->tqsetAlignment( a );
|
|
|
|
if ( (expandingDirections() & TQSizePolicy::Horizontally) ||
|
|
!(a & TQt::AlignHorizontal_Mask ) ) {
|
|
s.setWidth( TQMIN(r.width(), ms.width()) );
|
|
}
|
|
if ( (expandingDirections() & TQSizePolicy::Vertically) ||
|
|
!(a & TQt::AlignVertical_Mask) ) {
|
|
s.setHeight( TQMIN(r.height(), ms.height()) );
|
|
} else if ( hasHeightForWidth() ) {
|
|
int hfw = heightForWidth( s.width() );
|
|
if ( hfw < s.height() )
|
|
s.setHeight( TQMIN(hfw, ms.height()) );
|
|
}
|
|
|
|
int x = r.x();
|
|
int y = r.y();
|
|
|
|
if ( a & TQt::AlignBottom )
|
|
y += ( r.height() - s.height() );
|
|
else if ( !(a & TQt::AlignTop) )
|
|
y += ( r.height() - s.height() ) / 2;
|
|
|
|
a = TQApplication::horizontalAlignment( a );
|
|
if ( a & TQt::AlignRight )
|
|
x += ( r.width() - s.width() );
|
|
else if ( !(a & TQt::AlignLeft) )
|
|
x += ( r.width() - s.width() ) / 2;
|
|
|
|
return TQRect( x, y, s.width(), s.height() );
|
|
}
|
|
|
|
/*!
|
|
Removes the widget \a widget from the tqlayout. After this call, it
|
|
is the caller's responsibility to give the widget a reasonable
|
|
tqgeometry or to put the widget back into a tqlayout.
|
|
|
|
\sa removeItem(), TQWidget::setGeometry(), add()
|
|
*/
|
|
void TQLayout::remove( TQWidget *widget )
|
|
{
|
|
TQLayoutIterator it = iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) != 0 ) {
|
|
if ( child->widget() == widget ) {
|
|
it.deleteCurrent();
|
|
tqinvalidate(); // maybe redundant
|
|
TQApplication::postEvent( mainWidget(),
|
|
new TQEvent(TQEvent::LayoutHint) );
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Removes the tqlayout item \a item from the tqlayout. It is the
|
|
caller's responsibility to delete the item.
|
|
|
|
Notice that \a item can be a tqlayout (since TQLayout inherits
|
|
TQLayoutItem).
|
|
|
|
\sa remove(), addItem()
|
|
*/
|
|
void TQLayout::removeItem( TQLayoutItem *item )
|
|
{
|
|
TQLayoutIterator it = iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) != 0 ) {
|
|
if ( child == item ) {
|
|
it.takeCurrent();
|
|
tqinvalidate(); // maybe redundant
|
|
TQApplication::postEvent( mainWidget(),
|
|
new TQEvent(TQEvent::LayoutHint) );
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Enables this tqlayout if \a enable is TRUE, otherwise disables it.
|
|
|
|
An enabled tqlayout adjusts dynamically to changes; a disabled
|
|
tqlayout acts as if it did not exist.
|
|
|
|
By default all layouts are enabled.
|
|
|
|
\sa isEnabled()
|
|
*/
|
|
void TQLayout::setEnabled( bool enable )
|
|
{
|
|
enabled = enable;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the tqlayout is enabled; otherwise returns FALSE.
|
|
|
|
\sa setEnabled()
|
|
*/
|
|
bool TQLayout::isEnabled() const
|
|
{
|
|
return enabled;
|
|
}
|
|
|
|
void TQLayout::propagateSpacing( TQLayout *parent )
|
|
{
|
|
TQLayoutIterator it = parent->iterator();
|
|
TQLayoutItem *child;
|
|
while ( (child = it.current()) ) {
|
|
TQLayout *childLayout = child->tqlayout();
|
|
if ( childLayout && childLayout->insideSpacing < 0 ) {
|
|
childLayout->insideSpacing = parent->insideSpacing;
|
|
propagateSpacing( childLayout );
|
|
}
|
|
++it;
|
|
}
|
|
}
|
|
|
|
#endif // USE_QT4
|
|
|
|
#endif // TQT_NO_LAYOUT
|