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

namespace Wt {

void adjust_cell_size(int li_size, int sum_size, int cell_span,
                      int edge, std::vector<int>& max_size) {
    const int delta = li_size - sum_size;
    if (delta > 0) {
        // adjust all min width
        const int div = delta / cell_span;
        const int modulo = delta % cell_span;

        for (int d = 0; d < cell_span; d++) {
            max_size[edge + d] += div + ((d < modulo) ? 1 : 0);
        }
    }
}

void GridLayout::init() {
    gridSizeChanged.connect(sigc::mem_fun(*this, &GridLayout::onGridSizeChange));
}

GridLayout::GridLayout(Widget *parent, int margin, int spacing,
                       const std::string &name) :
GridLayoutBase(parent, margin, spacing, name) {
    init();
}

GridLayout::GridLayout(Layout * parent_layout,int margin,
                       int spacing,const std::string &name) :
GridLayoutBase(parent_layout, margin, spacing, name) {
    init();
}

GridLayout::GridLayout(int spacing, const std::string &name) :
GridLayoutBase(spacing, name) {
    init();
}

void GridLayout::onGridSizeChange(int rows_old,
                                  int cols_old, int rows, int cols) {
    trace("gridlayout",
          "GridSizeChange: from %dx%d --> %dx%d\n",
          rows_old, cols_old, rows, cols);

    if (!rows || !cols)
        return;

    row_stretch.resize(rows);
    column_stretch.resize(cols);

    max_min_width.resize(cols);
    max_min_height.resize(rows);
    max_hint_width.resize(cols);
    max_hint_height.resize(rows);
    row_empty.resize(rows);
    col_empty.resize(cols);

    may_grow_horizontally.resize(cols);
    may_grow_vertically.resize(rows);
    expanding_horizontally.resize(cols);
    expanding_vertically.resize(rows);

    for (int r = rows_old; r < rows; r++) {
        row_stretch[r] = 0;
        max_min_height[r] = 0;
        max_hint_height[r] = 0;
        row_empty[r] = true;
        may_grow_vertically[r] = false;
        expanding_vertically[r] = false;
    }

    for (int c = 0; c < cols_old; c++) {
        column_stretch[c] = 0;
        max_min_width[c] = 0;
        max_hint_width[c] = 0;
        col_empty[c] = true;
        may_grow_horizontally[c] = false;
        expanding_horizontally[c] = false;
    }
}

/// let's calc again sizeHint, minimumSize etc
void GridLayout::validate() {
    int hint_w = 0, hint_h = 0;
    int min_w = 0, min_h = 0;
    int row_count = 0, col_count = 0;
    int r, c;
    GridLayout& self = *this;
    int sp = spacing;

    trace("gridlayout") << this << " GridLayout::invalidate()" << std::endl;

    for (c = 0; c < numCols(); c++) {
        max_min_width[c] = 0;
        max_hint_width[c] = 0;
        col_empty[c] = true;
        may_grow_horizontally[c] = false;
        expanding_horizontally[c] = false;
    }

    for (r = 0; r < numRows(); r++) {
        max_min_height[r] = 0;
        max_hint_height[r] = 0;
        row_empty[r] = true;
        may_grow_vertically[r] = false;
        expanding_vertically[r] = false;

        for (c = 0; c < numCols(); c++) {
            const LayoutItem *li = self(r, c);
            const MatrixLayoutItemValue& v = self(r, c);

            // skip multicells
            if (li->isNonEmpty() && !v.isMultiCell()) {
                max_min_width[c] = std::max(max_min_width[c], li->minimumSize().width());
                max_min_height[r] = std::max(max_min_height[r], li->minimumSize().height());
                max_hint_width[c] = std::max(max_hint_width[c], li->sizeHint().width());
                max_hint_height[r] = std::max(max_hint_height[r], li->sizeHint().height());
            }
            if (li->isNonEmpty()) {
                row_empty[r] = false;
                col_empty[c] = false;
                may_grow_horizontally[c] = may_grow_horizontally[c] ||
                                           li->sizePolicy().mayGrowHorizontally();
                may_grow_vertically[r] = may_grow_vertically[r] ||
                                         li->sizePolicy().mayGrowVertically();
                expanding_horizontally[c] = expanding_horizontally[c] ||
                                            li->sizePolicy().expandingHorizontally();
                expanding_vertically[r] = expanding_vertically[r] ||
                                          li->sizePolicy().expandingVertically();
            }
        }
    }

    // for all multicells
    for (r = 0; r < numRows(); r++) {
        for (c = 0; c < numCols(); c++) {
            const LayoutItem *li = self(r, c);
            const MatrixLayoutItemValue& v = self(r, c);
            if (li->isNonEmpty() && v.isMultiCell() && !v.isReference()) {
                int dr, dc;
                int min_width_sum = 0, hint_width_sum = 0;
                int min_height_sum = 0, hint_height_sum = 0;
                // first mark the relevent row and columns non-empty
                // also let's count the relevent sizes
                for (dr = 0; dr < v.rowSpan(); dr++) {
                    row_empty[r + dr] = false;
                    min_height_sum += max_min_height[r + dr];
                    hint_height_sum += max_hint_height[r + dr];
                }

                for (dc = 0; dc < v.columnSpan(); dc++) {
                    col_empty[c + dc] = false;
                    min_width_sum += max_min_width[c + dc];
                    hint_width_sum += max_hint_width[c + dc];
                }
                // for rows and columns for hint and min sizes
                adjust_cell_size(li->minimumSize().width(), min_width_sum,
                                 v.columnSpan(), c, max_min_width);
                adjust_cell_size(li->minimumSize().height(), min_height_sum,
                                 v.rowSpan(), r, max_min_height);
                adjust_cell_size(li->sizeHint().width(), hint_width_sum,
                                 v.columnSpan(), c, max_hint_width);
                adjust_cell_size(li->sizeHint().height(), hint_height_sum,
                                 v.rowSpan(), r, max_hint_height);
            }
        }
    }

    for (r = 0; r < numRows(); r++) {
        if (!row_empty[r]) {
            row_count++;
            min_h += max_min_height[r];
            hint_h += max_hint_height[r];
        }
    }

    for (c = 0; c < numCols(); c++) {
        if (!col_empty[c]) {
            col_count++;
            min_w += max_min_width[c];
            hint_w += max_hint_width[c];
        }
    }

    // don't forget spacing
    if (row_count) {
        min_h += (row_count - 1) * sp;
        hint_h += (row_count - 1) * sp;
    }

    if (col_count) {
        min_w += (col_count - 1) * sp;
        hint_w += (col_count - 1) * sp;
    }

    setSizeHint(Size(hint_w, hint_h));
    setMinimumSize(Size(min_w, min_h));
    Layout::validate();
}

//! calcs the width of the columns and the height of the rows
/*! it's not funny if we have to do it two times both for width and height
so we are are heavily using the generic names length and edge to
indicate width or height and row or column.
*/
void GridLayout::calcEdge(int total_space, bool width_as_primary) {
    int expansion;
    bool expand;
    int stretch_sum = 0;
    int may_grow_num = 0;
    int unclaimed_space = 0;
    int j;

    setWidthasPrimaryLength(width_as_primary);

    std::vector<int>& hint_length = primaryHintLength();
    std::vector<int>& min_length = primaryMinLength();
    std::vector<int>& effective_stretch = secondaryEffectiveStretch();
    std::vector<int>& stretch = secondaryStretch();
    std::vector<int>& extra_space = secondaryExtraSpace();
    std::vector<int>& length = primaryCellItemLength();
    std::vector<int>& container_length = primaryCellLength();

    int edges = secondaryEdges();

    effective_stretch.resize(edges);
    extra_space.resize(edges);
    length.resize(edges);
    container_length.resize(edges);

    trace("gridlayout", "GridLayout:: Available space for %s %d\n",
          (isWidthPrimaryLength()) ? "width" : "height", total_space);
    expansion = total_space - Layout::primaryLength(sizeHint());
    expand = expansion >= 0;
    if (!expand) {
        expansion = total_space - Layout::primaryLength(minimumSize());
    }

    // initialize effective stretch to zero
    for (j = 0; j < edges; j++) {
        effective_stretch[j] = 0;
    }

    // we have to expand
    // first check if there are any stretch values
    for (j = 0; j < edges; j++) {
        int li_stretch = stretch[j];
        if (li_stretch && mayGrowPrimally(j)) {
            unclaimed_space += preferredLength(j, expand);
            stretch_sum += li_stretch;
            effective_stretch[j] = 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 (j = 0; j < edges; j++) {
            if (expandingPrimally(j)) {
                unclaimed_space += preferredLength(j, expand);
                effective_stretch[j] = 1;
                may_grow_num++;
            }
        }
        stretch_sum = may_grow_num;
    }

    // check if we have to split the extra space among may Grow simply (preferred)
    if (!may_grow_num) {
        unclaimed_space = 0;
        for (j = 0; j < edges; j++) {
            if (mayGrowPrimally(j)) {
                unclaimed_space += preferredLength(j, expand);
                effective_stretch[j] = 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 (j = 0; j < edges; j++) {
            int preferred_length = preferredLength(j, expand);
            if (preferred_length) {
                unclaimed_space += preferred_length;
                effective_stretch[j] = 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 (j = 0; j < edges; j++) {
        if (effective_stretch[j]) {
            int li_p = (effective_stretch[j] *
                        available_space) / stretch_sum;
            int preferred_length = preferredLength(j, expand);
            if (li_p < preferred_length) {
                // problem: offender found, remove him
                trace("gridlayout", "Removing offender at pos %d with "
                      "stretch %d stretch_sum %d unclaimed_space %d\n",
                      j, effective_stretch[j], stretch_sum, unclaimed_space);
                unclaimed_space -= preferred_length;
                stretch_sum -= effective_stretch[j];
                effective_stretch[j] = 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 (j = 0; j < edges; j++) {
        if (effective_stretch[j]) {
            extra_space[j] = div + (count < modulo) ? 1 : 0;
        } else {
            extra_space[j] = 0;
        }
        count++;
    }

    // finally calc the size
    for (j = 0; j < edges; j++) {
        const int space = ( (effective_stretch[j]) ?
                            (effective_stretch[j] * available_space) /
                            stretch_sum :
                            preferredLength(j, expand) ) + extra_space[j];
        container_length[j] = space;
        length[j] = (mayGrowPrimally(j)) ?
                    space : (hint_length[j] <= space) ?
                    hint_length[j] : min_length[j];
        trace("gridlayout", "GridLayout:: Allocating space "
              "(%d) %d for edge %d\n", isWidthPrimaryLength(), space, j);
    }
}

/// fixup all managed widgets geometry
void GridLayout::setGeometry(const Rect& r) {
    GridLayoutIterator it(*this);
    trace("gridlayout") << this <<  " GridLayout::setGeometry()" << 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->isNonEmpty()) {
            empty = false;
            break;
        }
    }
    if (empty)
        return;

    calcEdge(rect.width(), true);
    calcEdge(rect.height(), false);

    // finally place them
    int covered_y = rect.y();
    GridLayout& self = *this;
    for (int i = 0; i < numRows(); i++) {
        int covered_x = rect.x();
        for (int j = 0; j < numCols(); j++) {
            LayoutItem *li = self(i, j);
            const MatrixLayoutItemValue& v = self(i, j);

            if (!li->isNonEmpty())
                continue;

            // let's count the relevent sizes
            int container_width = 0;
            int container_height = 0;

            const Size& hint_size = li->sizeHint();
            const Size& min_size = li->minimumSize();

            for (int dr = 0; dr < v.rowSpan(); dr++)
                container_height += container_row_height[i + dr];
            container_height += (v.rowSpan() - 1) * spacing;

            for (int dc = 0; dc < v.columnSpan(); dc++)
                container_width += container_column_width[j + dc];
            container_width += (v.columnSpan() - 1) * spacing;

            const Size& container_size = Size(container_width,
                                              container_height);

            const int cell_height = (li->sizePolicy().mayGrowVertically())
                                    ? container_size.height()
                                    : (hint_size.height() <= container_size.height())
                                    ? hint_size.height()
                                    : min_size.height();

            const int cell_width = (li->sizePolicy().mayGrowHorizontally())
                                   ? container_size.width()
                                   : (hint_size.width() <= container_size.width())
                                   ? hint_size.width()
                                   : min_size.width();

            const Size& cell_size = Size(cell_width, cell_height);

            if (!v.isReference()) {
                trace("gridlayout") << "GridLayout:: layoutItem " << li
                << " in ("  << i << "," << j << ") " << cell_size
                << " in " << container_size << std::endl;
                li->setGeometry(
                    Rect::align(Rect(mainWidget()->
                                     mapFromParent(Point(covered_x, covered_y)),
                                     container_size), cell_size, li->alignment));
            }
            covered_x += column_width[j] + spacing;
        }
        covered_y += row_height[i] + spacing;
    }
}

void GridLayout::setRowStretch(int row, int stretch) {
    row_stretch[row] = stretch;
    postLayoutHintEvent();
}

void GridLayout::setColStretch(int col, int stretch) {
    column_stretch[col] = stretch;
    postLayoutHintEvent();
}

void GridLayout::insert(const LayoutItem *li, int row, int column) {
    (*this)(row, column) = li;
}

void GridLayout::insert(const LayoutItem *li, int row_from,
                        int row_to, int column_from, int column_to) {
    const int row_span = row_to - row_from + 1;
    const int col_span = column_to - column_from + 1;
    trace("gridlayout", "Span insertion [%d %d] to [%d %d]\n",
          row_from, column_from, row_to, column_to);
    for (int r = row_from; r <= row_to; r++) {
        for (int c = column_from; c <= column_to; c++) {
            MatrixLayoutItemValue value(
                (r == row_from && c == column_from) ?
                MatrixLayoutItemValue::Original :
                MatrixLayoutItemValue::Reference, row_span, col_span);
            (*this)(r, c) = MatrixLayoutItemCompound(li, value);
        }
    }
}

void GridLayout::addItem(LayoutItem *li) {
    // obvious optimization. if exists and it is already in position do nothing
    GridLayout::const_iterator it = find(begin(), end(), li);
    bool exists = (it != end());

    if (exists && !cellSpanQueue.empty()) {
        const CellSpan& cs = cellSpanQueue.front();
        const MatrixLayoutItemValue& value = *it;
        if (it.row() == cs.rowFrom() && it.column() == cs.columnFrom() &&
                value.rowSpan() == cs.rowSpan() && value.columnSpan() == cs.columnSpan()) {
            cellSpanQueue.pop();
            return;
        }
    }

    // remove if already exists. This is used for cell reassigning
    if (exists) {
        removeItem(li);
    }
    trace("gridlayout", "GridLayout::addItem layoutItem %p\n", li);
    Layout::addItem(li);

    if (!cellSpanQueue.empty()) {
        const CellSpan& cs = cellSpanQueue.front();
        if (cs.layoutItem() == li) {
            insert(cs.layoutItem(), cs.rowFrom(), cs.rowTo(),
                   cs.columnFrom(), cs.columnTo());
            cellSpanQueue.pop();
            return;
        }
    }
    push_back(li);
}

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