fltk/fluid/factory.cxx

//
// Widget factory code for the Fast Light Tool Kit (FLTK).
//
// Type classes for most of the fltk widgets.  Most of the work
// is done by code in Fl_Widget_Type.C.  Also a factory instance
// of each of these type classes.
//
// This file also contains the "new" menu, which has a pointer
// to a factory instance for every class (both the ones defined
// here and ones in other files)
//
// Copyright 1998-2017 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
//

#include "factory.h"

#include "fluid.h"
#include "Fl_Window_Type.h"
#include "Fl_Group_Type.h"
#include "Fd_Snap_Action.h"
#include "pixmaps.h"
#include "undo.h"

#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Button.H>
#include <FL/Fl_Return_Button.H>
#include <FL/Fl_Repeat_Button.H>
#include <FL/Fl_Light_Button.H>
#include <FL/Fl_Check_Button.H>
#include <FL/Fl_Round_Button.H>
#include <FL/Fl_Group.H>
#include <FL/Fl_Menu_Item.H>
#include <FL/Fl_Pixmap.H>
#include <FL/Fl_Tree.H>
#include <FL/Fl_Flex.H>
#include "../src/flstring.h"

#include <stdio.h>
#include <stdlib.h>

////////////////////////////////////////////////////////////////

#include <FL/Fl_Box.H>
class Fl_Box_Type : public Fl_Widget_Type {
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Box";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Widget";}
  Fl_Widget *widget(int x,int y,int w, int h) FL_OVERRIDE {
    return new Fl_Box(x,y,w,h,"label");}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Box_Type();}
  ID id() const FL_OVERRIDE { return ID::Box; }
};
static Fl_Box_Type Fl_Box_type;



// ---- Button Types --------------------------------------------------- MARK: -


// ---- Button ----

static Fl_Menu_Item buttontype_menu[] = {
  {"Normal",0,0,(void*)0},
  {"Toggle",0,0,(void*)FL_TOGGLE_BUTTON},
  {"Radio",0,0,(void*)FL_RADIO_BUTTON},
  {0}
};

/**
 \brief A handler for the simple push button and a base class for all other buttons.
 */
class Fl_Button_Type : public Fl_Widget_Type
{
  typedef Fl_Widget_Type super;
  Fl_Menu_Item *subtypes() FL_OVERRIDE { return buttontype_menu; }
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    // TODO: this is a really bad size suggestion
    Fl_Widget_Type::ideal_size(w, h);
    w += 2 * (o->labelsize() - 4);
    h = (h / 5) * 5;
  }
  const char *type_name() FL_OVERRIDE { return "Fl_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::Button"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Button_Type(); }
  int is_button() const FL_OVERRIDE { return 1; }
  ID id() const FL_OVERRIDE { return ID::Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Button) ? true : super::is_a(inID); }
};

static Fl_Button_Type Fl_Button_type;


// ---- Return Button ----

/**
 \brief The Return Button is simply a Button with the return key as a hotkey.
 */
class Fl_Return_Button_Type : public Fl_Button_Type
{
  typedef Fl_Button_Type super;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    // TODO: this is a really bad size suggestion
    Fl_Button_Type::ideal_size(w, h);
    int W = o->h();
    if (o->w()/3 < W) W = o->w()/3;
    w += W + 8 - o->labelsize();
  }
  const char *type_name() FL_OVERRIDE { return "Fl_Return_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::ReturnButton"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Return_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Return_Button_Type(); }
  ID id() const FL_OVERRIDE { return ID::Return_Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Return_Button) ? true : super::is_a(inID); }
};

static Fl_Return_Button_Type Fl_Return_Button_type;


// ---- Repeat Button ----

/**
 \brief Handler for Fl_Repeat_Button.
 \note Even though Fl_Repeat_Button is somewhat limited compared to Fl_Button,
    and some settings may not make much sense, it is still derived from it,
    so the wrapper should be as well.
 */
class Fl_Repeat_Button_Type : public Fl_Button_Type
{
  typedef Fl_Button_Type super;
public:
  const char *type_name() FL_OVERRIDE { return "Fl_Repeat_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::RepeatButton"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Repeat_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Repeat_Button_Type(); }
  ID id() const FL_OVERRIDE { return ID::Repeat_Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Repeat_Button) ? true : super::is_a(inID); }
};

static Fl_Repeat_Button_Type Fl_Repeat_Button_type;


// ---- Light Button ----

class Fl_Light_Button_Type : public Fl_Button_Type
{
  typedef Fl_Button_Type super;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    // TODO: improve this
    Fl_Button_Type::ideal_size(w, h);
    w += 4;
  }
  const char *type_name() FL_OVERRIDE { return "Fl_Light_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::LightButton"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Light_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Light_Button_Type(); }
  ID id() const FL_OVERRIDE { return ID::Light_Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Light_Button) ? true : super::is_a(inID); }
};

static Fl_Light_Button_Type Fl_Light_Button_type;


// ---- Check Button ----

class Fl_Check_Button_Type : public Fl_Button_Type
{
  typedef Fl_Button_Type super;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    // TODO: fix this
    Fl_Button_Type::ideal_size(w, h);
    w += 4;
  }
  const char *type_name() FL_OVERRIDE { return "Fl_Check_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::CheckButton"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Check_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Check_Button_Type(); }
  ID id() const FL_OVERRIDE { return ID::Check_Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Check_Button) ? true : super::is_a(inID); }
};

static Fl_Check_Button_Type Fl_Check_Button_type;


// ---- Round Button ----

class Fl_Round_Button_Type : public Fl_Button_Type
{
  typedef Fl_Button_Type super;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    // TODO: ideas?
    Fl_Button_Type::ideal_size(w, h);
    w += 4;
  }
  const char *type_name() FL_OVERRIDE { return "Fl_Round_Button"; }
  const char *alt_type_name() FL_OVERRIDE { return "fltk::RadioButton"; }
  Fl_Widget *widget(int x, int y, int w, int h) FL_OVERRIDE {
    return new Fl_Round_Button(x, y, w, h, "button");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE { return new Fl_Round_Button_Type(); }
  ID id() const FL_OVERRIDE { return ID::Round_Button; }
  bool is_a(ID inID) FL_OVERRIDE { return (inID==ID::Round_Button) ? true : super::is_a(inID); }
};
static Fl_Round_Button_Type Fl_Round_Button_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Browser.H>
#include <FL/Fl_Check_Browser.H>
#include <FL/Fl_File_Browser.H>

static Fl_Menu_Item browser_type_menu[] = {
  {"No Select",0,0,(void*)FL_NORMAL_BROWSER},
  {"Select",0,0,(void*)FL_SELECT_BROWSER},
  {"Hold",0,0,(void*)FL_HOLD_BROWSER},
  {"Multi",0,0,(void*)FL_MULTI_BROWSER},
  {0}};
class Fl_Browser_Type : public Fl_Widget_Type { // FIXME: Fl_Group(!), Fl_Browser_
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return browser_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Browser *myo = (Fl_Browser *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Browser";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Browser";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Browser* b = new Fl_Browser(x,y,w,h);
    // Fl_Browser::add calls fl_height(), which requires the X display open.
    // Avoid this when compiling so it works w/o a display:
    if (!batch_mode) {
      char buffer[20];
      for (int i = 1; i <= 20; i++) {
        sprintf(buffer,"Browser Line %d",i);
        b->add(buffer);
      }
    }
    return b;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Browser_Type();}
  ID id() const FL_OVERRIDE { return ID::Browser; }
};
static Fl_Browser_Type Fl_Browser_type;

int Fl_Browser_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Browser *myo = (Fl_Browser*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

class Fl_Check_Browser_Type : public Fl_Widget_Type { // FIXME: Fl_Browser_
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return browser_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Check_Browser *myo = (Fl_Check_Browser *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box()) - fl_height();
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Check_Browser";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::CheckBrowser";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Check_Browser* b = new Fl_Check_Browser(x,y,w,h);
    // Fl_Check_Browser::add calls fl_height(), which requires the X display open.
    // Avoid this when compiling so it works w/o a display:
    if (!batch_mode) {
      char buffer[20];
      for (int i = 1; i <= 20; i++) {
        sprintf(buffer,"Browser Line %d",i);
        b->add(buffer);
      }
    }
    return b;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Check_Browser_Type();}
  ID id() const FL_OVERRIDE { return ID::Check_Browser; }
};
static Fl_Check_Browser_Type Fl_Check_Browser_type;

int Fl_Check_Browser_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Check_Browser *myo = (Fl_Check_Browser*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

class Fl_Tree_Type : public Fl_Widget_Type { // FIXME: Fl_Group
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    if (h < 60) h = 60;
    if (w < 80) w = 80;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Tree";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::TreeBrowser";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Tree* b = new Fl_Tree(x,y,w,h);
    if (!batch_mode) {
      b->add("/A1/B1/C1");
      b->add("/A1/B1/C2");
      b->add("/A1/B2/C1");
      b->add("/A1/B2/C2");
      b->add("/A2/B1/C1");
      b->add("/A2/B1/C2");
      b->add("/A2/B2/C1");
      b->add("/A2/B2/C2");
    }
    return b;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Tree_Type();}
  ID id() const FL_OVERRIDE { return ID::Tree; }
};
static Fl_Tree_Type Fl_Tree_type;

class Fl_File_Browser_Type : public Fl_Widget_Type { // FIXME: Fl_Browser (no underscore)
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return browser_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_File_Browser *myo = (Fl_File_Browser *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box()) + fl_height();
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_File_Browser";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::FileBrowser";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_File_Browser* b = new Fl_File_Browser(x,y,w,h);
    // Fl_File_Browser::add calls fl_height(), which requires the X display open.
    // Avoid this when compiling so it works w/o a display:
    if (!batch_mode) {
      b->load(".");
    }
    return b;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_File_Browser_Type();}
  ID id() const FL_OVERRIDE { return ID::File_Browser; }
};
static Fl_File_Browser_Type Fl_File_Browser_type;

int Fl_File_Browser_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_File_Browser *myo = (Fl_File_Browser*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Counter.H>
static Fl_Menu_Item counter_type_menu[] = {
  {"Normal",0,0,(void*)FL_NORMAL_COUNTER},
  {"Simple",0,0,(void*)FL_SIMPLE_COUNTER},
  {0}};
class Fl_Counter_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return counter_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
  int is_valuator() const FL_OVERRIDE {return 1;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Counter";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Counter";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Counter(x,y,w,h,"counter:");}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Counter_Type();}
  ID id() const FL_OVERRIDE { return ID::Counter; }
};
static Fl_Counter_Type Fl_Counter_type;

int Fl_Counter_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Counter *myo = (Fl_Counter*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Spinner.H>
static Fl_Menu_Item spinner_type_menu[] = {
  {"Integer",0,0,(void*)FL_INT_INPUT},
  {"Float",  0,0,(void*)FL_FLOAT_INPUT},
  {0}};
class Fl_Spinner_Type : public Fl_Widget_Type {  // FIXME: Fl_Group, *NOT* Fl_Valuator
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return spinner_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Spinner *myo = (Fl_Spinner *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() - 6;
    if (h < 15) h = 15;
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box()) + h / 2;
    if (w < 40) w = 40  ;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Spinner";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Spinner";}
  int is_spinner() const FL_OVERRIDE { return 1; }
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Spinner(x,y,w,h,"spinner:");
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Spinner_Type();}
  ID id() const FL_OVERRIDE { return ID::Spinner; }
};
static Fl_Spinner_Type Fl_Spinner_type;

int Fl_Spinner_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Spinner *myo = (Fl_Spinner*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = (Fl_Font)myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Input.H>
static Fl_Menu_Item input_type_menu[] = {
  {"Normal",0,0,(void*)FL_NORMAL_INPUT},
  {"Multiline",0,0,(void*)FL_MULTILINE_INPUT},
  {"Secret",0,0,(void*)FL_SECRET_INPUT},
  {"Int",0,0,(void*)FL_INT_INPUT},
  {"Float",0,0,(void*)FL_FLOAT_INPUT},
  {0}};
class Fl_Input_Type : public Fl_Widget_Type { // FIXME: Fl_Input_
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return input_type_menu;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Input *myo = (Fl_Input *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() - 6;
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    if (h < 15) h = 15;
    if (w < 15) w = 15;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Input";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Input";}
  int is_input() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Input *myo = new Fl_Input(x,y,w,h,"input:");
    myo->value("Text Input");
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Input_Type();}
  ID id() const FL_OVERRIDE { return ID::Input; }
  void copy_properties() FL_OVERRIDE {
    Fl_Widget_Type::copy_properties();
    Fl_Input_ *d = (Fl_Input_*)live_widget, *s = (Fl_Input_*)o;
    d->textfont(s->textfont());
    d->textsize(s->textsize());
    d->textcolor(s->textcolor());
    d->shortcut(s->shortcut());
  }
};
static Fl_Input_Type Fl_Input_type;

int Fl_Input_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Input_ *myo = (Fl_Input_*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_File_Input.H>
class Fl_File_Input_Type : public Fl_Widget_Type { // FIXME: Fl_Input
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return 0;}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_File_Input *myo = (Fl_File_Input *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() + 4;
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    if (h < 20) h = 20;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_File_Input";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::FileInput";}
  int is_input() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_File_Input *myo = new Fl_File_Input(x,y,w,h,"file:");
    myo->value("/now/is/the/time/for/a/filename.ext");
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_File_Input_Type();}
  ID id() const FL_OVERRIDE { return ID::File_Input; }
};
static Fl_File_Input_Type Fl_File_Input_type;

int Fl_File_Input_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_File_Input *myo = (Fl_File_Input*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Text_Display.H>
class Fl_Text_Display_Type : public Fl_Widget_Type { // FIXME: Fl_Group
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Text_Display *myo = (Fl_Text_Display *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Text_Display";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::TextDisplay";}
  int is_text_display() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Text_Display *myo = new Fl_Text_Display(x,y,w,h);
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Text_Display_Type();}
  ID id() const FL_OVERRIDE { return ID::Text_Display; }
};
static Fl_Text_Display_Type Fl_Text_Display_type;

int Fl_Text_Display_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Text_Display *myo = (Fl_Text_Display*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Text_Editor.H>
class Fl_Text_Editor_Type : public Fl_Widget_Type { // FIXME: Fl_Text_Display
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Text_Editor *myo = (Fl_Text_Editor *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Text_Editor";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::TextEditor";}
  int is_text_display() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Text_Editor *myo = new Fl_Text_Editor(x,y,w,h);
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Text_Editor_Type();}
  ID id() const FL_OVERRIDE { return ID::Text_Editor; }
};
static Fl_Text_Editor_Type Fl_Text_Editor_type;

int Fl_Text_Editor_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Text_Editor *myo = (Fl_Text_Editor*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Simple_Terminal.H>
class Fl_Simple_Terminal_Type : public Fl_Text_Editor_Type { // FIXME: Fl_Text_Display
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Simple_Terminal";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::SimpleTerminal";}
  int is_text_display() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Widget *myo = 0L;
    if (batch_mode) {
      // The Fl_Simple_Terminal constructor attaches a buffer which in turn
      // opens a connection to the display. In batch mode, we create the
      // superclass Fl_Text_Display to avoid that.
      myo = new Fl_Text_Display(x,y,w,h);
    } else {
      myo = new Fl_Simple_Terminal(x,y,w,h);
    }
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Simple_Terminal_Type();}
  ID id() const FL_OVERRIDE { return ID::Simple_Terminal; }
};
static Fl_Simple_Terminal_Type Fl_Simple_Terminal_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Clock.H>
class Fl_Clock_Type : public Fl_Widget_Type {
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Clock";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Clock";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Clock(x,y,w,h);}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Clock_Type();}
  ID id() const FL_OVERRIDE { return ID::Clock; }
};
static Fl_Clock_Type Fl_Clock_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Help_View.H>
class Fl_Help_View_Type : public Fl_Widget_Type { // FIXME: Fl_Group
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Help_View *myo = (Fl_Help_View *)o;
    fl_font(myo->textfont(), myo->textsize());
    h -= Fl::box_dh(o->box());
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    h = ((h + fl_height() - 1) / fl_height()) * fl_height() + Fl::box_dh(o->box());
    if (h < 30) h = 30;
    if (w < 50) w = 50;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Help_View";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::HelpView";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Help_View *myo = new Fl_Help_View(x,y,w,h);
    if (!batch_mode) {
      myo->value("<HTML><BODY><H1>Fl_Help_View Widget</H1>"
                 "<P>This is a Fl_Help_View widget.</P></BODY></HTML>");
    }
    return myo;}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Help_View_Type();}
  ID id() const FL_OVERRIDE { return ID::Help_View; }
};
static Fl_Help_View_Type Fl_Help_View_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Progress.H>
class Fl_Progress_Type : public Fl_Widget_Type {
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Progress";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::ProgressBar";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Progress *myo = new Fl_Progress(x,y,w,h,"label");
    myo->value(50);
    return myo;}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Progress_Type();}
  ID id() const FL_OVERRIDE { return ID::Progress; }
};
static Fl_Progress_Type Fl_Progress_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Adjuster.H>
class Fl_Adjuster_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
  int is_valuator() const FL_OVERRIDE {return 1;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Adjuster";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Adjuster";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Adjuster(x,y,w,h);}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Adjuster_Type();}
  ID id() const FL_OVERRIDE { return ID::Adjuster; }
};
static Fl_Adjuster_Type Fl_Adjuster_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Dial.H>
static Fl_Menu_Item dial_type_menu[] = {
  {"Dot",0,0,(void*)0},
  {"Line",0,0,(void*)FL_LINE_DIAL},
  {"Fill",0,0,(void*)FL_FILL_DIAL},
  {0}};
class Fl_Dial_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return dial_type_menu;}
  int is_valuator() const FL_OVERRIDE {return 1;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Dial";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Dial";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Dial(x,y,w,h);}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Dial_Type();}
  ID id() const FL_OVERRIDE { return ID::Dial; }
};
static Fl_Dial_Type Fl_Dial_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Roller.H>
static Fl_Menu_Item roller_type_menu[] = {
  {"Vertical",0,0,(void*)0},
  {"Horizontal",0,0,(void*)FL_HORIZONTAL},
  {0}};
class Fl_Roller_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return roller_type_menu;}
  int is_valuator() const FL_OVERRIDE {return 1;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Roller";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Roller";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Roller(x,y,w,h);}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Roller_Type();}
  ID id() const FL_OVERRIDE { return ID::Roller; }
};
static Fl_Roller_Type Fl_Roller_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Scrollbar.H>
static Fl_Menu_Item slider_type_menu[] = {
  {"Vertical",0,0,(void*)FL_VERT_SLIDER},
  {"Horizontal",0,0,(void*)FL_HOR_SLIDER},
  {"Vert Fill",0,0,(void*)FL_VERT_FILL_SLIDER},
  {"Horz Fill",0,0,(void*)FL_HOR_FILL_SLIDER},
  {"Vert Knob",0,0,(void*)FL_VERT_NICE_SLIDER},
  {"Horz Knob",0,0,(void*)FL_HOR_NICE_SLIDER},
  {0}};
class Fl_Slider_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return slider_type_menu;}
  int is_valuator() const FL_OVERRIDE {return 2;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Slider";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Slider";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Slider(x,y,w,h,"slider:");}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Slider_Type();}
  ID id() const FL_OVERRIDE { return ID::Slider; }
};
static Fl_Slider_Type Fl_Slider_type;

static Fl_Menu_Item scrollbar_type_menu[] = {
  {"Vertical",0,0,(void*)FL_VERT_SLIDER},
  {"Horizontal",0,0,(void*)FL_HOR_SLIDER},
  {0}};
class Fl_Scrollbar_Type : public Fl_Slider_Type {
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return scrollbar_type_menu;}
  int is_valuator() const FL_OVERRIDE {return 3;}
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Scrollbar";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Scrollbar";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Scrollbar(x,y,w,h);}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Scrollbar_Type();}
  ID id() const FL_OVERRIDE { return ID::Scrollbar; }
};
static Fl_Scrollbar_Type Fl_Scrollbar_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Output.H>
static Fl_Menu_Item output_type_menu[] = {
  {"Normal",0,0,(void*)FL_NORMAL_OUTPUT},
  {"Multiline",0,0,(void*)FL_MULTILINE_OUTPUT},
  {0}};
class Fl_Output_Type : public Fl_Input_Type {
  Fl_Menu_Item *subtypes() FL_OVERRIDE {return output_type_menu;}
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Output *myo = (Fl_Output *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() - 6;
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    if (h < 15) h = 15;
    if (w < 15) w = 15;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Output";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::Output";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Output *myo = new Fl_Output(x,y,w,h,"output:");
    myo->value("Text Output");
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Output_Type();}
  ID id() const FL_OVERRIDE { return ID::Output; }
};
static Fl_Output_Type Fl_Output_type;

////////////////////////////////////////////////////////////////

#include <FL/Fl_Value_Input.H>
class Fl_Value_Input_Type : public Fl_Widget_Type { // FIXME: Fl_Input_
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Value_Input *myo = (Fl_Value_Input *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() - 6;
    w -= Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    if (h < 15) h = 15;
    if (w < 15) w = 15;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Value_Input";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::ValueInput";}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
  int is_valuator() const FL_OVERRIDE {return 1;}
  int is_value_input() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Value_Input *myo = new Fl_Value_Input(x,y,w,h,"value:");
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Value_Input_Type();}
  ID id() const FL_OVERRIDE { return ID::Value_Input; }
};
static Fl_Value_Input_Type Fl_Value_Input_type;

int Fl_Value_Input_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Value_Input *myo = (Fl_Value_Input*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Value_Output.H>
class Fl_Value_Output_Type : public Fl_Widget_Type { // FIXME: Fl_Valuator
public:
  void ideal_size(int &w, int &h) FL_OVERRIDE {
    Fl_Value_Output *myo = (Fl_Value_Output *)o;
    fl_font(myo->textfont(), myo->textsize());
    h = fl_height() + myo->textsize() - 6;
    w = o->w() - Fl::box_dw(o->box());
    int ww = (int)fl_width('m');
    w = ((w + ww - 1) / ww) * ww + Fl::box_dw(o->box());
    if (h < 15) h = 15;
    if (w < 15) w = 15;
  }
  const char *type_name() FL_OVERRIDE {return "Fl_Value_Output";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::ValueOutput";}
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
  int is_valuator() const FL_OVERRIDE {return 1;}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    Fl_Value_Output *myo = new Fl_Value_Output(x,y,w,h,"value:");
    return myo;
  }
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Value_Output_Type();}
  ID id() const FL_OVERRIDE { return ID::Value_Output; }
};
static Fl_Value_Output_Type Fl_Value_Output_type;

int Fl_Value_Output_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Value_Output *myo = (Fl_Value_Output*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

#include <FL/Fl_Value_Slider.H>
class Fl_Value_Slider_Type : public Fl_Slider_Type {
  int textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) FL_OVERRIDE;
public:
  const char *type_name() FL_OVERRIDE {return "Fl_Value_Slider";}
  const char *alt_type_name() FL_OVERRIDE {return "fltk::ValueSlider";}
  Fl_Widget *widget(int x,int y,int w,int h) FL_OVERRIDE {
    return new Fl_Value_Slider(x,y,w,h,"slider:");}
  Fl_Widget_Type *_make() FL_OVERRIDE {return new Fl_Value_Slider_Type();}
  ID id() const FL_OVERRIDE { return ID::Value_Slider; }
};
static Fl_Value_Slider_Type Fl_Value_Slider_type;

int Fl_Value_Slider_Type::textstuff(int w, Fl_Font& f, int& s, Fl_Color& c) {
  Fl_Value_Slider *myo = (Fl_Value_Slider*)(w==4 ? ((Fl_Widget_Type*)factory)->o : o);
  switch (w) {
    case 4:
    case 0: f = myo->textfont(); s = myo->textsize(); c = myo->textcolor(); break;
    case 1: myo->textfont(f); break;
    case 2: myo->textsize(s); break;
    case 3: myo->textcolor(c); break;
  }
  return 1;
}

////////////////////////////////////////////////////////////////

extern class Fl_Function_Type Fl_Function_type;
extern class Fl_Code_Type Fl_Code_type;
extern class Fl_CodeBlock_Type Fl_CodeBlock_type;
extern class Fl_Data_Type Fl_Data_type;
extern class Fl_Decl_Type Fl_Decl_type;
extern class Fl_DeclBlock_Type Fl_DeclBlock_type;
extern class Fl_Comment_Type Fl_Comment_type;
extern class Fl_Class_Type Fl_Class_type;
extern class Fl_Window_Type Fl_Window_type;
extern class Fl_Widget_Class_Type Fl_Widget_Class_type;
extern class Fl_Group_Type Fl_Group_type;
extern class Fl_Pack_Type Fl_Pack_type;
extern class Fl_Flex_Type Fl_Flex_type;
extern class Fl_Tabs_Type Fl_Tabs_type;
extern class Fl_Scroll_Type Fl_Scroll_type;
extern class Fl_Table_Type Fl_Table_type;
extern class Fl_Tile_Type Fl_Tile_type;
extern class Fl_Input_Choice_Type Fl_Input_Choice_type;
extern class Fl_Choice_Type Fl_Choice_type;
extern class Fl_Menu_Bar_Type Fl_Menu_Bar_type;
extern class Fl_Menu_Button_Type Fl_Menu_Button_type;
extern class Fl_Menu_Item_Type Fl_Menu_Item_type;
extern class Fl_Checkbox_Menu_Item_Type Fl_Checkbox_Menu_Item_type;
extern class Fl_Radio_Menu_Item_Type Fl_Radio_Menu_Item_type;
extern class Fl_Submenu_Type Fl_Submenu_type;
extern class Fl_Wizard_Type Fl_Wizard_type;

extern void select(Fl_Type *,int);
extern void select_only(Fl_Type *);

/**
 List all known types.
 This is used to convert a type name into a pointer to the prototype.
 This list may contain types that are supported in .fl files, but not
 available in the *New* menu.
 */
static Fl_Type *known_types[] = {
  // functions
  (Fl_Type*)&Fl_Function_type,
  (Fl_Type*)&Fl_Code_type,
  (Fl_Type*)&Fl_CodeBlock_type,
  (Fl_Type*)&Fl_Decl_type,
  (Fl_Type*)&Fl_DeclBlock_type,
  (Fl_Type*)&Fl_Class_type,
  (Fl_Type*)&Fl_Widget_Class_type,
  (Fl_Type*)&Fl_Comment_type,
  (Fl_Type*)&Fl_Data_type,
  // groups
  (Fl_Type*)&Fl_Window_type,
  (Fl_Type*)&Fl_Group_type,
  (Fl_Type*)&Fl_Pack_type,
  (Fl_Type*)&Fl_Flex_type,
  (Fl_Type*)&Fl_Tabs_type,
  (Fl_Type*)&Fl_Scroll_type,
  (Fl_Type*)&Fl_Tile_type,
  (Fl_Type*)&Fl_Wizard_type,
  // buttons
  (Fl_Type*)&Fl_Button_type,
  (Fl_Type*)&Fl_Return_Button_type,
  (Fl_Type*)&Fl_Light_Button_type,
  (Fl_Type*)&Fl_Check_Button_type,
  (Fl_Type*)&Fl_Repeat_Button_type,
  (Fl_Type*)&Fl_Round_Button_type,
  // valuators
  (Fl_Type*)&Fl_Slider_type,
  (Fl_Type*)&Fl_Scrollbar_type,
  (Fl_Type*)&Fl_Value_Slider_type,
  (Fl_Type*)&Fl_Adjuster_type,
  (Fl_Type*)&Fl_Counter_type,
  (Fl_Type*)&Fl_Spinner_type,
  (Fl_Type*)&Fl_Dial_type,
  (Fl_Type*)&Fl_Roller_type,
  (Fl_Type*)&Fl_Value_Input_type,
  (Fl_Type*)&Fl_Value_Output_type,
  // text
  (Fl_Type*)&Fl_Input_type,
  (Fl_Type*)&Fl_Output_type,
  (Fl_Type*)&Fl_Text_Editor_type,
  (Fl_Type*)&Fl_Text_Display_type,
  (Fl_Type*)&Fl_File_Input_type,
  (Fl_Type*)&Fl_Simple_Terminal_type,
  // menus
  (Fl_Type*)&Fl_Menu_Bar_type,
  (Fl_Type*)&Fl_Menu_Button_type,
  (Fl_Type*)&Fl_Choice_type,
  (Fl_Type*)&Fl_Input_Choice_type,
  (Fl_Type*)&Fl_Submenu_type,
  (Fl_Type*)&Fl_Menu_Item_type,
  (Fl_Type*)&Fl_Checkbox_Menu_Item_type,
  (Fl_Type*)&Fl_Radio_Menu_Item_type,
  // browsers
  (Fl_Type*)&Fl_Browser_type,
  (Fl_Type*)&Fl_Check_Browser_type,
  (Fl_Type*)&Fl_File_Browser_type,
  (Fl_Type*)&Fl_Tree_type,
  (Fl_Type*)&Fl_Help_View_type,
  (Fl_Type*)&Fl_Table_type,
  // misc
  (Fl_Type*)&Fl_Box_type,
  (Fl_Type*)&Fl_Clock_type,
  (Fl_Type*)&Fl_Progress_type,
};

/**
 Create and add a new widget to the widget tree.

 Fluid will try to set a default postion for widgets to the user's expectation.
 Using the context menu will put new widgets at the position of the mouse click.
 Pulldown menu and bin actions will generate widgets no too far from previously
 added widgets in the same group.

 Widgets can be added by dragging them from the widget bin to the
 desired location.

 By setting the strategy, widgets are added as the last child of a group (this
 is done when reading them from a file), or close to the current widget, which
 the user would expect in interactive mode.

 \param[in] inPrototype pointer to one of the FL_..._type prototype; note the
    lower case 't' in type.
 \param[in] strategy add after current or as last child

 \see add_new_widget_from_file(const char*, int)
 add_new_widget_from_user(Fl_Type*, int)
 add_new_widget_from_user(const char*, int)
 */
Fl_Type *add_new_widget_from_user(Fl_Type *inPrototype, Strategy strategy) {
  undo_checkpoint();
  undo_suspend();
  Fl_Type *t = ((Fl_Type*)inPrototype)->make(strategy);
  if (t) {
    if (t->is_widget() && !t->is_window())
    {
      Fl_Widget_Type *wt = (Fl_Widget_Type *)t;

      // Set font sizes...
      wt->o->labelsize(layout->labelsize);
      wt->o->labelfont(layout->labelfont);

      Fl_Font f = layout->textfont;
      int s = layout->textsize;
      Fl_Color c;

      wt->textstuff(1, f, s, c);
      wt->textstuff(2, f, s, c);

      // Resize and/or reposition new widget...
      int w = 0, h = 0;
      wt->ideal_size(w, h);

      if ((t->parent && t->parent->is_flex())) {
        // Do not resize or layout the widget. Flex will need the widget size.
      } else if (wt->id() == Fl_Type::ID::Menu_Bar) {
        // Move and resize the menubar across the top of the window...
        wt->o->resize(0, 0, w, h);
      } else {
        if (Fl_Window_Type::popupx != 0x7FFFFFFF) {
          // If this callback was called from the RMB popup menu in a window,
          // popupx and popupy will contain the mouse coordinates at RMB event.
          wt->o->resize(Fl_Window_Type::popupx, Fl_Window_Type::popupy, w, h);
        } else {
          // If popupx is invalid, use the default position and find a good
          // size for the widget.
          wt->o->size(w, h);
        }
      }
    }
    // make the new widget visible
    select_only(t);
    set_modflag(1);
    t->open();
  } else {
    undo_current --;
    undo_last --;
  }
  undo_resume();
  return t;
}

/**
 Create and add a new widget to the widget tree.
 \param[in] inName find the right prototype by this name
 \param[in] strategy where to add the node
 \return the newly created node
 \see add_new_widget_from_file(const char*, int)
 add_new_widget_from_user(Fl_Type*, int)
 add_new_widget_from_user(const char*, int)
 */
Fl_Type *add_new_widget_from_user(const char *inName, Strategy strategy) {
  Fl_Type *prototype = typename_to_prototype(inName);
  if (prototype)
    return add_new_widget_from_user(prototype, strategy);
  else
    return NULL;
}

/**
 Callback for all menu items.
 */
static void cb(Fl_Widget *, void *v) {
  Fl_Type *t = NULL;
  if (Fl_Type::current && Fl_Type::current->is_group())
    t = ((Fl_Type*)v)->make(kAddAsLastChild);
  else
    t = ((Fl_Type*)v)->make(kAddAfterCurrent);
  select_only(t);
}

Fl_Menu_Item New_Menu[] = {
{"Code",0,0,0,FL_SUBMENU},
  {"Function/Method",0,cb,(void*)&Fl_Function_type},
  {"Code",0,cb,(void*)&Fl_Code_type},
  {"Code Block",0,cb,(void*)&Fl_CodeBlock_type},
  {"Declaration",0,cb,(void*)&Fl_Decl_type},
  {"Declaration Block",0,cb,(void*)&Fl_DeclBlock_type},
  {"Class",0,cb,(void*)&Fl_Class_type},
  {"Widget Class",0,cb,(void*)&Fl_Widget_Class_type},
  {"Comment",0,cb,(void*)&Fl_Comment_type},
  {"Inlined Data",0,cb,(void*)&Fl_Data_type},
{0},
{"Group",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Window_type},
  {0,0,cb,(void*)&Fl_Group_type},
  {0,0,cb,(void*)&Fl_Pack_type},
  {0,0,cb,(void*)&Fl_Flex_type},
  {0,0,cb,(void*)&Fl_Tabs_type},
  {0,0,cb,(void*)&Fl_Scroll_type},
  {0,0,cb,(void*)&Fl_Tile_type},
  {0,0,cb,(void*)&Fl_Wizard_type},
{0},
{"Buttons",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Button_type},
  {0,0,cb,(void*)&Fl_Return_Button_type},
  {0,0,cb,(void*)&Fl_Light_Button_type},
  {0,0,cb,(void*)&Fl_Check_Button_type},
  {0,0,cb,(void*)&Fl_Repeat_Button_type},
  {0,0,cb,(void*)&Fl_Round_Button_type},
{0},
{"Valuators",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Slider_type},
  {0,0,cb,(void*)&Fl_Scrollbar_type},
  {0,0,cb,(void*)&Fl_Value_Slider_type},
  {0,0,cb,(void*)&Fl_Adjuster_type},
  {0,0,cb,(void*)&Fl_Counter_type},
  {0,0,cb,(void*)&Fl_Spinner_type},
  {0,0,cb,(void*)&Fl_Dial_type},
  {0,0,cb,(void*)&Fl_Roller_type},
  {0,0,cb,(void*)&Fl_Value_Input_type},
  {0,0,cb,(void*)&Fl_Value_Output_type},
{0},
{"Text",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Input_type},
  {0,0,cb,(void*)&Fl_Output_type},
  {0,0,cb,(void*)&Fl_Text_Editor_type},
  {0,0,cb,(void*)&Fl_Text_Display_type},
  {0,0,cb,(void*)&Fl_File_Input_type},
  {0,0,cb,(void*)&Fl_Simple_Terminal_type},
{0},
{"Menus",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Menu_Bar_type},
  {0,0,cb,(void*)&Fl_Menu_Button_type},
  {0,0,cb,(void*)&Fl_Choice_type},
  {0,0,cb,(void*)&Fl_Input_Choice_type},
  {0,0,cb, (void*)&Fl_Submenu_type},
  {0,0,cb, (void*)&Fl_Menu_Item_type},
  {"Checkbox Menu Item",0,cb, (void*)&Fl_Checkbox_Menu_Item_type},
  {"Radio Menu Item",0,cb, (void*)&Fl_Radio_Menu_Item_type},
{0},
{"Browsers",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Browser_type},
  {0,0,cb,(void*)&Fl_Check_Browser_type},
  {0,0,cb,(void*)&Fl_File_Browser_type},
  {0,0,cb,(void*)&Fl_Tree_type},
  {0,0,cb,(void*)&Fl_Help_View_type},
  {0,0,cb,(void*)&Fl_Table_type},
{0},
{"Other",0,0,0,FL_SUBMENU},
  {0,0,cb,(void*)&Fl_Box_type},
  {0,0,cb,(void*)&Fl_Clock_type},
  {0,0,cb,(void*)&Fl_Progress_type},
{0},
{0}};

#include <FL/Fl_Multi_Label.H>

/**
 Modify a menuitem to display an icon in front of the label.
 This is implemented using Fl_Multi_Label as the labeltype (FL_MULTI_LABEL).
 The icon may be null. If ic is null only the text is assigned
 to the label and Fl_Multi_Label is not used.
 \param[in] mi pointer to tme menu item that will be modified
 \param[in] ic icon for the menu, may be NULL
 \param[in] txt new label text, may *not* be NULL, will not be copied
 */
static void make_iconlabel(Fl_Menu_Item *mi, Fl_Image *ic, const char *txt)
{
  if (ic) {
    char *t1 = new char[strlen(txt)+6];
    strcpy(t1, " ");
    strcat(t1, txt);
    strcat(t1, "...");
    Fl_Multi_Label *ml = new Fl_Multi_Label;
    ml->labela = (char*)ic;
    ml->labelb = t1;
    ml->typea = FL_IMAGE_LABEL;
    ml->typeb = FL_NORMAL_LABEL;
    ml->label(mi);
  } else {
    if (txt != mi->text)
      mi->label(txt);
  }
}

void fill_in_New_Menu() {
  for (unsigned i = 0; i < sizeof(New_Menu)/sizeof(*New_Menu); i++) {
    Fl_Menu_Item *m = New_Menu+i;
    if (m->user_data()) {
      Fl_Type *t = (Fl_Type*)m->user_data();
      if (m->text) {
        make_iconlabel( m, pixmap[t->id()], m->label() );
      } else {
        const char *n = t->type_name();
        if (!strncmp(n,"Fl_",3)) n += 3;
        if (!strncmp(n,"fltk::",6)) n += 6;
        make_iconlabel( m, pixmap[t->id()], n );
      }
    }
  }
}

/**
 Find the correct prototype for a given type name.
 \param[in] inName a C string that must match type_name() or alt_type_name() of
    one of the known Fl_Type classes.
 \return the matching prototype or NULL
 */
Fl_Type *typename_to_prototype(const char *inName)
{
  if (inName==NULL || *inName==0)
    return NULL;
  for (unsigned i = 0; i < sizeof(known_types)/sizeof(*known_types); i++) {
    Fl_Type *prototype = known_types[i];
    if (fl_ascii_strcasecmp(inName, prototype->type_name())==0)
      return prototype;
    if (fl_ascii_strcasecmp(inName, prototype->alt_type_name())==0)
      return prototype;
  }
  return NULL;
}

/**
 Create and add a new type node to the widget tree.

 This is used by the .fl file reader. New types are always created as
 the last child of the first compatible parent. New widgets have a default
 setup. Their position, size and label will be read next in the file.

 \param[in] inName a C string that described the type we want
 \param[in] strategy add after current or as last child
 \return the type node that was created or NULL
 \see add_new_widget_from_file(const char*, int)
 add_new_widget_from_user(Fl_Type*, int)
 add_new_widget_from_user(const char*, int)
*/
Fl_Type *add_new_widget_from_file(const char *inName, Strategy strategy) {
  reading_file = 1; // makes labels be null
  Fl_Type *prototype = typename_to_prototype(inName);
  if (!prototype)
    return NULL;
  Fl_Type *new_node = prototype->make(strategy);
  reading_file = 0;
  return new_node;
}

////////////////////////////////////////////////////////////////

// Since I have included all the .H files, do this table here:
// This table is only used to read fdesign files:

struct symbol {const char *name; int value;};

/**
 Table with all symbols known by the "fdesign" format reader.
 This table does not need to be sorted alphabetically.
 */
static symbol table[] = {
  {"BLACK",                     FL_BLACK},
  {"RED",                       FL_RED},
  {"GREEN",                     FL_GREEN},
  {"YELLOW",                    FL_YELLOW},
  {"BLUE",                      FL_BLUE},
  {"MAGENTA",                   FL_MAGENTA},
  {"CYAN",                      FL_CYAN},
  {"WHITE",                     FL_WHITE},

  {"LCOL",                      FL_BLACK},
  {"COL1",                      FL_GRAY},
  {"MCOL",                      FL_LIGHT1},
  {"LEFT_BCOL",                 FL_LIGHT3},
  {"TOP_BCOL",                  FL_LIGHT2},
  {"BOTTOM_BCOL",               FL_DARK2},
  {"RIGHT_BCOL",                FL_DARK3},
  {"INACTIVE",                  FL_INACTIVE_COLOR},
  {"INACTIVE_COL",              FL_INACTIVE_COLOR},
  {"FREE_COL1",                 FL_FREE_COLOR},
  {"FREE_COL2",                 FL_FREE_COLOR+1},
  {"FREE_COL3",                 FL_FREE_COLOR+2},
  {"FREE_COL4",                 FL_FREE_COLOR+3},
  {"FREE_COL5",                 FL_FREE_COLOR+4},
  {"FREE_COL6",                 FL_FREE_COLOR+5},
  {"FREE_COL7",                 FL_FREE_COLOR+6},
  {"FREE_COL8",                 FL_FREE_COLOR+7},
  {"FREE_COL9",                 FL_FREE_COLOR+8},
  {"FREE_COL10",                FL_FREE_COLOR+9},
  {"FREE_COL11",                FL_FREE_COLOR+10},
  {"FREE_COL12",                FL_FREE_COLOR+11},
  {"FREE_COL13",                FL_FREE_COLOR+12},
  {"FREE_COL14",                FL_FREE_COLOR+13},
  {"FREE_COL15",                FL_FREE_COLOR+14},
  {"FREE_COL16",                FL_FREE_COLOR+15},
  {"TOMATO",                    131},
  {"INDIANRED",                 164},
  {"SLATEBLUE",                 195},
  {"DARKGOLD",                  84},
  {"PALEGREEN",                 157},
  {"ORCHID",                    203},
  {"DARKCYAN",                  189},
  {"DARKTOMATO",                113},
  {"WHEAT",                     174},
  {"ALIGN_CENTER",              FL_ALIGN_CENTER},
  {"ALIGN_TOP",                 FL_ALIGN_TOP},
  {"ALIGN_BOTTOM",              FL_ALIGN_BOTTOM},
  {"ALIGN_LEFT",                FL_ALIGN_LEFT},
  {"ALIGN_RIGHT",               FL_ALIGN_RIGHT},
  {"ALIGN_INSIDE",              FL_ALIGN_INSIDE},
  {"ALIGN_TOP_LEFT",            FL_ALIGN_TOP | FL_ALIGN_LEFT},
  {"ALIGN_TOP_RIGHT",           FL_ALIGN_TOP | FL_ALIGN_RIGHT},
  {"ALIGN_BOTTOM_LEFT",         FL_ALIGN_BOTTOM | FL_ALIGN_LEFT},
  {"ALIGN_BOTTOM_RIGHT",        FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT},
  {"ALIGN_CENTER|FL_ALIGN_INSIDE",      FL_ALIGN_CENTER|FL_ALIGN_INSIDE},
  {"ALIGN_TOP|FL_ALIGN_INSIDE",         FL_ALIGN_TOP|FL_ALIGN_INSIDE},
  {"ALIGN_BOTTOM|FL_ALIGN_INSIDE",      FL_ALIGN_BOTTOM|FL_ALIGN_INSIDE},
  {"ALIGN_LEFT|FL_ALIGN_INSIDE",        FL_ALIGN_LEFT|FL_ALIGN_INSIDE},
  {"ALIGN_RIGHT|FL_ALIGN_INSIDE",       FL_ALIGN_RIGHT|FL_ALIGN_INSIDE},
  {"ALIGN_INSIDE|FL_ALIGN_INSIDE",      FL_ALIGN_INSIDE|FL_ALIGN_INSIDE},
  {"ALIGN_TOP_LEFT|FL_ALIGN_INSIDE",    FL_ALIGN_TOP|FL_ALIGN_LEFT|FL_ALIGN_INSIDE},
  {"ALIGN_TOP_RIGHT|FL_ALIGN_INSIDE",   FL_ALIGN_TOP|FL_ALIGN_RIGHT|FL_ALIGN_INSIDE},
  {"ALIGN_BOTTOM_LEFT|FL_ALIGN_INSIDE", FL_ALIGN_BOTTOM|FL_ALIGN_LEFT|FL_ALIGN_INSIDE},
  {"ALIGN_BOTTOM_RIGHT|FL_ALIGN_INSIDE",FL_ALIGN_BOTTOM|FL_ALIGN_RIGHT|FL_ALIGN_INSIDE},

  {"ALIGN_LEFT_TOP",            FL_ALIGN_TOP | FL_ALIGN_LEFT},
  {"ALIGN_RIGHT_TOP",           FL_ALIGN_TOP | FL_ALIGN_RIGHT},
  {"ALIGN_LEFT_BOTTOM",         FL_ALIGN_BOTTOM | FL_ALIGN_LEFT},
  {"ALIGN_RIGHT_BOTTOM",        FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT},
  {"INVALID_STYLE",             255},
  {"NORMAL_STYLE",              FL_HELVETICA},
  {"BOLD_STYLE",                FL_HELVETICA|FL_BOLD},
  {"ITALIC_STYLE",              FL_HELVETICA|FL_ITALIC},
  {"BOLDITALIC_STYLE",          FL_HELVETICA|FL_BOLD|FL_ITALIC},
  {"FIXED_STYLE",               FL_COURIER},
  {"FIXEDBOLD_STYLE",           FL_COURIER|FL_BOLD},
  {"FIXEDITALIC_STYLE",         FL_COURIER|FL_ITALIC},
  {"FIXEDBOLDITALIC_STYLE",     FL_COURIER|FL_BOLD|FL_ITALIC},
  {"TIMES_STYLE",               FL_TIMES},
  {"TIMESBOLD_STYLE",           FL_TIMES|FL_BOLD},
  {"TIMESITALIC_STYLE",         FL_TIMES|FL_ITALIC},
  {"TIMESBOLDITALIC_STYLE",     FL_TIMES|FL_BOLD|FL_ITALIC},
  {"SHADOW_STYLE",              (_FL_SHADOW_LABEL<<8)},
  {"ENGRAVED_STYLE",            (_FL_ENGRAVED_LABEL<<8)},
  {"EMBOSSED_STYLE",            (_FL_EMBOSSED_LABEL<<0)},
  {"TINY_SIZE",                 8},
  {"SMALL_SIZE",                11},
  {"NORMAL_SIZE",               FL_NORMAL_SIZE},
  {"MEDIUM_SIZE",               18},
  {"LARGE_SIZE",                24},
  {"HUGE_SIZE",                 32},
  {"DEFAULT_SIZE",              FL_NORMAL_SIZE},
  {"TINY_FONT",                 8},
  {"SMALL_FONT",                11},
  {"NORMAL_FONT",               FL_NORMAL_SIZE},
  {"MEDIUM_FONT",               18},
  {"LARGE_FONT",                24},
  {"HUGE_FONT",                 32},
  {"NORMAL_FONT1",              11},
  {"NORMAL_FONT2",              FL_NORMAL_SIZE},
  {"DEFAULT_FONT",              11},
  {"RETURN_END_CHANGED",        0},
  {"RETURN_CHANGED",            1},
  {"RETURN_END",                2},
  {"RETURN_ALWAYS",             3},
  {"PUSH_BUTTON",               FL_TOGGLE_BUTTON},
  {"RADIO_BUTTON",              FL_RADIO_BUTTON},
  {"HIDDEN_BUTTON",             FL_HIDDEN_BUTTON},
  {"SELECT_BROWSER",            FL_SELECT_BROWSER},
  {"HOLD_BROWSER",              FL_HOLD_BROWSER},
  {"MULTI_BROWSER",             FL_MULTI_BROWSER},
  {"SIMPLE_COUNTER",            FL_SIMPLE_COUNTER},
  {"LINE_DIAL",                 FL_LINE_DIAL},
  {"FILL_DIAL",                 FL_FILL_DIAL},
  {"VERT_SLIDER",               FL_VERT_SLIDER},
  {"HOR_SLIDER",                FL_HOR_SLIDER},
  {"VERT_FILL_SLIDER",          FL_VERT_FILL_SLIDER},
  {"HOR_FILL_SLIDER",           FL_HOR_FILL_SLIDER},
  {"VERT_NICE_SLIDER",          FL_VERT_NICE_SLIDER},
  {"HOR_NICE_SLIDER",           FL_HOR_NICE_SLIDER},
};

/**
 \brief Find a symbol in an array of name/value pairs and return the value.

 If numberok is 0, and the symbol was not found, v remains unchanged and the
 function returns 0.

 If numberok is set and no label matched, the symbol is interpreted as a
 string containing an integer. If the string is not an integer, v is set to 0
 and the function returns 0.

 If the symbol is found, or the integer could be read, v is set to the
 value, and the function returns 1.

 \param[in] name find a symbol by this name, a leading "FL_" is ignored
 \param[out] v value associated to the symbol, or the integer value
 \param[in] numberok if set, the symbol can also be a text representing an
    integer number
 \return 0 if the symbol was not found and the integer was not valid
 \return 1 otherwise and set v
 */
int lookup_symbol(const char *name, int &v, int numberok) {
  if ((name[0]=='F') && (name[1]=='L') && (name[2]=='_'))
    name += 3;
  for (int i=0; i < int(sizeof(table)/sizeof(*table)); i++) {
    if (!fl_ascii_strcasecmp(name,table[i].name)) {
      v = table[i].value;
      return 1;
    }
  }
  if (numberok && ((v = atoi(name)) || !strcmp(name,"0")))
    return 1;
  return 0;
}