Fl_Flex.H

//
// Fl_Flex widget header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 2020 by Karsten Pedersen
// Copyright 2022-2023 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//
 
#ifndef Fl_Flex_H
#define Fl_Flex_H
 
#include <FL/Fl_Group.H>
 
class FL_EXPORT Fl_Flex : public Fl_Group {
 
  int margin_left_;           // left margin
  int margin_top_;            // top margin
  int margin_right_;          // right margin
  int margin_bottom_;         // bottom margin
  int gap_;                   // gap between widgets
  int fixed_size_size_;       // number of fixed size widgets in array
  int fixed_size_alloc_;      // allocated size of fixed size array
  Fl_Widget **fixed_size_;    // array of fixed size widgets
  bool need_layout_;          // true if layout needs to be calculated
 
public:
 
  enum { // values for type(int)
    VERTICAL   = 0,     
    HORIZONTAL = 1,     
    COLUMN     = 0,     
    ROW        = 1      
  };
 
  // FLTK standard constructor
  Fl_Flex(int X, int Y, int W, int H, const char *L = 0);
 
  // original Fl_Flex constructors:
  // backwards compatible if direction enums { ROW | COLUMN } are used
 
  Fl_Flex(int direction);
  Fl_Flex(int w, int h, int direction);
  Fl_Flex(int x, int y, int w, int h, int direction);
 
  virtual ~Fl_Flex();
 
  virtual void end();
  void resize(int x, int y, int w, int h) FL_OVERRIDE;
 
  void fixed(Fl_Widget &w, int size) {
    fixed(&w, size);
  }
 
  void fixed(Fl_Widget *w, int size);
  int fixed(Fl_Widget *w) const;
 
protected:
 
  void init(int t = VERTICAL);
 
  virtual int alloc_size(int size) const;
 
  void on_remove(int) FL_OVERRIDE;
  void draw() FL_OVERRIDE;
 
public:
 
  void need_layout(int set) {
    if (set) need_layout_ = true;
    else need_layout_ = false;
  }
 
  bool need_layout() const {
    return need_layout_;
  }
 
  int margin() const { return margin_left_; }
 
  int margin(int *left, int *top, int *right, int *bottom) const {
    if (left) *left = margin_left_;
    if (top) *top = margin_top_;
    if (right) *right = margin_right_;
    if (bottom) *bottom = margin_bottom_;
    if (margin_left_ == margin_top_ && margin_top_ == margin_right_ && margin_right_ == margin_bottom_)
      return 1;
    return 0;
  }
 
  void margin(int m, int g = -1) {
    if (m < 0)
      m = 0;
    margin_left_ = margin_top_ = margin_right_ = margin_bottom_ = m;
    if (g >= 0)
      gap_ = g;
    need_layout(1);
  }
 
  void margin(int left, int top, int right, int bottom) {
    margin_left_   = left < 0 ? 0 : left;
    margin_top_    = top < 0 ? 0 : top;
    margin_right_  = right < 0 ? 0 : right;
    margin_bottom_ = bottom < 0 ? 0 : bottom;
    need_layout(1);
  }
 
  int gap() const {
    return gap_;
  }
 
  void gap(int g) {
    gap_ = g < 0 ? 0 : g;
    need_layout(1);
  }
 
  int horizontal() const {
    return type() == Fl_Flex::HORIZONTAL ? 1 : 0;
  }
 
  // Calculate the layout of the widget and redraw it.
  void layout();
 
  int spacing() const {
    return gap_;
  }
 
  void spacing(int i) {
    gap(i);
    need_layout(1);
  }
 
};
 
#endif // Fl_Flex_H