cascadelayout.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/cascadelayout.h>
#include <wt/widget.h>

namespace Wt {

void CascadeLayout::init() {
    sigc::slot<void> slot = sigc::mem_fun(*this,
                                          &CascadeLayout::postLayoutHintEvent);
    alignment.changed.connect(slot);
    horizontalAdvance.changed.connect(slot);
    verticalAdvance.changed.connect(slot);
}

void CascadeLayout::validate() {
    int hint_w = 0, hint_h = 0;
    int min_w = 0, min_h = 0;
    int count = 0;
    const int dx = abs(static_cast<int>(horizontalAdvance));
    const int dy = abs(static_cast<int>(verticalAdvance));

    trace("cascadelayout") << this << " CascadeLayout::validate()" << std::endl;

    CascadeLayoutIterator it(*this);
    for (it.start(), count = 0; !it.finish(); it++, count++) {
        LayoutItem *li = *it;
        if (!li->isEmpty()) {
            min_w = std::max(min_w, count * dx + li->minimumSize().width());
            min_h = std::max(min_h, count * dy + li->minimumSize().height());
            hint_w = std::max(hint_w, count * dx + li->sizeHint().width());
            hint_h = std::max(hint_h, count * dy + li->sizeHint().height());
        }
    }

    setSizeHint(Size(hint_w, hint_h));
    setMinimumSize(Size(min_w, min_h));

    Layout::validate();
}

static int preferredWidth(const LayoutItem *li, bool expand) {
    return (expand) ? li->sizeHint().width() : li->minimumSize().width();
}

static int preferredHeight(const LayoutItem *li, bool expand) {
    return (expand) ? li->sizeHint().height() : li->minimumSize().height();
}

void CascadeLayout::setGeometry(const Rect& r) {
    CascadeLayoutIterator it(*this);
    trace("cascadelayout") << this << " CascadeLayout::setGeometry()" << std::endl;

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

    bool expand_w = (rect.width() >= sizeHint().width());
    bool expand_h = (rect.height() >= sizeHint().height());

    rect = Rect::align(rect, Size(preferredWidth(this, expand_w),
                                  preferredHeight(this, expand_h)), alignment);

    trace("cascadelayout",
          "Expanding horizontally %d vertically %d\n", expand_w, expand_h);
    trace("cascadelayout",
          "rect.width() = %d sizeHint().width() = %d\n",
          rect.width(), sizeHint().width());
    trace("cascadelayout",
          "rect.height() = %d sizeHint().height() = %d\n",
          rect.height(), sizeHint().height());

    const int horizontal_advance = horizontalAdvance;
    const int vertical_advance = verticalAdvance;
    int covered_x = (horizontal_advance >= 0) ? rect.left() : rect.right() + 1;
    int covered_y = (vertical_advance >= 0) ? rect.top() : rect.bottom() + 1;
    for (it.start(); !it.finish(); it++) {
        LayoutItem *li = *it;

        if (li->isEmpty())
            continue;

        int size_w = preferredWidth(li, expand_w);
        int offset_x = (horizontal_advance >= 0) ?
                       covered_x : covered_x - size_w;
        int size_h = preferredHeight(li, expand_h);
        int offset_y = (vertical_advance >= 0) ?
                       covered_y : covered_y - size_h;

        trace("cascadelayout", "Placing %p at [%d, %d] with [%d x %d]\n",
              li, offset_x, offset_y, size_w, size_h);
        li->setGeometry(Rect(mainWidget()->mapFromParent(
                                 Point(offset_x, offset_y)),
                             Size(size_w, size_h)));

        covered_x += horizontal_advance;
        covered_y += vertical_advance;
    }
}

} // namespace

---

Generated Fri Jul 28 19:22:59 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.