gridlayout.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_GRIDLAYOUT_H
#define WT_GRIDLAYOUT_H

#include <queue>

#include <wt/matrix.h>
#include <wt/layout.h>

namespace Wt {

class MatrixLayoutItemValue {
public:
    typedef enum {
        Original,
        Reference
    } Type;

    MatrixLayoutItemValue(int type = Original,
                          int row_span = 1, int col_span = 1) :
    type_(type), row_span_(row_span), col_span_(col_span) {}

    bool isReference() const {
        return (type_ == Reference);
    }

    int type() const {
        return type_;
    }

    int rowSpan() const {
        return row_span_;
    }

    int columnSpan() const {
        return col_span_;
    }

    bool isMultiCell() const {
        return col_span_ > 1 || row_span_ > 1;
    }

private:
    int type_;
    int row_span_;
    int col_span_;
};

typedef LayoutItemCompound<MatrixLayoutItemValue> MatrixLayoutItemCompound;
typedef Matrix<MatrixLayoutItemCompound> MatrixLayoutItemMatrix;
typedef LayoutStdContainer<MatrixLayoutItemMatrix> GridLayoutBase;

class GridLayoutIterator : public LayoutStdContainerIterator<MatrixLayoutItemMatrix> {
public:
    GridLayoutIterator(MatrixLayoutItemMatrix& matrix) :
    LayoutStdContainerIterator<MatrixLayoutItemMatrix>(matrix) {}
private:
};

class GridLayout : public GridLayoutBase {
    friend class Grid;
    // equivalent inside class shortcut
    typedef MatrixLayoutItemMatrix::Edge Edge;

public:
    GridLayout(Widget *parent, int margin = 0, int spacing = -1,
               const std::string &name = "GridLayout::anon");

    GridLayout(Layout * parent_layout, int margin = 0,
               int spacing = -1, const std::string &name = "GridLayout::anon");

    GridLayout(int spacing = -1,
               const std::string &name = "GridLayout::anon");

    void insert(const LayoutItem *li, int row, int column);
    void insert(const LayoutItem *li, int row_from,
                int row_to, int column_from, int column_to);
    virtual void addItem(LayoutItem *li);

    virtual void setGeometry(const Rect& r);

    virtual void setRowStretch(int row, int stretch);
    virtual void setColStretch(int col, int stretch);

    int rowStretch (int row) const {
        return row_stretch[row];
    }
    int colStretch (int col) const {
        return column_stretch[col];
    }

protected:
    virtual void validate();

    int secondaryEdges() const {
        return isWidthPrimaryLength() ? numCols() : numRows();
    }

    std::vector<int>& secondaryStretch() {
        return isWidthPrimaryLength() ? column_stretch : row_stretch;
    }

    std::vector<int>& secondaryEffectiveStretch() {
        return isWidthPrimaryLength() ?
               column_stretch_effective : row_stretch_effective;
    }

    std::vector<int>& secondaryExtraSpace() {
        return isWidthPrimaryLength() ? column_extra_space : row_extra_space;
    }

    std::vector<int>& primaryCellItemLength() {
        return isWidthPrimaryLength() ? column_width : row_height;
    }

    std::vector<int>& primaryCellLength() {
        return isWidthPrimaryLength() ?
               container_column_width : container_row_height;
    }

    bool mayGrowPrimally(int edge_index) const {
        return isWidthPrimaryLength() ?
               may_grow_horizontally[edge_index] :
               may_grow_vertically[edge_index];
    }

    bool expandingPrimally(int edge_index) const {
        return isWidthPrimaryLength() ?
               expanding_horizontally[edge_index] :
               expanding_vertically[edge_index];
    }

    std::vector<int>& primaryMinLength() {
        return isWidthPrimaryLength() ? max_min_width : max_min_height;
    }

    std::vector<int>& primaryHintLength() {
        return isWidthPrimaryLength() ? max_hint_width : max_hint_height;
    }

    int preferredLength(int edge_index, bool expand) {
        return (expand) ? primaryHintLength()[edge_index] :
               primaryMinLength()[edge_index];
    }

    class CellSpan {
    public:
        CellSpan(const LayoutItem *li = 0,
                 int row = -1, int column = -1,
                 int row_span = 1, int column_span = 1) :
                li_(li),
                row_(row),
                column_(column),
                row_span_(row_span),
        column_span_(column_span) {}

        void invalidate() {
            li_ = 0;
            row_ = -1;
            column_ = -1;
        }

        bool isValid() const {
            return row_ >= 0 && column_ >= 0;
        }

        void setLayoutItem(const LayoutItem *li) {
            li_ = li;
        }

        const LayoutItem *layoutItem() const {
            return li_;
        }

        void setSpan(int row, int column,
                     int row_span = 1, int column_span = 1) {
            row_ = row;
            column_ = column;
            row_span_ = row_span;
            column_span_ = column_span;
        }

        void setFromTo(int row_from, int row_to,
                       int  column_from, int column_to) {
            row_ = row_from;
            column_ = column_from;
            row_span_ = row_to - row_from + 1;
            column_span_ = column_to - column_from + 1;
        }

        int rowSpan() const {
            return row_span_;
        }

        int columnSpan() const {
            return column_span_;
        }

        int rowFrom() const {
            return row_;
        }

        int columnFrom() const {
            return column_;
        }

        int rowTo() const {
            return row_ + row_span_ - 1;
        }

        int columnTo() const {
            return column_ + column_span_ - 1;
        }

    private:
        const LayoutItem *li_;
        int row_;
        int column_;
        int row_span_;
        int column_span_;
    };

    std::queue<CellSpan> cellSpanQueue;

private:
    void init();
    void onGridSizeChange(int rows_old, int cols_old, int rows, int cols);
    void calcEdge(const int available_space, bool width_as_primary);

    std::vector<int> max_min_width;
    std::vector<int> max_min_height;
    std::vector<int> max_hint_width;
    std::vector<int> max_hint_height;
    std::vector<bool> row_empty;
    std::vector<bool> col_empty;

    std::vector<bool> may_grow_horizontally;
    std::vector<bool> may_grow_vertically;
    std::vector<bool> expanding_horizontally;
    std::vector<bool> expanding_vertically;

    std::vector<int> row_stretch;
    std::vector<int> column_stretch;
    std::vector<int> row_stretch_effective;
    std::vector<int> column_stretch_effective;
    std::vector<int> row_extra_space;
    std::vector<int> column_extra_space;
    std::vector<int> row_height;
    std::vector<int> column_width;
    std::vector<int> container_row_height;
    std::vector<int> container_column_width;
};

} // namespace

#endif // WT_GRIDLAYOUT_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.