layout.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_LAYOUT_H
#define WT_LAYOUT_H

#include <wt/object.h>
#include <wt/wvar.h>
#include <wt/sizepolicy.h>
#include <wt/size.h>
#include <wt/rect.h>
#include <wt/trace.h>
#include <wt/flags.h>

namespace Wt {

class LayoutItem;
class Widget;
class LayoutHintEvent;

/*
We cannot possibly split the design to ContainerInterface and IteratorInterface
because we can't return Iterator* from std containers
*/
class LayoutIteratorInterface {
public:
    virtual ~LayoutIteratorInterface() {}
    virtual LayoutItem* operator*() const = 0;
    virtual bool operator!=(const LayoutIteratorInterface& other) const = 0;
    bool operator==(const LayoutIteratorInterface& other) const {
        return !(**this != *other);
    }
    //postfix only
    virtual LayoutIteratorInterface& operator++(int) = 0;

    // we bastardize iterator and container here
    virtual void start() = 0;
    virtual bool finish() = 0;
    virtual LayoutItem* pop() = 0;
};

class NullLayoutIterator : public LayoutIteratorInterface {
public:
    virtual LayoutItem* operator*() const {
        return 0;
    }
    virtual bool operator!=(const LayoutIteratorInterface&) const {
        return false;
    }
    //postfix only
    virtual NullLayoutIterator& operator++(int) {
        return *this;
    }

    // we bastardize iterator and container here
    virtual void start() {}
    virtual bool finish() {
        return true;
    }
    virtual LayoutItem* pop() {
        return 0;
    }
};

class LayoutIterator {
public:
    /// we cannot avoid the pointer here since we need the virtualized behaviour
    LayoutIterator(LayoutIteratorInterface * li) :
    li_(li) {}
    ~LayoutIterator () {
        delete li_;
    }
    LayoutItem* operator*() const {
        return **li_;
    }
    LayoutIterator operator=(const LayoutIterator &i) {
        return li_ = i.li_;
    }
    bool operator!=(const LayoutIteratorInterface& other) const {
        return (**li_ != *other);
    }
    //postfix only
    LayoutIterator& operator++(int) {
        (*li_)++;
        return *this;
    }
    // we bastardize iterator and container here
    void start() {
        return li_->start();
    }
    bool finish() {
        return li_->finish();
    }
    LayoutItem* pop() {
        return li_->pop();
    }

private:
    LayoutIteratorInterface *li_;
};

/// all layoutItems should inherit from this. It's their interface
/*!
The following functions must be reimplemented
 - setGeometry()
 - isEmpty() const;
 - hasHeightForWidth()
 - heightForWidth()
 - iterator()
*/
class LayoutItem {
public:
    LayoutItem(int alignment = AlignAuto,
               const SizePolicy& size_policy = SizePolicy(),
               const Size& size_hint = Size(default_hint_size, default_hint_size),
               const Size& minimum_size = Size(default_min_size, default_min_size),
               const Size& maximum_size = Size(default_max_size, default_max_size)) :
            alignment(alignment),
            invalidated_(true),
            size_policy_(size_policy),
            size_hint_(size_hint),
            minimum_size_(minimum_size),
    maximum_size_(maximum_size) {}

    virtual ~LayoutItem() {}

    virtual Size sizeHint() const {
        return size_hint_;
    }

    virtual Size minimumSize() const {
        return minimum_size_;
    }
    virtual void setMinimumSize(const Size& size) {
        minimum_size_ = size;
    }

    virtual Size maximumSize() const {
        return maximum_size_;
    }
    virtual void setMaximumSize(const Size& size) {
        maximum_size_ = size;
    }

    virtual SizePolicy sizePolicy() const {
        return size_policy_;
    }

    virtual void setSizePolicy(const SizePolicy& size_policy) {
        size_policy_ = size_policy;
    }

    virtual SizePolicy::ExpandData expanding() const {
        return size_policy_.expandData;
    }

    /// return the widget's geometry relative to its parent
    virtual const Rect& geometry() const {
        return geometry_rect_;
    }

    //  --- necessary interface --- default implementations
    virtual void setGeometry(const Rect& r) {
        geometry_rect_ = r;
    }

    virtual bool isEmpty() const {
        return false;
    }

    bool isNonEmpty() const {
        return (this) ? !isEmpty() : false;
    }

    virtual bool hasHeightForWidth() const {
        return false;
    }
    virtual int heightForWidth(int) const {
        return -1;
    }

    virtual LayoutIterator iterator() {
        return LayoutIterator(new NullLayoutIterator());
    }

    template<typename TEST_TYPE>
    TEST_TYPE type() const {
        return dynamic_cast<TEST_TYPE>(const_cast<LayoutItem *>(this));
    }

    template<typename TEST_TYPE>
    bool is() const {
        return (type<TEST_TYPE>() != 0);
    }

    // sensible defaults
    static const int default_max_size = ((int) ((unsigned int) (~0) >> 1));
    static const int default_min_size = 30;
    static const int default_hint_size = 100;

    WVar<int> alignment;

protected:
    void invalidateRecursively();

    virtual void validate() {
        invalidated_ = false;
    }

    bool invalidated() const {
        return invalidated_;
    }

    virtual void setSizeHint(const Size& size) {
        size_hint_ = size;
    }

private:
    bool invalidated_;
    SizePolicy size_policy_;
    Size size_hint_;
    Size minimum_size_;
    Size maximum_size_;
    Rect geometry_rect_;
};

/// handles the layout of widgets
/*!
The Layout class takes ownership of child layouts (Objects),
and other layoutitems that are not widgets. Widgets have their
own ierarchy and so a Layout absolutely does not delete Widgets,
in any way.
 
Layouts will be deleted when the parent layout dies or when they
are explictely deleted. The rest of the layout items (spacer)
will be deleted on Layout::remove() and/or ~Layout().
 
In the mean time however, we keep track of all these pointers into
our container layout and layout actively syncronizes the list when
a child is deleted.
 
In short: Layout contains LayoutItems. LayoutItems can be Layouts,
Widgets and Spacers. Layouts are also children to parent Layout.
 
                      Layout Widgets Spacer
Deleted on remove       y       n      y
Deleted on ~Layout      y       n      y
removed on deletion     y       y      *
 
* don't do that. That objects are now belong to Layout and cannot
be deleted safely since they are not Objects. If you want them to
be deleted remove them from the Layout via Layout::remove()
 
*/
class Layout : public Object, public LayoutItem {
public:
    Layout(Widget *parent, int margin = 0, int spacing = -1,
           const std::string &name = "Layout::anon");
    Layout(Layout * parentLayout, int margin = 0, int spacing = -1,
           const std::string &name = "Layout::anon");
    Layout(int spacing = -1, const std::string &name = "Layout::anon");
    virtual ~Layout() {
        Layout *l = dynamic_cast<Layout *>(parent());
        if (l) {
            l->markDeleted(this);
            l->removeItem(this);
        }
    }

    Widget *mainWidget() const;
    bool isTopLevel() const;

    virtual Size sizeHint() const;
    virtual Size minimumSize() const;
    // The reason we need this if Layout parent is a Layout (in constructor)
    virtual void addItem(LayoutItem *li);

    /// returns true if a layoutitem is actually removed
    virtual bool removeItem(LayoutItem *li);

    virtual bool eventFilter(Object *, Event *);

    virtual void setGeometry(const Rect& r);

    WVar<int> margin;
    WVar<int> spacing;
    WVar<bool> autoAdd;

protected:
    virtual bool onAboutToChangeAutoAdd(bool auto_add);
    virtual int onSpacingOverride(int spacing);
    void adjustMaximumSize(int margin);
    virtual bool exists(const LayoutItem *li) const = 0;
    void markDeleted(LayoutItem *li) {
        deleted_li_ = li;
    }
    bool isDeleted(LayoutItem *li) const {
        return deleted_li_ == li;
    }
    void enforce();
    void postLayoutHintEvent();

    void setWidthasPrimaryLength(bool width = true);
    bool isWidthPrimaryLength() const {
        return width_as_primary_length;
    }

    template<typename TYPE>
    int primaryLength(const TYPE& t) const {
        return (width_as_primary_length) ? t.width() : t.height();
    }

    int preferredLength(const LayoutItem *li, bool expand) const;

    template<typename TYPE>
    int secondaryLength(const TYPE& t) const;

    template<typename TYPE>
    int primaryOffset(const TYPE& t) const;

    template<typename TYPE>
    int secondaryOffset(const TYPE& t) const;

    Point getPoint(int primary_offset, int secondary_offset) const;
    Size getSize(int primary, int secondary) const;
    Rect getRect(int primary_offset, int secondary_offset,
                 int primary_size, int secondary_size) const;

    int primaryStretch(const SizePolicy& sp) const;
    bool mayGrowPrimally(const SizePolicy& sp) const;
    bool mayShrinkPrimally(const SizePolicy& sp) const;
    bool expandingPrimally(const SizePolicy& sp) const;

private:
    void on_wobject_item_death(const Object *obj);
    LayoutItem *deleted_li_;

    void init();
    bool width_as_primary_length;
};

class NullClass {
public:
};

template <typename ValueType = NullClass>
class LayoutItemCompound {
public:
    typedef ValueType LayoutItemValue;

    LayoutItemCompound(const LayoutItem * li_ = 0,
                       const LayoutItemValue& val = LayoutItemValue()) :
    li(const_cast<LayoutItem *>(li_)), value(val) {}

    operator LayoutItem *() const {
        return li;
    }

    operator const LayoutItemValue& () const {
        return value;
    }

    operator LayoutItemValue& () {
        return value;
    }

    bool operator==(const LayoutItemCompound& other) const {
        return li == other.li;
    }

    bool operator==(const LayoutItem *other) const {
        return li == other;
    }

private:
    LayoutItem *li;
    LayoutItemValue value;
};

template <typename Container>
class LayoutStdContainerIterator : public LayoutIteratorInterface {
public:
    typedef typename Container::value_type Compound;
    LayoutStdContainerIterator(Container& container) :
            container_(container),
    end(container_.end()) {}

    virtual LayoutItem* operator*() const {
        return *it_;
    }

    typename Compound::LayoutItemValue& value() {
        return *it_;
    }

    virtual bool operator!=(const LayoutIteratorInterface& other) const {
        return *it_ != *other;
    }

    //postfix only
    virtual LayoutStdContainerIterator& operator++(int) {
        ++it_;
        return *this;
    }

    // we bastardize iterator and container here
    virtual void start() {
        it_ = container_.begin();
    }
    virtual bool finish() {
        return (it_ == end);
    }
    virtual LayoutItem* pop() {
        LayoutItem *li = *it_;
        container_.erase(it_);
        return li;
    }

private:
    Container& container_;
    typename Container::iterator it_;
    typename Container::iterator end;
};

/*!
 Each LayoutItem is possible associated with a value class where the
 the Layout can store effective or current configuration per item.
 The way to access this value field is via the operator[] or by
 the value() function. Both are equivalents and return a reference
 to the value part of the compound type. Access is going through a
 limited (one item only) cache scheme.
 
 The ways to access the value part are:
 (*this)[li].stretch = 1;
 or
 XXXLayout& self(*this);
 self[li].stretch = 1;
 or
 value(li).stretch = 1;
 
 where stretch is a member of the value part of the compound type
*/
template <typename Container>
class LayoutStdContainer : public Layout, public Container {
public:
    typedef typename Container::value_type Compound;
    LayoutStdContainer(Widget *parent, int margin = 0, int spacing = -1,
                       const std::string &name = "StdLayout::anon") :
            Layout(parent, margin, spacing, name),
    cached_li_(0) {}

    LayoutStdContainer(Layout * parent_layout, int margin = 0, int spacing = -1,
                       const std::string &name = "StdLayout::anon") :
            Layout(parent_layout, margin, spacing, name),
    cached_li_(0) {}

    LayoutStdContainer(int spacing = -1, const std::string &name = "StdLayout::anon") :
            Layout(spacing, name),
    cached_li_(0) {}

    ~LayoutStdContainer() {
        for (typename Container::iterator it(Container::begin()),
                e(Container::end()); it != e;) {
            LayoutItem *li = *it;
            // Delete only non Objects, Objects will be deleted by ~Object()
            if (li && !li->is<Object *>()) {
                delete li;
            }
            it = Container::erase(it);
        }
    }

    virtual bool isEmpty() const {
        return Container::empty();
    }

    // you cannot have multiple inheritance in order to fill up pure virtual functions
    virtual void addItem(LayoutItem *li) {
        Layout::addItem(li);
        Container::push_back(li);
    }

    virtual bool removeItem(LayoutItem *li) {
        bool exist = Layout::removeItem(li);
        if (exist) {
            Container::remove
                (li);
        }
        return exist;
    }

    virtual LayoutIterator iterator() {
        return LayoutIterator(new LayoutStdContainerIterator<Container>(*this));
    }

protected:
    virtual bool exists(const LayoutItem *li) const {
        typename Container::const_iterator end = Container::end();
        typename Container::const_iterator p = find(Container::begin(), end, li);
        return (p != end);
    }

    typename Compound::LayoutItemValue& value(const LayoutItem *li) {
        if (li != cached_li_) {
            cached_li_ = li;
            cached_it_ = find(Container::begin(), Container::end(), li);
        }
        return (cached_it_ != Container::end()) ? *cached_it_ : null_;
    }

    typename Compound::LayoutItemValue& operator[](const LayoutItem *li) {
        return value(li);
    }

private:
    const LayoutItem *cached_li_;
    typename Container::iterator cached_it_;
    typename Compound::LayoutItemValue null_;
};

class BoxLayoutItemValue {
public:
    BoxLayoutItemValue() :
            stretch(0),
    extra_space(0) {}

    int stretch;
    int extra_space;
};

typedef LayoutItemCompound<BoxLayoutItemValue> BoxLayoutItemCompound;
typedef std::list<BoxLayoutItemCompound> BoxLayoutItemList;

class BoxLayoutIterator : public LayoutStdContainerIterator<BoxLayoutItemList> {
public:
    BoxLayoutIterator(BoxLayoutItemList& list) :
    LayoutStdContainerIterator<BoxLayoutItemList>(list) {}
private:
};

/*!
 - stretch beats expanding
 - expanding beats mayGrow
 - expanding and or stretch does not propagate outside layout
 - if there is stretch turns on expanding
 
 The extra space is first divided between layout items with a stretch value.
 If there is none then the space is divided among expanding layout items. If there
 is none then space is divided among layout items that have the mayGrow flag set.
*/
typedef LayoutStdContainer<BoxLayoutItemList> BoxLayoutBase;
class BoxLayout : public BoxLayoutBase {
public:
    friend class Box;

    typedef enum  {
        LeftToRight,
        RightToLeft,
        TopToBottom,
        BottomToTop,
        Down = TopToBottom,
        Up = BottomToTop
    } Direction;

    BoxLayout(Widget *parent, Direction direction, int margin = 0,
              int spacing = -1, const std::string &name = "BoxLayout::anon") :
            BoxLayoutBase(parent, margin, spacing, name),
    direction(direction) {
        setWidthasPrimaryLength(direction == LeftToRight ||
                                direction == RightToLeft);
    }

    BoxLayout(Layout * parent_layout, Direction direction, int margin = 0,
              int spacing = -1, const std::string &name = "BoxLayout::anon") :
            BoxLayoutBase(parent_layout, margin, spacing, name),
    direction(direction) {
        setWidthasPrimaryLength(direction == LeftToRight ||
                                direction == RightToLeft);
    }

    BoxLayout(Direction direction, int spacing = -1,
              const std::string &name = "BoxLayout::anon") :
            BoxLayoutBase(spacing, name),
    direction(direction) {
        setWidthasPrimaryLength(direction == LeftToRight ||
                                direction == RightToLeft);
    }

    Direction direction;

    virtual void appendItem(LayoutItem *li);
    virtual void prependItem(LayoutItem *li);
    virtual void addItem(LayoutItem *li);
    virtual void setGeometry(const Rect& r);

protected:
    virtual void validate();
};

class HBoxLayout : public BoxLayout {
public:
    HBoxLayout(Widget *parent, int margin = 0, int spacing = -1,
               const std::string &name = "HBoxLayout::anon") :
    BoxLayout(parent, LeftToRight, margin, spacing, name) {}

    HBoxLayout(Layout * parent_layout, int margin = 0, int spacing = -1,
               const std::string &name = "HBoxLayout::anon") :
    BoxLayout(parent_layout, LeftToRight, margin, spacing, name) {}

    HBoxLayout(int spacing = -1, const std::string &name = "HBoxLayout::anon") :
    BoxLayout(LeftToRight, spacing, name) {}

private:
};

class VBoxLayout : public BoxLayout {
public:
    VBoxLayout(Widget *parent, int margin = 0, int spacing = -1,
               const std::string &name = "VBoxLayout::anon") :
    BoxLayout(parent, Down, margin, spacing, name) {}

    VBoxLayout(Layout * parent_layout, int margin = 0, int spacing = -1,
               const std::string &name = "VBoxLayout::anon") :
    BoxLayout(parent_layout, Down, margin, spacing, name) {}

    VBoxLayout(int spacing = -1, const std::string &name = "VBoxLayout::anon") :
    BoxLayout(Down, spacing, name) {}

private:
};

} // namespace

#endif // WT_LAYOUT_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.