layout.cpp

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.
*/

#include <wt/application.h>
#include <wt/event.h>
#include <wt/window.h>
#include <wt/layout.h>

namespace Wt {

void LayoutItem::invalidateRecursively() {
    // if null means empty item. don't bother (used on Grid)
    // we can't handle it in isEmpty() because it is virtual
    // and the null dereference crashes
    trace("layout") << "Trying to invalidate " << this
    << " == "  << dynamic_cast<Object *>(this) << std::endl;
    if (isNonEmpty()) {
        trace("layout") << "Invalidating " << this << std::endl;
        LayoutIterator it = iterator();
        invalidated_ = true;
        for (it.start(); !it.finish(); it++) {
            LayoutItem *li = *it;
            li->invalidateRecursively();
        }
        trace("layout") << "Invalidation finished " << this << std::endl;
    }
}

int Layout::onSpacingOverride(int sp) {
    return (sp == -1) ? static_cast<int>(margin) : sp;
}

void Layout::adjustMaximumSize(int margin) {
    setMaximumSize(maximumSize() >> margin);
}

void Layout::init() {
    autoAdd.aboutToChange.connect(
        sigc::slot1<bool, bool>(
            sigc::mem_fun(*this, &Layout::onAboutToChangeAutoAdd)));

    spacing.override.connect(
        sigc::slot1<int, int>(
            sigc::mem_fun(*this, &Layout::onSpacingOverride)));

    sigc::slot0<void> post_layouthint_slot = sigc::mem_fun(*this,
            &Layout::postLayoutHintEvent);

    spacing.changed.connect(post_layouthint_slot);

    margin.changed.connect(
        sigc::slot1<void, int>(
            sigc::mem_fun(*this,
                          &Layout::adjustMaximumSize)));
    margin.changed.connect(post_layouthint_slot);

    adjustMaximumSize(margin);
}

Layout::Layout(Widget *parent, int margin, int spacing,
               const std::string &name)
        : Object(parent, name),
        LayoutItem(),
        margin(margin),
        spacing(spacing),
        autoAdd(false),
        deleted_li_(0),
width_as_primary_length(true) {
    init();
    if (parent)
        parent->setLayout(this);
    Application::sendPostedEvents();
}

Layout::Layout(Layout * parent, int margin, int spacing,
               const std::string &name)
        : Object(parent, name),
        LayoutItem(),
        margin(margin),
        spacing(spacing),
        autoAdd(false),
        deleted_li_(0),
width_as_primary_length(true) {
    init();
    parent->addItem(this);
    Application::sendPostedEvents();
}

Layout::Layout(int spacing, const std::string &name)
        : Object(0, name),
        LayoutItem(),
        margin(0),
        spacing(spacing),
        autoAdd(false),
        deleted_li_(0),
width_as_primary_length(true) {
    init();
    Application::sendPostedEvents();
}

Widget *Layout::mainWidget() const {
    const Object *p = this;
    while ((p = p->parent())) {
        Widget *w = dynamic_cast<Widget *>(const_cast<Object *>(p));
        if (w) {
            return w;
        }
    }
    return 0;
}

bool Layout::isTopLevel() const {
    return (parent() && mainWidget() == parent());
}

bool Layout::onAboutToChangeAutoAdd(bool auto_add) {
    return (auto_add && !isTopLevel());
}

void Layout::postLayoutHintEvent() {
    if (mainWidget()) {
        Application::postEvent(mainWidget(), new LayoutHintEvent());
    }
}

void Layout::addItem(LayoutItem *li) {
    assert(!exists(li));

    // Here we care only for rogue add statements of fully created
    // objects and if they are layouts we put them under our
    // ownership. If li is already children of this then reparent
    // is a nop
    Layout *l;
    Object *child;
    if ((l = li->type<Layout *>())) {
        l->reparent(this);
    } else if ((child = li->type<Object *>())) {
        child->destroyed.connect(
            sigc::slot1<void, const Object *>(
                sigc::mem_fun(*this, &Layout::on_wobject_item_death)));
    }
    postLayoutHintEvent();
}

bool Layout::removeItem(LayoutItem *li) {
    bool exist = exists(li);
    // It is possible to be asked to remove a non existing li
    if (exist) {
        // Delete only non Objects, Objects will be deleted by ~Object()
        // also delete child layouts here when removed but do not delete
        // them again if they are already deleted

        if (!isDeleted(li) && (li->is<Layout *>() || !li->is<Object *>())
           ) {
            delete li;
        }

        postLayoutHintEvent();
    }
    return exist;
}

void Layout::on_wobject_item_death(const Object *obj) {
    // we cannot do dynamic_cast because Widget does not exist anymore
    Widget *w = static_cast<Widget *>(const_cast<Object *>(obj));
    LayoutItem *li = static_cast<LayoutItem *>(w);
    // do not delete this bastard. It is alerady deleted
    markDeleted(li);
    removeItem(li);
}

/*!
  we get events from the mainWidget only if exists. The type of events are:
   - ChildEvent (Inserted or ChildRemoved)
   - ResizeEvent
   - LayoutHintEvent
 
   The following uses cases has to be covered:
    - case 1: A widget w deep in the hierarchy changes something
    (sizeHint, minimumSize, sizePolicy etc..)
    - case 2: insert/remove layout item
    - case 3: add remove child in a widget with a tll
    - case 4: parent widget gets resized
 
   \code
    // we monitor the managed widgets
    // top level layout grabs it (if tll exists)
    Layout::eventFilter() {
        // on layoutHint event calls
        Layout::enforce();
 
        // on resize calls
        Layout::setGeometry(r);
 
        // on child insert / remove in mainWidget
        // this implies enforce called in the next event processing
            Application::postEvent(mainWidget(), new LayoutHintEvent());
    }
   \endcode
    
   \note
    - if there is no top level layout then layout is not
    automatically enforced
    - use cases 1,2,3,4 are working if we assume the presence of a tll
    - we do a lot of invalidateRecursively()
    - widgets can only have one layout child (setLayout(), layout()) and
    no more
    - a widget cannot tell if it is managed or not
    - Layout::setGeometry() reimplementations must call base class implementation
 */
bool Layout::eventFilter(Object *obj, Event *e) {
    Widget *w;

    switch (e->type()) {
    case Event::ChildInserted:
        if (autoAdd) {
            ChildEvent *ce = static_cast<ChildEvent *>(e);
            Object *child = ce->child();
            // It is not possible to add other widgets layout. They will
            // be toplevels and that means we are dead
            LayoutItem *li = dynamic_cast<LayoutItem *>(child);

            //assert(li == this);
            // we can only insert Widget items as childs of our mainWidget
            const bool is_window_frame = dynamic_cast<Window::Frame *>(child);
            const Window *wnd = dynamic_cast<Window *>(child);
            const bool is_frameless_window = wnd &&
                                             !dynamic_cast<Window::Frame *>(wnd->parent());
            if (li != this && !is_window_frame && !is_frameless_window
                    && (w = dynamic_cast<Widget *>(child))) {
                trace("layout") << "Inserting to layout "
                << this << " child " << w << std::endl;
                addItem(w);
            }
        }
        break;
    case Event::ChildRemoved: {
            // we have to handle the reparenting case.
            // delete is handled gracefully. Problem is we don't
            // know if it is deleted. But if it is deleted it will
            // have been already removed. So we use static_cast to
            // go up and down the inheritance tree. It is also possible
            // that we don't manage this child.
            ChildEvent *ce = static_cast<ChildEvent *>(e);
            w = static_cast<Widget *>(ce->child());
            LayoutItem *li = static_cast<LayoutItem *>(w);
            // if item is already dead (removed) removeItem will do nothing
            removeItem(li);
        }
        break;
    case Event::Resize:
        w = dynamic_cast<Widget *>(obj);
        trace("layout") << "Widget Resize: " << w
        << " caused layout resize" << std::endl;
        setGeometry(w->geometry());
        break;
    case Event::Move:
        w = dynamic_cast<Widget *>(obj);
        trace("layout") << "Widget move: " << w
        << " caused layout move" << std::endl;
        LayoutItem::setGeometry(w->geometry());
        break;
    case Event::LayoutHint:
        enforce();
        break;
    default:
        break;
    }

    return Object::eventFilter(obj, e);
}

void Layout::setGeometry(const Rect& r) {
    Rect widget_rect = r;

    if (isTopLevel()) {
        const Rect& layout_rect = r >> margin;
        Size new_size = layout_rect.size();

        trace("layout") <<  "Is Widget hidden ? "
        << mainWidget()->isHidden() << std::endl;
        trace("layout") << this << " requested new_size " << new_size
        << " min_size " << minimumSize()
        << " hint_size " << sizeHint() << std::endl;

        if (isTrace("layout")) {
            LayoutIterator it = iterator();
            for (it.start(); !it.finish(); it++) {
                LayoutItem *li = *it;
                if (li->is<Object *>()) {
                    trace("layout") << "Listing item " << dynamic_cast<Object *>(li)
                    << " min_size " << li->minimumSize()
                    << " hint_size " << li->sizeHint() << std::endl;
                }
            }
        }

        if (!new_size.contains(minimumSize())) {
            new_size = minimumSize().expandedTo(new_size);
        }

        if (!maximumSize().contains(new_size)) {
            new_size = new_size.boundedTo(maximumSize());
        }

        trace("layout") << this << " accepted new_size " << new_size << std::endl;

        widget_rect.setSize(new_size << margin);
        mainWidget()->setGeometry(widget_rect);
    }
    trace("layout") << this << " Layout::setGeometry()" << widget_rect << std::endl;
    // It is weird but in the layout::LayoutItem component
    // we store widget's geometry (<< margin)
    LayoutItem::setGeometry(widget_rect);
}

/// enforces the layout in the mainWidget() children and layouts
/*! it can be only called if there is a main widget */
void Layout::enforce() {
    const Rect rect = geometry();
    const Size min_size = minimumSize();
    const Size hint_size = sizeHint();

    // top downn invalidate across one widget only
    invalidateRecursively();
    // calls the virtual reimplementations
    setGeometry(rect);
    // this will notify parent of mainWidget() if exists
    if (rect != geometry() ||
            hint_size != sizeHint() ||
            min_size != minimumSize()) {
        mainWidget()->updateGeometry();
    }
}

void Layout::setWidthasPrimaryLength(bool width) {
    width_as_primary_length = width;
}

int Layout::preferredLength(const LayoutItem *li, bool expand) const {
    return primaryLength((expand) ? li->sizeHint() : li->minimumSize());
}

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

template<typename TYPE>
int Layout::primaryOffset(const TYPE& t) const {
    return (width_as_primary_length) ? t.left() : t.top();
}

template<typename TYPE>
int Layout::secondaryOffset(const TYPE& t) const {
    return (width_as_primary_length) ? t.top() : t.left();
}

Point Layout::getPoint(int primary_offset, int secondary_offset) const {
    return (width_as_primary_length) ?
           Point(primary_offset, secondary_offset) :
           Point(secondary_offset, primary_offset);
}

Size Layout::getSize(int primary, int secondary) const {
    return (width_as_primary_length) ?
           Size(primary, secondary) :
           Size(secondary, primary);
}

Rect Layout::getRect(int primary_offset, int secondary_offset,
                     int primary_size, int secondary_size) const {
    return (width_as_primary_length) ?
           Rect(primary_offset, secondary_offset, primary_size, secondary_size) :
           Rect(secondary_offset, primary_offset, secondary_size, primary_size);
}

int Layout::primaryStretch(const SizePolicy& sp) const {
    return (width_as_primary_length) ?
           sp.horizontalStretch : sp.verticalStretch;
}

bool Layout::mayGrowPrimally(const SizePolicy& sp) const {
    return (width_as_primary_length) ?
           sp.mayGrowHorizontally() : sp.mayGrowVertically();
}

bool Layout::mayShrinkPrimally(const SizePolicy& sp) const {
    return (width_as_primary_length) ?
           sp.mayShrinkHorizontally() : sp.mayShrinkVertically();
}

bool Layout::expandingPrimally(const SizePolicy& sp) const {
    return (width_as_primary_length) ?
           sp.expandingHorizontally() : sp.expandingVertically();
}

Size Layout::minimumSize() const {
    if (invalidated()) {
        Layout &self(*const_cast<Layout *>(this));
        self.validate();
    }
    return LayoutItem::minimumSize();
}

Size Layout::sizeHint() const {
    if (invalidated()) {
        Layout &self(*const_cast<Layout *>(this));
        self.validate();
    }
    return LayoutItem::sizeHint();
}

void BoxLayout::appendItem(LayoutItem *li) {
    Layout::addItem(li);
    push_back(li);
}

void BoxLayout::prependItem(LayoutItem *li) {
    Layout::addItem(li);
    push_front(li);
}

void BoxLayout::addItem(LayoutItem *li) {
    switch(direction) {
    case LeftToRight:
    case TopToBottom:
        appendItem(li);
        break;
    case RightToLeft:
    case BottomToTop:
        prependItem(li);
        break;
    default:
        break;
    }
}

/// let's calc again sizeHint, minimumSize etc
void BoxLayout::validate() {
    int hint_p = 0, hint_s = 0;
    int min_p = 0, min_s = 0;
    int count = 0;
    int sp;

    trace("layout") << this << " BoxLayout::invalidate()" << std::endl;

    BoxLayoutIterator it(*this);
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        if (!li->isEmpty()) {
            min_p += primaryLength(li->minimumSize());
            min_s = std::max(min_s, secondaryLength(li->minimumSize()));
            hint_p += primaryLength(li->sizeHint());
            hint_s = std::max(hint_s, secondaryLength(li->sizeHint()));
            trace("layout", "Up to item %d (%p) min_size %d hint_size %d\n", count, li, min_p, hint_p);
            count++;
        }
    }
    // don't forget spacing
    sp = spacing;
    if (count) {
        min_p += (count - 1) * sp;
        hint_p += (count - 1) * sp;
    }

    setSizeHint(getSize(hint_p, hint_s));
    setMinimumSize(getSize(min_p, min_s));
    Layout::validate();
}

/// fixup all managed widgets geometry
void BoxLayout::setGeometry(const Rect& r) {
    BoxLayoutIterator it(*this);
    trace("layout") << this << " BoxLayout::setGeometry()" << r << std::endl;

    // store geometry first
    Layout::setGeometry(r);
    // if smaller than the minSize it is possible that
    // we have to reacquire the size to perform the layout
    Rect rect = LayoutItem::geometry() >> margin;

    // obvious optimization. If they are empty do nothing
    bool empty = true;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        if (!li->isEmpty()) {
            empty = false;
            break;
        }
    }
    if (empty)
        return;

    int expansion = primaryLength(rect) - primaryLength(sizeHint());
    bool expand = expansion >= 0;

    if (!expand) {
        expansion = primaryLength(rect) - primaryLength(minimumSize());
    }

    // we have to expand
    int stretch_sum = 0;
    int may_grow_num;
    int unclaimed_space;

    // initialize effective stretch to zero
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        value(li).stretch = 0;
    }

    // first check if there are any stretch values
    may_grow_num = 0;
    unclaimed_space = 0;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        int li_stretch = primaryStretch(li->sizePolicy());
        if (!li->isEmpty() && li_stretch &&
                mayGrowPrimally(li->sizePolicy())) {
            unclaimed_space += preferredLength(li, expand);
            stretch_sum += li_stretch;
            value(li).stretch = li_stretch;
            may_grow_num++;
        }
    }

    // check if we have to split the extra space among expanding
    if (!stretch_sum) {
        may_grow_num = 0;
        unclaimed_space = 0;
        for (it.start(); !it.finish(); it++) {
            LayoutItem *li = *it;
            if (!li->isEmpty() && expandingPrimally(li->sizePolicy())) {
                unclaimed_space += preferredLength(li, expand);
                value(li).stretch = 1;
                may_grow_num++;
            }
        }
        stretch_sum = may_grow_num;
    }

    // check if we have to split the extra space among may Grow simply (preffered)
    if (!may_grow_num) {
        unclaimed_space = 0;
        for (it.start(); !it.finish(); it++) {
            LayoutItem *li = *it;
            if (!li->isEmpty() && mayGrowPrimally(li->sizePolicy())) {
                unclaimed_space += preferredLength(li, expand);
                value(li).stretch = 1;
                may_grow_num++;
            }
        }
        stretch_sum = may_grow_num;
    }

    // none of the fuckers grows -- all fixed size
    if (!may_grow_num) {
        unclaimed_space = 0;
        for (it.start(); !it.finish(); it++) {
            LayoutItem *li = *it;
            if (!li->isEmpty()) {
                unclaimed_space += preferredLength(li, expand);
                value(li).stretch = 1;
                may_grow_num++;
            }
        }
        stretch_sum = may_grow_num;
    }

    // Now we will remove offenders until we can distribute evenly
    int available_space;
    int claimed_space;
restart:
    /// \todo find biggest offender not the first one
    available_space = expansion + unclaimed_space;
    claimed_space = 0;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        if (!li->isEmpty() && value(li).stretch) {
            int li_p = (value(li).stretch *
                        available_space) / stretch_sum;
            if (li_p < preferredLength(li, expand)) {
                // problem: offender found, remove him
                trace("layout", "Removing offender %p with "
                      "stretch %d stretch_sum %d\n",
                      li, value(li).stretch, stretch_sum);
                unclaimed_space -= preferredLength(li, expand);
                stretch_sum -= value(li).stretch;
                value(li).stretch = 0;
                may_grow_num--;
                goto restart;
            }
            claimed_space += li_p;
        }
    }

    // now we have to distribute evenly the difference
    // that got truncated in the integer division
    int rest_space = available_space - claimed_space;
    int div = 0;
    int modulo = 0;
    if (may_grow_num) {
        div = rest_space / may_grow_num;
        modulo = rest_space % may_grow_num;
    }

    int count = 0;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;
        if (value(li).stretch) {
            value(li).extra_space = div + (count < modulo) ? 1 : 0;
        } else {
            value(li).extra_space = 0;
        }
        count++;
    }

    // finally place them
    int covered = primaryOffset(rect);
    int sp = spacing;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;

        if (li->isEmpty())
            continue;

        int space = ( (value(li).stretch) ?
                      (value(li).stretch * available_space) / stretch_sum :
                      preferredLength(li, expand) ) + value(li).extra_space;
        const Size& container_size = getSize(space,
                                             secondaryLength(rect));
        const Size& hint_size = li->sizeHint();
        const Size& min_size = li->minimumSize();
        const int w = (li->sizePolicy().mayGrowHorizontally())
                      ? container_size.width()
                      : (hint_size.width() <= container_size.width())
                      ? hint_size.width()
                      : min_size.width();
        const int h = (li->sizePolicy().mayGrowVertically())
                      ? container_size.height()
                      : (hint_size.height() <= container_size.height())
                      ? hint_size.height()
                      : min_size.height();
        const Size& cell_size = Size(w, h);

        trace("layout", "BoxLayout:: Allocating space %d for layoutItem %p\n", space, li);
        trace("layout") <<  "BoxLayout:: Container size: "
        << container_size << " cell_size " << cell_size << std::endl;
        li->setGeometry(
            Rect::align(Rect(mainWidget()->mapFromParent(getPoint(covered,
                             secondaryOffset(rect))), container_size),
                        cell_size, li->alignment));
        covered += space + sp;
    }
}

} // namespace

---

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.