canvas/canvas/table.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Paul Davis <paul@linuxaudiosystems.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef __CANVAS_TABLE_H__
#define __CANVAS_TABLE_H__
 
#include <unordered_map>
 
#include "canvas/rectangle.h"
 
namespace ArdourCanvas
{
 
class Rectangle;
 
class LIBCANVAS_API Table : public Rectangle
{
public:
        Table (Canvas *);
        Table (Item *);
 
        void set_row_spacing (Distance s);
        void set_col_spacing (Distance s);
 
        void set_padding (FourDimensions const & padding);
 
#if 0
        void set_margin (double top, double right = -1.0, double bottom = -1.0, double left = -1.0);
 
        /* aliases so that CSS box model terms work */
        void set_border_width (double w) { set_outline_width (w); }
        void set_border_color (Gtkmm2ext::Color c)  { set_outline_color (c); }
 
        void set_collapse_on_hide (bool);
 
#endif
        void set_homogenous (bool);
        void set_row_homogenous (bool);
        void set_col_homogenous (bool);
        void compute_bounding_box () const;
        void size_request (double& w, double& h) const;
        void size_allocate_children (Rect const & r);
 
        struct Index {
                Index (uint32_t xv, uint32_t yv) : x (xv), y (yv) {}
 
                bool operator== (Index const & other) const {
                        return x == other.x && y == other.y;
                }
 
                uint32_t x;
                uint32_t y;
        };
 
        /* These three functions cannot be used with Table, and will cause a
           fatal error if called.
        */
        void add (Item *);
        void add_front (Item *);
        void remove (Item *);
 
        /* How to place an item in a table
         */
 
        void attach (Item*, uint32_t upper_left_x, uint32_t upper_left_y, uint32_t lower_right_x, uint32_t lower_right_y, PackOptions row_options = PackOptions (0), PackOptions col_options = PackOptions (0), FourDimensions padding = FourDimensions (0.));
        void attach (Item*, uint32_t upper_left_x, uint32_t upper_right_y, PackOptions row_options = PackOptions (0), PackOptions col_options = PackOptions (0), FourDimensions padding = FourDimensions (0.));
        void attach_with_span (Item*, uint32_t upper_left_x, uint32_t upper_left_y, uint32_t hspan, uint32_t vspan, PackOptions row_options = PackOptions (0), PackOptions col_options = PackOptions (0), FourDimensions padding = FourDimensions (0.));
 
        // Not implemented, but also not needed thus far
        // void detach (Item*);
 
        void set_row_size (uint32_t row, Distance);
        void set_col_size (uint32_t row, Distance);
 
  protected:
        void child_changed (bool bbox_changed);
 
  private:
        FourDimensions padding;
        FourDimensions margin;
        Distance row_spacing;
        Distance col_spacing;
        bool collapse_on_hide;
        bool row_homogenous;
        bool col_homogenous;
        bool draw_hgrid;
        bool draw_vgrid;
 
        mutable bool ignore_child_changes;
 
        struct CellInfo {
                Item* content;
                PackOptions row_options;
                PackOptions col_options;
                Index upper_left;
                Index lower_right;
                Duple natural_size;
                Duple allocate_size;
                Rect  full_size;
                FourDimensions padding;
 
                CellInfo (Item* i, PackOptions ro, PackOptions co, Index const & ul, Index const & lr, FourDimensions const & p)
                          : content (i)
                          , row_options (ro)
                          , col_options (co)
                          , upper_left (ul)
                          , lower_right (lr)
                          , padding (p)
                          {}
        };
 
        struct index_hash {
                std::size_t operator() (Table::Index const & i) const {
                        /* use upper left coordinate for hash */
                        return ((uint64_t) i.x << 32) | i.y;
                }
        };
 
        /* cell lookup, indexed by upper left corner only
         */
 
        typedef std::unordered_map<Index, CellInfo, index_hash> Cells;
        Cells cells;
 
        struct AxisInfo {
                uint32_t expanders;
                uint32_t shrinkers;
                Distance natural_size;
                Distance expand;
                Distance shrink;
                Distance user_size;
                bool     occupied;
                Distance spacing;
 
                AxisInfo() : expanders (0), shrinkers (0), natural_size (0), expand (0), shrink (0), user_size (0), occupied (false), spacing (0) {}
 
                void reset () {
                        expanders = 0;
                        shrinkers = 0;
                        natural_size = 0;
                        expand = 0;
                        shrink = 0;
                        /* leave user size alone */
                        occupied = false;
                        spacing = 0;
                }
        };
 
        typedef std::vector<AxisInfo> AxisInfos;
        AxisInfos row_info;
        AxisInfos col_info;
 
        void _add (Item *);
        void _add_front (Item *);
        void _remove (Item *);
 
        void layout ();
        Duple compute (Rect const &);
};
 
} /* namespace */
 
#endif /* __CANVAS_TABLE_H__ */