path: root/fluid/nodes/Group_Node.h

//
// Group Node header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-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 FLUID_NODES_GROUP_NODE_H
#define FLUID_NODES_GROUP_NODE_H

#include "nodes/Widget_Node.h"

#include <FL/Fl_Tabs.H>
#include <FL/Fl_Pack.H>
#include <FL/Fl_Flex.H>
#include <FL/Fl_Wizard.H>

void group_cb(Fl_Widget *, void *);
void ungroup_cb(Fl_Widget *, void *);

// ---- Group_Node -------------------------------------------------- MARK: -

/**
 Proxy group to use in place of Fl_Group in the interactive window.

 In an interactive environment, groups should not automatically resize their
 children. This proxy disables the layout of children by default. Children
 layout propagation may be enable temporarily by incrementing `allow_layout`
 before resizing and decrementing it again afterwards.
 */
class Fl_Group_Proxy : public Fl_Group {
public:
  Fl_Group_Proxy(int X,int Y,int W,int H) : Fl_Group(X, Y, W, H) { Fl_Group::current(0); }
  void resize(int x, int y, int w, int h);
  void draw();
};

class Group_Node : public Widget_Node
{
public:
  typedef Widget_Node super;
  static Group_Node prototype;
public:
  void ideal_size(int &w, int &h);
  const char *type_name() {return "Fl_Group";}
  const char *alt_type_name() {return "fltk::Group";}
  Fl_Widget *widget(int X,int Y,int W,int H) {
    Fl_Group_Proxy *g = new Fl_Group_Proxy(X,Y,W,H); Fl_Group::current(0); return g;}
  Widget_Node *_make() {return new Group_Node();}
  void write_code1(Code_Writer& f);
  void write_code2(Code_Writer& f);
  void add_child(Node*, Node*);
  void move_child(Node*, Node*);
  void remove_child(Node*);
  int can_have_children() const {return 1;}
  Type type() const { return FLD_NODE_TYPE_Group; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Group) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
  void leave_live_mode();
  void copy_properties();
};

// ---- Pack_Node --------------------------------------------------- MARK: -

extern const char pack_type_name[];
extern Fl_Menu_Item pack_type_menu[];

class Pack_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Pack_Node prototype;
private:
  Fl_Menu_Item *subtypes() {return pack_type_menu;}
public:
  const char *type_name() {return pack_type_name;}
  const char *alt_type_name() {return "fltk::PackedGroup";}
  Widget_Node *_make() {return new Pack_Node();}
  Type type() const { return FLD_NODE_TYPE_Pack; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Pack) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
  void copy_properties();
};

// ---- Flex_Node --------------------------------------------------- MARK: -

extern const char flex_type_name[];
extern Fl_Menu_Item flex_type_menu[];

class Fl_Flex_Proxy : public Fl_Flex {
public:
  Fl_Flex_Proxy(int X,int Y,int W,int H) : Fl_Flex(X, Y, W, H) { Fl_Group::current(0); }
  void resize(int x, int y, int w, int h);
  void draw();
};

class Flex_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Flex_Node prototype;
private:
  Fl_Menu_Item *subtypes() {return flex_type_menu;}
  int fixedSizeTupleSize; /* number of pairs in array */
  int *fixedSizeTuple; /* [ index, size, index2, size2, ... ] */
  int suspend_auto_layout;
public:
  Flex_Node() : fixedSizeTupleSize(0), fixedSizeTuple(0), suspend_auto_layout(0) { }
  const char *type_name() {return flex_type_name;}
  const char *alt_type_name() {return "fltk::FlexGroup";}
  Widget_Node *_make() { return new Flex_Node(); }
  Fl_Widget *widget(int X,int Y,int W,int H) {
    Fl_Flex *g = new Fl_Flex_Proxy(X,Y,W,H); Fl_Group::current(0); return g;}
  Type type() const { return FLD_NODE_TYPE_Flex; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Flex) ? true : super::is_a(inType); }
  void write_properties(Project_Writer &f);
  void read_property(Project_Reader &f, const char *);
  Fl_Widget *enter_live_mode(int top=0);
  void copy_properties();
  void copy_properties_for_children();
  void postprocess_read();
  void write_code2(Code_Writer& f);
//  void add_child(Node*, Node*);
//  void move_child(Node*, Node*);
  void remove_child(Node*);
  void layout_widget();
  void change_subtype_to(int n);
  void insert_child_at(Fl_Widget *child, int x, int y);
  void keyboard_move_child(Widget_Node*, int key);
  static int parent_is_flex(Node*);
  static int size(Node*, char fixed_only=0);
  static int is_fixed(Node*);
};

// ---- Table_Node -------------------------------------------------- MARK: -

class Table_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Table_Node prototype;
public:
  void ideal_size(int &w, int &h);
  const char *type_name() { return "Fl_Table"; }
  const char *alt_type_name() { return "fltk::TableGroup"; }
  Widget_Node *_make() { return new Table_Node(); }
  Fl_Widget *widget(int X, int Y, int W, int H);
  Type type() const { return FLD_NODE_TYPE_Table; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Table) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
  void add_child(Node*, Node*);
  void move_child(Node*, Node*);
  void remove_child(Node*);
};

// ---- Tabs_Node --------------------------------------------------- MARK: -

extern const char tabs_type_name[];

class Fl_Tabs_Proxy : public Fl_Tabs {
public:
  Fl_Tabs_Proxy(int X,int Y,int W,int H) : Fl_Tabs(X,Y,W,H) {}
  void resize(int,int,int,int);
  void draw();
};

class Tabs_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Tabs_Node prototype;
public:
  const char *type_name() {return tabs_type_name;}
  const char *alt_type_name() {return "fltk::TabGroup";}
  Fl_Widget *widget(int X,int Y,int W,int H) {
    Fl_Tabs_Proxy *g = new Fl_Tabs_Proxy(X,Y,W,H); Fl_Group::current(0); return g;}
  Widget_Node *_make() {return new Tabs_Node();}
  Node* click_test(int,int);
  void add_child(Node*, Node*);
  void remove_child(Node*);
  Type type() const { return FLD_NODE_TYPE_Tabs; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Tabs) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
};

// ---- Scroll_Node ------------------------------------------------- MARK: -

extern const char scroll_type_name[];
extern Fl_Menu_Item scroll_type_menu[];

class Scroll_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Scroll_Node prototype;
private:
  Fl_Menu_Item *subtypes() {return scroll_type_menu;}
public:
  const char *type_name() {return scroll_type_name;}
  const char *alt_type_name() {return "fltk::ScrollGroup";}
  Widget_Node *_make() {return new Scroll_Node();}
  Type type() const { return FLD_NODE_TYPE_Scroll; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Scroll) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
  void copy_properties();
};

// ---- Tile_Node --------------------------------------------------- MARK: -

extern const char tile_type_name[];

class Tile_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Tile_Node prototype;
public:
  const char *type_name() {return tile_type_name;}
  const char *alt_type_name() {return "fltk::TileGroup";}
  Widget_Node *_make() {return new Tile_Node();}
  Type type() const { return FLD_NODE_TYPE_Tile; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Tile) ? true : super::is_a(inType); }
  Fl_Widget *enter_live_mode(int top=0);
  void leave_live_mode();
  void copy_properties();
};

// ---- Wizard_Node ------------------------------------------------- MARK: -

class Fl_Wizard_Proxy : public Fl_Wizard {
public:
  Fl_Wizard_Proxy(int X,int Y,int W,int H) : Fl_Wizard(X,Y,W,H) {}
  void resize(int,int,int,int);
  void draw();
};

extern const char wizard_type_name[];

class Wizard_Node : public Group_Node
{
public:
  typedef Group_Node super;
  static Wizard_Node prototype;
public:
  const char *type_name() {return wizard_type_name;}
  const char *alt_type_name() {return "fltk::WizardGroup";}
  Fl_Widget *widget(int X,int Y,int W,int H) {
    Fl_Wizard_Proxy *g = new Fl_Wizard_Proxy(X,Y,W,H); Fl_Group::current(0); return g;}
  Widget_Node *_make() {return new Wizard_Node();}
  Type type() const { return FLD_NODE_TYPE_Wizard; }
  bool is_a(Type inType) const { return (inType==FLD_NODE_TYPE_Wizard) ? true : super::is_a(inType); }
};

#endif // FLUID_NODES_GROUP_NODE_H