[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-panel-devel
Subject: Re: [Panel-devel] [PATCH] Beginnings of a panel implementation for
From: "Robert Knight" <robertknight () gmail ! com>
Date: 2007-08-31 15:03:18
Message-ID: 13ed09c00708310803r63adf02eq45e6a9d31bf42b78 () mail ! gmail ! com
[Download RAW message or body]
Hi,
Updated version of the patch attached in response to initial review by
richmoore.
- Better naming for a few private enums and methods
- Better comments in BoxLayout::Private
- Added support for spacing() and margin()
- Basic testing with nested layouts.
Regards,
Robert.
On 31/08/2007, Robert Knight <robertknight@gmail.com> wrote:
> Hi,
>
> Percy, thanks for doing this, but the current BoxLayout class still
> has some problems, mainly that it does not support the maximumSize()
> or minimumSize() constraints of layout items. expandingDirections()
> turned out to be too crude to work in the task bar.
>
> I also think it is better for the main layout algorithm to be
> direction-agnostic with the direction-specific code elsewhere. I had
> a look at Qt's layout engine and the code is surprisingly complex, we
> can probably get away with something less fancy though.
>
> The attached patch is my work-in-progress rewrite of BoxLayout which
> is 'good enough' for the Panel. In addition to understanding
> maximumSize() and minimumSize() it also has RightToLeft and
> BottomToTop directions. It currently ignores spacing() and margin() ,
> but I will fix that shortly.
>
> Regards,
> Robert.
>
> On 31/08/2007, Aaron J. Seigo <aseigo@kde.org> wrote:
> > On Thursday 30 August 2007, Percy Leonhardt wrote:
> > > On Thursday 23 August 2007, Matt Broadstone wrote:
> > > > If you've got it in you (and the time) please just do this, it will
> > > > make drop in replacement of QH/VBoxLayout when widgets on the canvas
> > > > works trivial.
> > >
> > > Finally I had the time to do this. Attached is a patch for the 3 layout
> > > classes.
> > >
> > > Can I commit this?
> >
> > sure thing.. very cool that you got around to this. less code! yay! =))
> >
> > --
> > Aaron J. Seigo
> > humru othro a kohnu se
> > GPG Fingerprint: 8B8B 2209 0C6F 7C47 B1EA EE75 D6B7 2EB1 A7F1 DB43
> >
> > KDE core developer sponsored by Trolltech
> >
>
["rk_box_layout_v2.patch" (text/x-diff)]
Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt (revision 706509)
+++ CMakeLists.txt (working copy)
@@ -33,8 +33,7 @@
karambamanager.cpp
widgets/boxlayout.cpp
widgets/checkbox.cpp
- widgets/hboxlayout.cpp
widgets/flash.cpp
widgets/icon.cpp
widgets/label.cpp
@@ -46,7 +45,6 @@
widgets/radiobutton.cpp
# widgets/rectangle.cpp
widgets/widget.cpp
- widgets/vboxlayout.cpp
widgets/signalplotter.cpp
)
@@ -105,17 +103,18 @@
install(FILES
widgets/boxlayout.h
widgets/hboxlayout.h
+ widgets/vboxlayout.h
widgets/flash.h
widgets/icon.h
widgets/label.h
widgets/layout.h
+ widgets/layoutanimator.h
widgets/layoutitem.h
widgets/lineedit.h
widgets/pushbutton.h
widgets/checkbox.h
widgets/radiobutton.h
# widgets/rectangle.h
- widgets/vboxlayout.h
widgets/widget.h
widgets/signalplotter.h
DESTINATION ${INCLUDE_INSTALL_DIR}/plasma/widgets)
Index: widgets/boxlayout.h
===================================================================
--- widgets/boxlayout.h (revision 706509)
+++ widgets/boxlayout.h (working copy)
@@ -1,5 +1,6 @@
/*
* Copyright 2007 by Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
+ * Copyright 2007 by Robert Knight <robertknight@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License version 2 as
@@ -27,62 +28,89 @@
namespace Plasma
{
-
/**
- * Vertical Box Layout
- *
- * @author Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
- *
- * This class implements a generic box Layout used as a common API for VBox and HBox implementations.
+ * The BoxLayout class lays out items in a horizontal or vertical line.
*/
class PLASMA_EXPORT BoxLayout : public Layout
{
public:
+ /**
+ * This enum describes the directions in which items can be laid
+ * out.
+ */
+ enum Direction
+ {
+ /** Lay items out horizontally, from left to right. */
+ LeftToRight,
+ /** Lay items out horizontally, from right to left. */
+ RightToLeft,
+ /** Lay items out vertically, from top to bottom. */
+ TopToBottom,
+ /** Lay items out vertically, from bottom to top. */
+ BottomToTop
+ };
/**
- * Constructor.
- */
- explicit BoxLayout(LayoutItem *parent = 0);
-
- /**
- * Destructor.
- */
+ * Creates a new box layout which lays items out in the specified
+ * @p direction
+ */
+ explicit BoxLayout(Direction direction , LayoutItem *parent = 0);
~BoxLayout();
- virtual Qt::Orientations expandingDirections() const;
+ /** Sets the direction in which items are laid out. */
+ void setDirection(Direction direction);
+ /** Returns the direction in which items are laid out. */
+ Direction direction() const;
- QSizeF minimumSize() const;
- QSizeF maximumSize() const;
-
- QRectF geometry() const;
- void setGeometry(const QRectF& geometry);
-
- //TODO: if we turn this into an actually usable layout we need to implement this
- //QSizeF sizeHint() const;
-
- int count() const;
-
- bool isEmpty() const;
-
+ /** Inserts a new item into the layout at the specified index. */
void insertItem(int index, LayoutItem *l);
- void addItem(LayoutItem *l);
+
+ // reimplemented from Layout
+ virtual void addItem(LayoutItem *l);
+ virtual void removeItem(LayoutItem *l);
+ virtual int indexOf(LayoutItem *l) const;
+ virtual LayoutItem *itemAt(int i) const;
+ virtual LayoutItem *takeAt(int i);
+ virtual Qt::Orientations expandingDirections() const;
+ virtual QRectF geometry() const;
+ virtual void setGeometry(const QRectF& geometry);
+ virtual int count() const;
- void removeItem(LayoutItem *l);
+ virtual QSizeF minimumSize() const;
+ virtual QSizeF maximumSize() const;
+ virtual QSizeF sizeHint() const;
- int indexOf(LayoutItem *l) const;
- LayoutItem *itemAt(int i) const;
- LayoutItem *takeAt(int i);
-
- QSizeF size() const;
-
- protected:
- QList<LayoutItem *> children() const;
-
private:
class Private;
Private *const d;
};
+/**
+ * A BoxLayout which defaults to laying items out
+ * horizontally in a left-to-right order.
+ *
+ * Equivalent to creating a BoxLayout and passing LeftToRight
+ * in the constructor.
+ */
+class PLASMA_EXPORT HBoxLayout : public BoxLayout
+{
+public:
+ explicit HBoxLayout(LayoutItem *parent = 0);
+};
+
+/**
+ * A BoxLayout which defaults to laying items out
+ * vertically in a top-to-bottom order.
+ *
+ * Equivalent to creating a BoxLayout and passing TopToBottom
+ * in the constructor.
+ */
+class PLASMA_EXPORT VBoxLayout : public BoxLayout
+{
+public:
+ explicit VBoxLayout(LayoutItem *parent = 0);
+};
+
}
-#endif /* _H_BOX_LAYOUT__ */
+#endif /* PLASMA_BOX_LAYOUT */
Index: widgets/boxlayout.cpp
===================================================================
--- widgets/boxlayout.cpp (revision 706509)
+++ widgets/boxlayout.cpp (working copy)
@@ -1,5 +1,6 @@
/*
* Copyright 2007 by Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
+ * Copyright 2007 by Robert Knight <robertknight@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License version 2 as
@@ -19,32 +20,253 @@
#include "boxlayout.h"
#include <QtCore/QList>
+#include <QtCore/QTimeLine>
#include <KDebug>
+#include "layoutanimator.h"
+
namespace Plasma
{
class BoxLayout::Private
{
- public:
- QRectF geometry;
- QList<LayoutItem *> childList;
+public:
+ BoxLayout *const q;
+ Direction direction;
+ QRectF geometry;
+ QList<LayoutItem*> children;
+
+ Private(BoxLayout *parent)
+ : q(parent)
+ , direction(LeftToRight)
+ {
+ }
+
+ // returns the component of 'size' in the expanding direction
+ // of this layout
+ qreal size(const QSizeF& size) const
+ {
+ switch (direction) {
+ case LeftToRight:
+ case RightToLeft:
+ return size.width();
+ case TopToBottom:
+ case BottomToTop:
+ return size.height();
+ default:
+ Q_ASSERT(false);
+ return 0;
+ }
+ }
+
+ // returns the direction in which this layout expands
+ // or shrinks
+ Qt::Orientation expandingDirection() const
+ {
+ switch ( direction ) {
+ case LeftToRight:
+ case RightToLeft:
+ return Qt::Horizontal;
+ case TopToBottom:
+ case BottomToTop:
+ return Qt::Vertical;
+ default:
+ Q_ASSERT(false);
+ return Qt::Horizontal;
+ }
+ }
+
+ // returns the position from which layouting should
+ // begin depending on the direction of this layout
+ qreal startPos(const QRectF& geometry) const
+ {
+ switch ( direction ) {
+ case LeftToRight:
+ case TopToBottom:
+ return 0;
+ case RightToLeft:
+ return geometry.width();
+ case BottomToTop:
+ return geometry.height();
+ default:
+ Q_ASSERT(false);
+ return 0;
+ }
+ }
+
+ // lays out an item
+ //
+ // 'geometry' the geometry of the layout
+ // 'item' the item whoose geometry should be altered
+ // 'pos' the position of the item (in the expanding direction of the layout)
+ // 'size' the size of the item (in the expanding direction of the layout)
+ //
+ // returns the position for the next item in the layout
+ //
+ qreal layoutItem(const QRectF& geometry , LayoutItem *item , const qreal pos , qreal size)
+ {
+ qDebug() << "layoutItem: " << direction << "item size" << size;
+
+ QRectF newGeometry;
+ qreal newPos = 0;
+
+ qreal top = 0;
+ qreal height = 0;
+
+ QSizeF minSize = item->minimumSize();
+ QSizeF maxSize = item->maximumSize();
+ switch ( direction ) {
+ case LeftToRight:
+ case RightToLeft:
+ height = qBound(minSize.height(),geometry.height(),maxSize.height());
+ top = geometry.top();
+ break;
+ case TopToBottom:
+ case BottomToTop:
+ height = qBound(minSize.width(),geometry.width(),maxSize.width());
+ top = geometry.left();
+ break;
+ }
+
+ switch ( direction ) {
+ case LeftToRight:
+ newGeometry = QRectF(pos,top,size,height);
+ newPos = pos+size+q->spacing();
+ break;
+ case RightToLeft:
+ newGeometry = QRectF(geometry.width()-pos-size,top,
+ size,height);
+ newPos = pos-size-q->spacing();
+ break;
+ case TopToBottom:
+ newGeometry = QRectF(top,pos,height,size);
+ newPos = pos+size+q->spacing();
+ break;
+ case BottomToTop:
+ newGeometry = QRectF(top,geometry.height()-pos-size,
+ height,size);
+ newPos = pos-size-q->spacing();
+ break;
+ }
+
+ // qDebug() << "Item geometry: " << newGeometry;
+
+ if ( q->animator() )
+ q->animator()->setGeometry(item,newGeometry);
+ else
+ item->setGeometry(newGeometry);
+
+ return newPos;
+ }
+
+ enum SizeType
+ {
+ MinSize,
+ MaxSize,
+ HintSize
+ };
+
+ // this provides a + function which can be passed as the 'op'
+ // argument to calculateSize
+ static qreal sum(const qreal a , const qreal b)
+ {
+ return a+b;
+ }
+
+ // calcualtes a size hint or value for this layout
+ // 'sizeType' - The item size ( minimum , maximum , hint ) to use
+ // 'dir' - The direction component of the item size to use
+ // 'op' - A function to apply to the size of each item in the layout
+ // , usually qMax,qMin or sum
+ template <class T>
+ qreal calculateSize(SizeType sizeType , Qt::Orientation dir , T (*op)(T,T)) const
+ {
+ qreal value = 0;
+ for ( int i = 0 ; i < children.count() ; i++ ) {
+
+ QSizeF itemSize;
+ switch ( sizeType ) {
+ case MinSize:
+ itemSize = children[i]->minimumSize();
+ break;
+ case MaxSize:
+ itemSize = children[i]->maximumSize();
+ break;
+ case HintSize:
+ itemSize = children[i]->sizeHint();
+ break;
+ }
+
+ if ( dir == Qt::Horizontal ) {
+ value = op(value,itemSize.width());
+ } else {
+ value = op(value,itemSize.height());
+ }
+ }
+
+ return value;
+ }
+
+ // calculates a size hint or value for this layout
+ // 'calculateSizeType' specifies the value to be calculated
+ QSizeF calculateSize(SizeType calculateSizeType) const
+ {
+ QSizeF result;
+
+ const qreal totalMargin = q->margin() * 2;
+ const qreal totalSpacing = q->spacing() * (children.count()-1);
+
+ switch ( direction ) {
+ case LeftToRight:
+ case RightToLeft:
+ result = QSizeF(calculateSize(calculateSizeType,Qt::Horizontal,sum),
+ calculateSize(calculateSizeType,Qt::Vertical,qMax<qreal>));
+
+ result.rwidth() += totalMargin + totalSpacing;
+ result.rheight() += totalMargin;
+
+ break;
+ case TopToBottom:
+ case BottomToTop:
+ result = QSizeF(calculateSize(calculateSizeType,Qt::Horizontal,qMax<qreal>),
+ calculateSize(calculateSizeType,Qt::Vertical,sum));
+
+ result.rheight() += totalMargin + totalSpacing;
+ result.rwidth() += totalMargin;
+
+ break;
+ }
+
+ return result;
+ }
};
-BoxLayout::BoxLayout(LayoutItem *parent)
+BoxLayout::BoxLayout(Direction direction , LayoutItem *parent)
: Layout(parent),
- d(new Private)
+ d(new Private(this))
{
if (parent) {
parent->setLayout(this);
}
+
+ d->direction = direction;
}
+void BoxLayout::setDirection(Direction direction)
+{
+ d->direction = direction;
+ update();
+}
+BoxLayout::Direction BoxLayout::direction() const
+{
+ return d->direction;
+}
+
BoxLayout::~BoxLayout()
{
- foreach (LayoutItem* item, children()) {
+ foreach (LayoutItem* item, d->children) {
item->unsetManagingLayout(this);
}
delete d;
@@ -52,97 +274,198 @@
Qt::Orientations BoxLayout::expandingDirections() const
{
- return Qt::Vertical | Qt::Horizontal;
+ switch ( d->direction ) {
+ case LeftToRight:
+ case RightToLeft:
+ return Qt::Horizontal;
+ case TopToBottom:
+ case BottomToTop:
+ return Qt::Vertical;
+ default:
+ Q_ASSERT(false);
+ return 0;
+ }
}
-QSizeF BoxLayout::minimumSize() const
-{
- return QSizeF();
-}
-
-QSizeF BoxLayout::maximumSize() const
-{
- return QSizeF();
-}
-
QRectF BoxLayout::geometry() const
{
return d->geometry;
}
-void BoxLayout::setGeometry(const QRectF& geometry)
-{
- d->geometry = geometry;
-}
-
int BoxLayout::count() const
{
- return d->childList.count();
+ return d->children.count();
}
-bool BoxLayout::isEmpty() const
+void BoxLayout::insertItem(int index, LayoutItem *item)
{
- return count() == 0;
-}
-
-void BoxLayout::insertItem(int index, LayoutItem *l)
-{
- if (!l) {
+ if (!item) {
return;
}
- //l->setLayout(this);
- d->childList.insert(index, l);
- setGeometry(geometry());
+ item->setManagingLayout(this);
+
+ if ( index == -1 )
+ index = d->children.size();
+
+ d->children.insert(index, item);
+
+ if ( animator() )
+ animator()->setCurrentState(item,LayoutAnimator::InsertedState);
+
+ update();
}
-void BoxLayout::addItem(LayoutItem *l)
+void BoxLayout::addItem(LayoutItem *item)
{
- if (!l) {
- return;
- }
-
- l->setManagingLayout(this);
- d->childList.append(l);
- setGeometry(geometry());
+ insertItem(-1,item);
}
-void BoxLayout::removeItem(LayoutItem *l)
+void BoxLayout::removeItem(LayoutItem *item)
{
- if (!l) {
+ if (!item) {
return;
}
- l->unsetManagingLayout(this);
- d->childList.removeAll(l);
- setGeometry(geometry());
+ item->unsetManagingLayout(this);
+ d->children.removeAll(item);
+
+ if ( animator() )
+ animator()->setCurrentState(item,LayoutAnimator::RemovedState);
+
+ update();
}
int BoxLayout::indexOf(LayoutItem *l) const
{
- return d->childList.indexOf(l);
+ return d->children.indexOf(l);
}
LayoutItem *BoxLayout::itemAt(int i) const
{
- return d->childList[i];
+ return d->children[i];
}
LayoutItem *BoxLayout::takeAt(int i)
{
- return d->childList.takeAt(i);
+ return d->children.takeAt(i);
- setGeometry(geometry());
+ update();
}
-QSizeF BoxLayout::size() const
+void BoxLayout::setGeometry(const QRectF& geo)
{
- return d->geometry.size();
+ QRectF geometry = geo.adjusted(margin(),margin(),-margin(),-margin());
+
+ qDebug() << "geo before " << geo << "after" << geometry << "margin" << margin();
+ //qDebug() << "Box layout beginning with geo" << geometry;
+ //qDebug() << "This box max size" << maximumSize();
+
+ QVector<qreal> sizes(count());
+ QVector<qreal> expansionSpace(count());
+
+ qreal available = d->size(geometry.size()) - spacing()*(d->children.count()-1);
+ qreal perItemSize = available / count();
+
+ // initial distribution of space to items
+ for ( int i = 0 ; i < sizes.count() ; i++ ) {
+ const LayoutItem *item = d->children[i];
+
+ const bool isExpanding = item->expandingDirections() & d->expandingDirection();
+
+ if ( isExpanding )
+ sizes[i] = perItemSize;
+ else
+ sizes[i] = d->size(item->sizeHint());
+
+ const qreal minItemSize = d->size(item->minimumSize());
+ const qreal maxItemSize = d->size(item->maximumSize());
+
+ // qDebug() << "Layout max item " << i << "size: " << maxItemSize;
+
+ sizes[i] = qMin( sizes[i] , maxItemSize );
+ sizes[i] = qMax( sizes[i] , minItemSize );
+
+ // qDebug() << "Available: " << available << "per item:" << perItemSize <<
+ // "Initial size: " << sizes[i];
+
+ if ( isExpanding )
+ expansionSpace[i] = maxItemSize-sizes[i];
+ else
+ expansionSpace[i] = 0;
+
+ // adjust the per-item size if the space was over or under used
+ if ( sizes[i] != perItemSize && i != sizes.count()-1 ) {
+ perItemSize = available / (sizes.count()-i-1);
+ }
+
+ available -= sizes[i];
+ }
+
+ // distribute out any remaining space to items which can still expand
+ //
+ // space is distributed equally amongst remaining items until we run
+ // out of space or items to expand
+ int expandable = sizes.count();
+ const qreal threshold = 1.0;
+ while ( available > threshold && expandable > 0 ) {
+
+ qreal extraSpace = available / expandable;
+ for ( int i = 0 ; i < sizes.count() ; i++ ) {
+ if ( expansionSpace[i] > threshold ) {
+ qreal oldSize = sizes[i];
+
+ sizes[i] += qMin(extraSpace,expansionSpace[i]);
+
+ expansionSpace[i] -= sizes[i]-oldSize;
+ available -= sizes[i]-oldSize;
+ } else {
+ expandable--;
+ }
+ }
+ }
+
+ // set items' geometry according to new sizes
+ qreal pos = d->startPos(geometry);
+ for ( int i = 0 ; i < sizes.count() ; i++ ) {
+
+ //QObject *obj = dynamic_cast<QObject*>(d->children[i]);
+ //if ( obj )
+ //qDebug() << "Item " << i << obj->metaObject()->className() << "size:" << sizes[i];
+
+ pos = d->layoutItem( geometry , d->children[i] , pos , sizes[i] );
+ }
+
+ d->geometry = geometry;
+
+ if ( animator() && animator()->timeLine() )
+ animator()->timeLine()->start();
}
-QList<LayoutItem *> BoxLayout::children() const
+
+QSizeF BoxLayout::maximumSize() const
{
- return d->childList;
+ return Layout::maximumSize();
}
+QSizeF BoxLayout::minimumSize() const
+{
+ return d->calculateSize(Private::MinSize);
+}
+QSizeF BoxLayout::sizeHint() const
+{
+ return d->calculateSize(Private::HintSize);
+}
+HBoxLayout::HBoxLayout(LayoutItem *parent)
+ : BoxLayout(LeftToRight,parent)
+{
+}
+
+VBoxLayout::VBoxLayout(LayoutItem *parent)
+ : BoxLayout(TopToBottom,parent)
+{
+}
+
+
} // Plasma namespace
+
Index: widgets/hboxlayout.h
===================================================================
--- widgets/hboxlayout.h (revision 706509)
+++ widgets/hboxlayout.h (working copy)
@@ -1,5 +1,5 @@
/*
- * Copyright 2007 by Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
+ * Copyright 2007 by Robert Knight <robertknight@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License version 2 as
@@ -16,54 +16,9 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#ifndef __H_BOX_LAYOUT__
-#define __H_BOX_LAYOUT__
+#ifndef PLASMA_HBOXLAYOUT
+#define PLASMA_HBOXLAYOUT
-#include <QtCore/QRectF>
-#include <QtCore/QSizeF>
-
-#include <plasma/plasma_export.h>
#include <plasma/widgets/boxlayout.h>
-namespace Plasma
-{
-
-
-/**
- * Vertical Box Layout
- *
- * @author Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
- *
- * This class implements a Horizontal Box Layout, it just lays items horizontally, from left to right.
- */
-class PLASMA_EXPORT HBoxLayout : public BoxLayout
-{
- public:
-
- /**
- * Constructor.
- */
- HBoxLayout(LayoutItem *parent = 0);
-
- /**
- * Virtual Destructor.
- */
- virtual ~HBoxLayout();
-
- Qt::Orientations expandingDirections() const;
-
- bool hasWidthForHeight() const;
- qreal widthForHeight(qreal w) const;
-
- void setGeometry(const QRectF& geometry);
-
- QSizeF sizeHint() const;
-
- private:
- class Private;
- Private *const d;
-};
-
-}
-
-#endif /* __H_BOX_LAYOUT__ */
+#endif /* PLASMA_HBOXLAYOUT */
Index: widgets/vboxlayout.h
===================================================================
--- widgets/vboxlayout.h (revision 706509)
+++ widgets/vboxlayout.h (working copy)
@@ -1,5 +1,5 @@
/*
- * Copyright 2007 by Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
+ * Copyright 2007 by Robert Knight <robertknight@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License version 2 as
@@ -19,48 +19,6 @@
#ifndef PLASMA_VBOXLAYOUT
#define PLASMA_VBOXLAYOUT
-#include <plasma/plasma_export.h>
#include <plasma/widgets/boxlayout.h>
-namespace Plasma
-{
-
-
-/**
- * Vertical Box Layout
- *
- * @author Matias Valdenegro T. <mvaldenegro@informatica.utem.cl>
- *
- * This class implements a Vertical Box Layout, it just lays items in vertical, from up to down.
- */
-class PLASMA_EXPORT VBoxLayout : public BoxLayout
-{
- public:
-
- /**
- * Constructor.
- */
- explicit VBoxLayout(LayoutItem *parent = 0);
-
- /**
- * Virtual Destructor.
- */
- ~VBoxLayout();
-
- Qt::Orientations expandingDirections() const;
-
- bool hasHeightForWidth() const;
- qreal heightForWidth(qreal w) const;
-
- void setGeometry(const QRectF& geometry);
-
- QSizeF sizeHint() const;
-
- private:
- class Private;
- Private *const d;
-};
-
-}
-
#endif /* PLASMA_VBOXLAYOUT */
_______________________________________________
Panel-devel mailing list
Panel-devel@kde.org
https://mail.kde.org/mailman/listinfo/panel-devel
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic