libs/canvas/grid.cc

   1 /*
   2     Copyright (C) 2018 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <algorithm>
  20 #include <vector>
  21
  22 #include "canvas/grid.h"
  23 #include "canvas/rectangle.h"
  24
  25 using namespace ArdourCanvas;
  26 using std::vector;
  27 using std::max;
  28 using std::cerr;
  29 using std::endl;
  30
  31 Grid::Grid (Canvas* canvas)
  32         : Item (canvas)
  33         , row_spacing (0)
  34         , col_spacing (0)
  35         , top_padding (0), right_padding (0), bottom_padding (0), left_padding (0)
  36         , top_margin (0), right_margin (0), bottom_margin (0), left_margin (0)
  37         , homogenous (false)
  38 {
  39         bg = new Rectangle (this);
  40         bg->set_outline (false);
  41         bg->set_fill (false);
  42         bg->hide ();
  43 }
  44
  45 Grid::Grid (Item* parent)
  46         : Item (parent)
  47         , row_spacing (0)
  48         , col_spacing (0)
  49         , top_padding (0), right_padding (0), bottom_padding (0), left_padding (0)
  50         , top_margin (0), right_margin (0), bottom_margin (0), left_margin (0)
  51         , homogenous (false)
  52 {
  53         bg = new Rectangle (this);
  54         bg->set_outline (false);
  55         bg->set_fill (false);
  56         bg->hide ();
  57 }
  58
  59 Grid::Grid (Item* parent, Duple const & p)
  60         : Item (parent, p)
  61         , row_spacing (0)
  62         , col_spacing (0)
  63         , top_padding (0), right_padding (0), bottom_padding (0), left_padding (0)
  64         , top_margin (0), right_margin (0), bottom_margin (0), left_margin (0)
  65         , homogenous (true)
  66 {
  67         bg = new Rectangle (this);
  68         bg->set_outline (false);
  69         bg->set_fill (false);
  70         bg->hide ();
  71 }
  72
  73 void
  74 Grid::set_homogenous (bool yn)
  75 {
  76         homogenous = yn;
  77 }
  78
  79 void
  80 Grid::render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const
  81 {
  82         Item::render_children (area, context);
  83 }
  84
  85 void
  86 Grid::compute_bounding_box () const
  87 {
  88         _bounding_box = Rect();
  89
  90         if (_items.empty()) {
  91                 _bounding_box_dirty = false;
  92                 return;
  93         }
  94
  95         add_child_bounding_boxes (!collapse_on_hide);
  96
  97         if (_bounding_box) {
  98                 Rect r = _bounding_box;
  99
 100                 _bounding_box = r.expand (outline_width() + top_margin + top_padding,
 101                                           outline_width() + right_margin + right_padding,
 102                                           outline_width() + bottom_margin + bottom_padding,
 103                                           outline_width() + left_margin + left_padding);
 104         }
 105
 106         _bounding_box_dirty = false;
 107 }
 108
 109 void
 110 Grid::set_row_spacing (double s)
 111 {
 112         row_spacing = s;
 113 }
 114
 115 void
 116 Grid::set_col_spacing (double s)
 117 {
 118         col_spacing = s;
 119 }
 120
 121 void
 122 Grid::set_padding (double t, double r, double b, double l)
 123 {
 124         double last = t;
 125
 126         top_padding = t;
 127
 128         if (r >= 0) {
 129                 last = r;
 130         }
 131         right_padding = last;
 132         if (b >= 0) {
 133                 last = b;
 134         }
 135         bottom_padding = last;
 136         if (l >= 0) {
 137                 last = l;
 138         }
 139         left_padding = last;
 140 }
 141
 142 void
 143 Grid::set_margin (double t, double r, double b, double l)
 144 {
 145         double last = t;
 146         top_margin = t;
 147         if (r >= 0) {
 148                 last = r;
 149         }
 150         right_margin = last;
 151         if (b >= 0) {
 152                 last = b;
 153         }
 154         bottom_margin = last;
 155         if (l >= 0) {
 156                 last = l;
 157         }
 158         left_margin = last;
 159 }
 160
 161 void
 162 Grid::reset_bg ()
 163 {
 164         if (_bounding_box_dirty) {
 165                 compute_bounding_box ();
 166         }
 167
 168         if (!_bounding_box) {
 169                 bg->hide ();
 170                 return;
 171         }
 172
 173         Rect r (_bounding_box);
 174
 175         /* XXX need to shrink by margin */
 176
 177         bg->set (r);
 178 }
 179
 180 void
 181 Grid::reposition_children ()
 182 {
 183         uint32_t max_row = 0;
 184         uint32_t max_col = 0;
 185
 186         /* since we encourage dynamic and essentially random placement of
 187          * children, begin by determining the maximum row and column extents given
 188          * our current set of children and placements.
 189          */
 190
 191         for (CoordsByItem::const_iterator c = coords_by_item.begin(); c != coords_by_item.end(); ++c) {
 192                 if (collapse_on_hide && !c->second.item->visible()) {
 193                         continue;
 194                 }
 195                 max_col = max (max_col, (uint32_t) (c->second.x + c->second.col_span));
 196                 max_row = max (max_row, (uint32_t) (c->second.y + c->second.row_span));
 197         }
 198
 199         /* Now compute the width of the widest child for each column, and the
 200          * height of the tallest child for each row. Store the results in
 201          * row_dimens and col_dimens, making sure they are suitably sized first.
 202          */
 203
 204         vector<double> row_dimens;
 205         vector<double> col_dimens;
 206
 207         row_dimens.assign (max_row + 1, 0);
 208         col_dimens.assign (max_col + 1, 0);
 209
 210         Rect uniform_cell_size;
 211
 212         if (homogenous) {
 213                 for (std::list<Item*>::iterator i = _items.begin(); i != _items.end(); ++i) {
 214
 215                         if (*i == bg || (collapse_on_hide && !(*i)->visible())) {
 216                                 continue;
 217                         }
 218
 219                         Rect bb = (*i)->bounding_box();
 220
 221                         if (!bb) {
 222                                 continue;
 223                         }
 224
 225                         CoordsByItem::const_iterator c = coords_by_item.find (*i);
 226
 227                         uniform_cell_size.x1 = max (uniform_cell_size.x1, (bb.width()/c->second.col_span));
 228                         uniform_cell_size.y1 = max (uniform_cell_size.y1, (bb.height()/c->second.row_span));
 229                 }
 230
 231                 for (uint32_t n = 0; n < max_col; ++n) {
 232                         col_dimens[n] = uniform_cell_size.width();
 233                 }
 234
 235                 for (uint32_t n = 0; n < max_row; ++n) {
 236                         row_dimens[n] = uniform_cell_size.height();
 237                 }
 238
 239                 for (std::list<Item*>::iterator i = _items.begin(); i != _items.end(); ++i) {
 240
 241                         if (*i == bg || (collapse_on_hide && !(*i)->visible())) {
 242                                 /* bg rect is not a normal child */
 243                                 continue;
 244                         }
 245
 246                         CoordsByItem::const_iterator c = coords_by_item.find (*i);
 247
 248                         Rect r = uniform_cell_size;
 249                         r.x1 *= c->second.col_span;
 250                         r.y1 *= c->second.row_span;
 251
 252                         (*i)->size_allocate (r);
 253                 }
 254
 255         } else {
 256                 for (std::list<Item*>::iterator i = _items.begin(); i != _items.end(); ++i) {
 257
 258                         if (*i == bg || (collapse_on_hide && !(*i)->visible())) {
 259                                 /* bg rect is not a normal child */
 260                                 continue;
 261                         }
 262
 263                         Rect bb = (*i)->bounding_box();
 264
 265                         if (!bb) {
 266                                 continue;
 267                         }
 268
 269                         CoordsByItem::const_iterator c = coords_by_item.find (*i);
 270
 271                         const double per_col_width = bb.width() / c->second.col_span;
 272                         const double per_row_height = bb.height() / c->second.row_span;
 273
 274                         /* set the width of each column spanned by this item
 275                          */
 276
 277                         for (int n = 0; n < (int) c->second.col_span; ++n) {
 278                                 col_dimens[c->second.x + n] = max (col_dimens[c->second.x + n], per_col_width);
 279                         }
 280                         for (int n = 0; n < (int) c->second.row_span; ++n) {
 281                                 row_dimens[c->second.y + n] = max (row_dimens[c->second.y + n], per_row_height);
 282                         }
 283                 }
 284         }
 285
 286         /* now progressively sum the row and column widths, once we're done:
 287          *
 288          * col_dimens: transformed into the x coordinate of the left edge of each column.
 289          *
 290          * row_dimens: transformed into the y coordinate of the upper left of each row,
 291          *
 292          */
 293
 294         double current_right_edge = left_margin + left_padding;
 295
 296         for (uint32_t n = 0; n < max_col; ++n) {
 297                 if (col_dimens[n]) {
 298                         /* a width was defined for this column */
 299                         const double w = col_dimens[n]; /* save width of this column */
 300                         col_dimens[n] = current_right_edge;
 301                         current_right_edge = current_right_edge + w + col_spacing;
 302                 }
 303         }
 304
 305         double current_top_edge = top_margin + top_padding;
 306
 307         for (uint32_t n = 0; n < max_row; ++n) {
 308                 if (row_dimens[n]) {
 309                         /* height defined for this row */
 310                         const double h = row_dimens[n]; /* save height */
 311                         row_dimens[n] = current_top_edge;
 312                         current_top_edge = current_top_edge + h + row_spacing;
 313                 }
 314         }
 315
 316         /* position each item at the upper left of its (row, col) coordinate,
 317          * given the width of all rows or columns before it.
 318          */
 319
 320         for (std::list<Item*>::iterator i = _items.begin(); i != _items.end(); ++i) {
 321                 CoordsByItem::const_iterator c = coords_by_item.find (*i);
 322
 323                 if (c == coords_by_item.end()) {
 324                         continue;
 325                 }
 326
 327                 /* do this even for hidden items - it will be corrected when
 328                  * they become visible again.
 329                  */
 330
 331                 (*i)->set_position (Duple (col_dimens[c->second.x], row_dimens[c->second.y]));
 332         }
 333
 334         _bounding_box_dirty = true;
 335         reset_bg ();
 336 }
 337
 338 void
 339 Grid::place (Item* i, double x, double y, double col_span, double row_span)
 340 {
 341         ChildInfo ci;
 342
 343         add (i);
 344
 345         ci.item = i;
 346         ci.x = x;
 347         ci.y = y;
 348         ci.col_span = max (1.0, col_span);
 349         ci.row_span = max (1.0, row_span);
 350
 351         coords_by_item.insert (std::make_pair (i, ci));
 352         reposition_children ();
 353 }
 354
 355 void
 356 Grid::child_changed ()
 357 {
 358         /* catch visibility and size changes */
 359
 360         Item::child_changed ();
 361         reposition_children ();
 362 }
 363
 364 void
 365 Grid::set_collapse_on_hide (bool yn)
 366 {
 367         if (collapse_on_hide != yn) {
 368                 collapse_on_hide = yn;
 369                 reposition_children ();
 370         }
 371 }