#ifndef __MAIN_H__
#define __MAIN_H__

#include <FL/fl_utf8.h>
#include <FL/Fl.H>
#include <FL/fl_ask.H>
#include <FL/fl_draw.H>

#include <FL/Fl_File_Chooser.H>

#include <FL/Fl_Printer.H>

#include <FL/Fl_Image.H>
 #include <FL/Fl_Shared_Image.H>
 #include <FL/Fl_Bitmap.H>
  #include <FL/Fl_XBM_Image.H>
 #include <FL/Fl_Pixmap.H>
  #include <FL/Fl_GIF_Image.H>
  #include <FL/Fl_XPM_Image.H>
 #include <FL/Fl_RGB_Image.H>
  #include <FL/Fl_BMP_Image.H>
  #include <FL/Fl_PNG_Image.H>
  #include <FL/Fl_JPEG_Image.H>
  #include <FL/Fl_PNM_Image.H>
 #include <FL/Fl_Tiled_Image.H>

#include <FL/Fl_Box.H>

#include <FL/Fl_Button.H>
 #include <FL/Fl_Radio_Button.H>
 #include <FL/Fl_Repeat_Button.H>
 #include <FL/Fl_Return_Button.H>
 #include <FL/Fl_Toggle_Button.H>
 #include <FL/Fl_Light_Button.H>
  #include <FL/Fl_Check_Button.H>
  #include <FL/Fl_Radio_Light_Button.H>
  #include <FL/Fl_Round_Button.H>
  #include <FL/Fl_Radio_Round_Button.H>

#include <FL/Fl_Chart.H>

#include <FL/Fl_Clock.H>
 #include <FL/Fl_Round_Clock.H>


#include <FL/Fl_Input_.H>
 #include <FL/Fl_Input.H>
  #include <FL/Fl_File_Input.H>
  #include <FL/Fl_Float_Input.H>
  #include <FL/Fl_Int_Input.H>
  #include <FL/Fl_Multiline_Input.H>
  #include <FL/Fl_Secret_Input.H>
  #include <FL/Fl_Output.H>
   #include <FL/Fl_Multiline_Output.H>

#include <FL/Fl_Menu_.H>
 #include <FL/Fl_Choice.H>
 #include <FL/Fl_Menu_Bar.H>
 #include <FL/Fl_Menu_Button.H>
#include <FL/Fl_Menu_Item.H>

#include <FL/Fl_Progress.H>

#include <FL/Fl_Valuator.H>
 #include <FL/Fl_Adjuster.H>
  #include <FL/Fl_Counter.H>
   #include <FL/Fl_Simple_Counter.H>
 #include <FL/Fl_Dial.H>
  #include <FL/Fl_Fill_Dial.H>
  #include <FL/Fl_Line_Dial.H>
 #include <FL/Fl_Roller.H>
 #include <FL/Fl_Slider.H>
  #include <FL/Fl_Hor_Slider.H>
  #include <FL/Fl_Fill_Slider.H>
  #include <FL/Fl_Hor_Fill_Slider.H>
  #include <FL/Fl_Nice_Slider.H>
  #include <FL/Fl_Hor_Nice_Slider.H>
  #include <FL/Fl_Scrollbar.H>
  #include <FL/Fl_Value_Slider.H>
   #include <FL/Fl_Hor_Value_Slider.H>

 #include <FL/Fl_Value_Input.H>
 #include <FL/Fl_Value_Output.H>

#include <FL/Fl_Group.H>
 #include <FL/Fl_Pack.H>
 #include <FL/Fl_Scroll.H>
 #include <FL/Fl_Tile.H>

 #include <FL/Fl_Browser_.H>
  #include <FL/Fl_Check_Browser.H>
  #include <FL/Fl_Browser.H>
   #include <FL/Fl_File_Browser.H>
   #include <FL/Fl_Hold_Browser.H>
   #include <FL/Fl_Multi_Browser.H>
   #include <FL/Fl_Select_Browser.H>

 #include <FL/Fl_Help_View.H>

 #include <FL/Fl_Input_Choice.H>

 #include <FL/Fl_Spinner.H>

 #include <FL/Fl_Table.H>
  #include <FL/Fl_Table_Row.H>

 #include <FL/Fl_Tabs.H>

#include <FL/Fl_Text_Buffer.H>
#include <FL/Fl_Text_Display.H>
 #include <FL/Fl_Text_Editor.H>

#include <FL/Fl_Tree.H>

#include <FL/Fl_Wizard.H>

 #include <FL/Fl_Window.H>
  #include <FL/Fl_Single_Window.H>
   #include <FL/Fl_Menu_Window.H>
#if 0
  #include <FL/x.H>
#endif
  #include <FL/Fl_Double_Window.H>
  #include <FL/Fl_Gl_Window.H>

 #include <FL/Fl_Color_Chooser.H>

#ifdef WIN32
 #ifdef BUILD_DLL
  #define DLL_EXPORT __declspec(dllexport)
 #else
  #define DLL_EXPORT __declspec(dllimport)
 #endif
#else
 #define DLL_EXPORT
#endif

typedef void(*Fl_drawEx)(void* self);
typedef void(*Fl_drawcellEx)(void* self, Fl_Table::TableContext context, int r, int c, int x, int y, int w, int h);
typedef int (*Fl_handleEx)(void* self, int event);
typedef void(*Fl_resizeEx)(void* self, int x, int y, int w, int h);

#define ExtendEx(name) \
class name##Ex : public name { \
  private: \
  Fl_drawEx drawcb; \
  Fl_handleEx handlecb; \
  Fl_resizeEx resizecb; \
  public: \
  void setDrawCB(Fl_drawEx cb) { drawcb = cb; } \
  void setHandleCB(Fl_handleEx cb) { handlecb = cb; } \
  void setResizeCB(Fl_resizeEx cb) { resizecb = cb; } \
  virtual ~name##Ex() {} \
  name##Ex(int x, int y, int w, int h, const char* title) : name(x, y, w, h, title) { drawcb=0; handlecb=0; resizecb=0; } \
  void draw() {\
    static bool flag=false; \
    if(!flag) { \
      if(resizecb) resizecb(this,x(),y(),w(),h()); \
      flag=true; \
    } \
    if(drawcb) \
      drawcb(this); \
    else \
      name::draw(); \
  } \
  \
  int handle(int event) { \
    int ret=0; \
    if(handlecb) ret=handlecb(this, event); \
    if(!ret) ret = name::handle(event); \
    return ret; \
  } \
  \
  void resize(int X, int Y, int W, int H){ \
    if(resizecb) resizecb(this,X,Y,W,H); \
    name::resize(X,Y,W,H); \
  } \
}; \
extern "C" { \
  name##Ex* DLL_EXPORT name##ExNew(int x, int y, int w, int h, char* title); \
  void DLL_EXPORT name##ExSetDrawCB(name##Ex*, Fl_drawEx cb); \
  void DLL_EXPORT name##ExSetHandleCB(name##Ex*, Fl_handleEx cb); \
  void DLL_EXPORT name##ExSetResizeCB(name##Ex*, Fl_resizeEx cb); \
}

#define ImplementEx(name) \
name##Ex* DLL_EXPORT name##ExNew(int x, int y, int w, int h, char* title){ return new name##Ex(x,y,w,h,title); } \
void DLL_EXPORT name##ExSetDrawCB(name##Ex* ex, Fl_drawEx cb){ ex->setDrawCB(cb); } \
void DLL_EXPORT name##ExSetHandleCB(name##Ex* ex, Fl_handleEx cb){ ex->setHandleCB(cb); } \
void DLL_EXPORT name##ExSetResizeCB(name##Ex* ex, Fl_resizeEx cb){ ex->setResizeCB(cb); }

// extends a window class with nameNew(w,h,label) and nameNew2(x,y,w,h,label) constructors
#define ExtendWindow(name) \
class name##Ex : public name { \
  private: \
  Fl_drawEx drawcb; \
  Fl_handleEx handlecb; \
  Fl_resizeEx resizecb; \
  public: \
  void setDrawCB(Fl_drawEx cb) { drawcb = cb; } \
  void setHandleCB(Fl_handleEx cb) { handlecb = cb; } \
  void setResizeCB(Fl_resizeEx cb) { resizecb = cb; } \
  virtual ~name##Ex() {} \
  name##Ex(int w, int h, const char* title) : name(w, h, title) { drawcb=0; handlecb=0; resizecb=0; } \
  name##Ex(int x, int y, int w, int h, const char* title) : name(x, y, w, h, title) { drawcb=0; handlecb=0; resizecb=0; } \
  void draw() {\
    static bool flag=false; \
    if(!flag) { \
      if(resizecb) resizecb(this,x(),y(),w(),h()); \
      flag=true; \
    } \
    if(drawcb) \
      drawcb(this); \
    else \
      name::draw(); \
  } \
  \
  int handle(int event) { \
    int ret=0; \
    if(handlecb) ret=handlecb(this, event); \
    if(!ret) ret = name::handle(event); \
    return ret; \
  } \
  \
  void resize(int X, int Y, int W, int H){ \
    if(resizecb) resizecb(this,X,Y,W,H); \
    name::resize(X,Y,W,H); \
  } \
}; \
extern "C" { \
  name##Ex* DLL_EXPORT name##ExNew(int w, int h, char* title); \
  name##Ex* DLL_EXPORT name##ExNew2(int x, int y, int w, int h, char* title); \
  void DLL_EXPORT name##ExSetDrawCB(name##Ex*, Fl_drawEx cb); \
  void DLL_EXPORT name##ExSetHandleCB(name##Ex*, Fl_handleEx cb); \
  void DLL_EXPORT name##ExSetResizeCB(name##Ex*, Fl_resizeEx cb); \
}


#define ImplementWindow(name) \
name##Ex* DLL_EXPORT name##ExNew(int w, int h, char* title){ return new name##Ex(w,h,title); } \
name##Ex* DLL_EXPORT name##ExNew2(int x, int y, int w, int h, char* title){ return new name##Ex(x,y,w,h,title); } \
void DLL_EXPORT name##ExSetDrawCB(name##Ex* ex, Fl_drawEx cb){ ex->setDrawCB(cb); } \
void DLL_EXPORT name##ExSetHandleCB(name##Ex* ex, Fl_handleEx cb){ ex->setHandleCB(cb); } \
void DLL_EXPORT name##ExSetResizeCB(name##Ex* ex, Fl_resizeEx cb){ ex->setResizeCB(cb); }


class Fl_TableEx : public Fl_Table {
  private:
  Fl_drawEx drawcb;
  Fl_drawcellEx drawcellcb;
  Fl_handleEx handlecb;
  Fl_resizeEx resizecb;
  public:
  void setDrawCB(Fl_drawEx cb) { drawcb = cb; }
  void setDrawCellCB(Fl_drawcellEx cb) { drawcellcb = cb; }
  void setHandleCB(Fl_handleEx cb) { handlecb = cb; }
  void setResizeCB(Fl_resizeEx cb) { resizecb = cb; }
  virtual ~Fl_TableEx() {}
  Fl_TableEx(int x, int y, int w, int h, const char* title) : Fl_Table(x, y, w, h, title) {
    drawcb=0; drawcellcb=0; handlecb=0; resizecb=0;
  }
  void draw() {
    static bool flag=false;
    if(!flag) {
      if(resizecb) resizecb(this,x(),y(),w(),h());
      flag=true;
    }
    if(drawcb)
      drawcb(this);
    else
      Fl_Table::draw();
  }
  void draw_cell(TableContext context, int ROW=0, int COL=0, int X=0, int Y=0, int W=0, int H=0){
    if(drawcellcb) drawcellcb(this,context,ROW,COL,X,Y,W,H);
  }

  int handle(int event) {
    int ret=0;
    if(handlecb) ret=handlecb(this, event);
    if(!ret) ret = Fl_Table::handle(event);
    return ret;
  }

  void resize(int X, int Y, int W, int H){
    if(resizecb) resizecb(this,X,Y,W,H);
    Fl_Table::resize(X,Y,W,H);
  }
};



ExtendEx(Fl_Adjuster);

ExtendEx(Fl_Box);

ExtendEx(Fl_Button)
 ExtendEx(Fl_Radio_Button);
 ExtendEx(Fl_Repeat_Button);
 ExtendEx(Fl_Return_Button);
 ExtendEx(Fl_Toggle_Button);
 ExtendEx(Fl_Light_Button);
  ExtendEx(Fl_Check_Button);
  ExtendEx(Fl_Radio_Light_Button);
  ExtendEx(Fl_Round_Button);
  ExtendEx(Fl_Radio_Round_Button);

ExtendEx(Fl_Browser);
 ExtendEx(Fl_File_Browser);
 ExtendEx(Fl_Hold_Browser);
 ExtendEx(Fl_Multi_Browser);
 ExtendEx(Fl_Select_Browser);

ExtendEx(Fl_Chart);

ExtendEx(Fl_Clock_Output);
 ExtendEx(Fl_Clock);
 ExtendEx(Fl_Round_Clock);

ExtendEx(Fl_Dial);
 ExtendEx(Fl_Fill_Dial);
 ExtendEx(Fl_Line_Dial);
 ExtendEx(Fl_Roller);

ExtendEx(Fl_Input);
 ExtendEx(Fl_File_Input);
 ExtendEx(Fl_Float_Input);
 ExtendEx(Fl_Int_Input);
 ExtendEx(Fl_Multiline_Input);
 ExtendEx(Fl_Secret_Input);
 ExtendEx(Fl_Output);
  ExtendEx(Fl_Multiline_Output);

ExtendEx(Fl_Progress);

ExtendEx(Fl_Menu_Bar);
ExtendEx(Fl_Menu_Button);
ExtendEx(Fl_Choice);

ExtendEx(Fl_Slider);
 ExtendEx(Fl_Hor_Slider);
 ExtendEx(Fl_Fill_Slider);
  ExtendEx(Fl_Hor_Fill_Slider);
 ExtendEx(Fl_Nice_Slider);
  ExtendEx(Fl_Hor_Nice_Slider);
ExtendEx(Fl_Scrollbar);
ExtendEx(Fl_Value_Slider);
 ExtendEx(Fl_Hor_Value_Slider);

ExtendEx(Fl_Value_Input);
ExtendEx(Fl_Value_Output);
 ExtendEx(Fl_Counter);
 ExtendEx(Fl_Simple_Counter);

ExtendEx(Fl_Group);
 ExtendEx(Fl_Pack);
 ExtendEx(Fl_Scroll);
 ExtendEx(Fl_Tile);
 ExtendEx(Fl_Color_Chooser);
//ExtendEx(Fl_Help_View);
 ExtendEx(Fl_Input_Choice);
 ExtendEx(Fl_Spinner);
  ExtendEx(Fl_Table_Row);
 ExtendEx(Fl_Tabs);
 ExtendEx(Fl_Text_Display);
 ExtendEx(Fl_Text_Editor);
 ExtendEx(Fl_Tree);

 ExtendWindow(Fl_Window);
  ExtendWindow(Fl_Single_Window);
   ExtendWindow(Fl_Menu_Window);
  ExtendWindow(Fl_Double_Window);
  ExtendWindow(Fl_Gl_Window)


#ifdef __cplusplus
extern "C"
{
#endif

// utf8
int          DLL_EXPORT Fl_utf8bytes(unsigned ucs);
int          DLL_EXPORT Fl_utf8len(char c);
int          DLL_EXPORT Fl_utf8len1(char c);
int          DLL_EXPORT Fl_utf_nb_char(const unsigned char *buf, int len);
unsigned     DLL_EXPORT Fl_utf8decode(const char* p, const char* end, int* len);
int          DLL_EXPORT Fl_utf8encode(unsigned ucs, char* buf);
const char*  DLL_EXPORT Fl_utf8fwd(const char* p, const char* start, const char* end);
const char*  DLL_EXPORT Fl_utf8back(const char* p, const char* start, const char* end);
unsigned     DLL_EXPORT Fl_ucs_to_Utf16(const unsigned ucs, unsigned short *dst, const unsigned dstlen);
unsigned     DLL_EXPORT Fl_utf8toUtf16(const char* src, unsigned srclen, unsigned short* dst, unsigned dstlen);
unsigned     DLL_EXPORT Fl_utf8towc(const char *src, unsigned srclen, wchar_t *dst, unsigned dstlen);
unsigned     DLL_EXPORT Fl_utf8fromwc(char *dst, unsigned dstlen, const wchar_t *src, unsigned srclen);
unsigned     DLL_EXPORT Fl_utf8toa (const char *src, unsigned srclen, char *dst, unsigned dstlen);
unsigned     DLL_EXPORT Fl_utf8froma (char *dst, unsigned dstlen, const char *src, unsigned srclen);
int          DLL_EXPORT Fl_utf8locale();
int          DLL_EXPORT Fl_utf8test(const char *src, unsigned len);
int          DLL_EXPORT Fl_wcwidth_(unsigned int ucs);
int          DLL_EXPORT Fl_wcwidth(const char *src);
unsigned int DLL_EXPORT Fl_nonspacing(unsigned int ucs);
unsigned     DLL_EXPORT Fl_utf8to_mb(const char *src, unsigned srclen, char *dst, unsigned dstlen);
char*        DLL_EXPORT Fl_utf2mbcs(const char *src);
unsigned     DLL_EXPORT Fl_utf8from_mb(char *dst, unsigned dstlen, const char *src, unsigned srclen);
#ifdef WIN32
char*        DLL_EXPORT Fl_utf8_to_locale(const char *s, int len, unsigned int codepage);
char*        DLL_EXPORT Fl_locale_to_utf8(const char *s, int len, unsigned int codepage);
#endif
int          DLL_EXPORT Fl_utf_strncasecmp(const char *s1, const char *s2, int n);
int          DLL_EXPORT Fl_utf_strcasecmp(const char *s1, const char *s2);
int          DLL_EXPORT Fl_tolower(unsigned int ucs);
int          DLL_EXPORT Fl_toupper(unsigned int ucs);
int          DLL_EXPORT Fl_utf_tolower(const unsigned char *str, int len, char *buf);
int          DLL_EXPORT Fl_utf_toupper(const unsigned char *str, int len, char *buf);
int          DLL_EXPORT Fl_chmod(const char* f, int mode);
int          DLL_EXPORT Fl_access(const char* f, int mode);
int          DLL_EXPORT Fl_stat( const char *path, struct stat *buffer );
char*        DLL_EXPORT Fl_getcwd( char *buf, int maxlen);
FILE*        DLL_EXPORT Fl_fopen(const char *f, const char *mode);
int          DLL_EXPORT Fl_system(const char* f);
int          DLL_EXPORT Fl_execvp(const char *file, char *const *argv);
int          DLL_EXPORT Fl_open(const char* f, int o);
int          DLL_EXPORT Fl_unlink(const char *f);
int          DLL_EXPORT Fl_rmdir(const char *f);
char*        DLL_EXPORT Fl_getenv(const char *name);
int          DLL_EXPORT Fl_mkdir(const char* f, int mode);
int          DLL_EXPORT Fl_rename(const char* f, const char *t);
void         DLL_EXPORT Fl_make_path_for_file( const char *path);
char         DLL_EXPORT Fl_make_path( const char *path);

// common dialogs
void        DLL_EXPORT flAlert(const char* msg);
int         DLL_EXPORT flChoice(const char* question, const char* button1, const char* button2, const char* button3);
void        DLL_EXPORT flBeep(int t);
int         DLL_EXPORT flColorChooser(const char *name, uchar &r, uchar &g, uchar &b, int cmode);
int         DLL_EXPORT flColorChooser2(const char *name, double &r, double &g, double &b, int cmode);
char*       DLL_EXPORT flDirChooser(const char *message, const char *fname, int relative);
char*       DLL_EXPORT flFileChooser(const char *message, const char *pat, const char *fname, int relative);
void        DLL_EXPORT flFileChooserCallback(void(*cb)(const char* f));
void        DLL_EXPORT flFileChooserOkLabel(const char* l);
const char* DLL_EXPORT flInput(const char* fmt, const char* defstr);
void        DLL_EXPORT flMessage(const char* txt);
void        DLL_EXPORT flMessageSetHotspot(int enable);
int         DLL_EXPORT flMessageGetHotspot(void);
Fl_Widget*  DLL_EXPORT flMessageIcon();
void        DLL_EXPORT flMessageTitle(const char* title);
void        DLL_EXPORT flMessageTitleDefault(const char* title);
const char* DLL_EXPORT flPassword(const char* fmt, const char* defstr);


// class Fl_File_Chooser
Fl_File_Chooser* DLL_EXPORT Fl_File_ChooserNew(const char* d, const char* p, int t, const char* title);
Fl_Widget*       DLL_EXPORT Fl_File_ChooserAddExtra(Fl_File_Chooser* fc, Fl_Widget* wgt);
void             DLL_EXPORT Fl_File_ChooserCallback(Fl_File_Chooser* fc, void(*cb)(Fl_File_Chooser *, void *), void *d=0);
void             DLL_EXPORT Fl_File_ChooserSetColor(Fl_File_Chooser* fc, Fl_Color c);
Fl_Color         DLL_EXPORT Fl_File_ChooserGetColor(Fl_File_Chooser* fc);
int              DLL_EXPORT Fl_File_ChooserCount(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetDirectory(Fl_File_Chooser* fc, const char* d);
char*            DLL_EXPORT Fl_File_ChooserGetDirectory(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetFilter(Fl_File_Chooser* fc, const char* f);
const char*      DLL_EXPORT Fl_File_ChooserGetFilter(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetFilterValue(Fl_File_Chooser* fc, int f);
int              DLL_EXPORT Fl_File_ChooserGetFilterValue(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserHide(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetIconSize(Fl_File_Chooser* fc, uchar s);
uchar            DLL_EXPORT Fl_File_ChooserGetIconSize(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetLabel(Fl_File_Chooser* fc, const char* l);
const char*      DLL_EXPORT Fl_File_ChooserGetLabel(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetOkLabel(Fl_File_Chooser* fc, const char* l);
const char*      DLL_EXPORT Fl_File_ChooserGetOkLabel(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetPreview(Fl_File_Chooser* fc, int e);
int              DLL_EXPORT Fl_File_ChooserGetPreview(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserRescan(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserRescanKeepFilename(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserShow(Fl_File_Chooser* fc);
int              DLL_EXPORT Fl_File_ChooserShown(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetTextColor(Fl_File_Chooser* fc, Fl_Color c);
Fl_Color         DLL_EXPORT Fl_File_ChooserGetTextColor(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetTextFont(Fl_File_Chooser* fc, Fl_Font f);
Fl_Font          DLL_EXPORT Fl_File_ChooserGetTextFont(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetTextSize(Fl_File_Chooser* fc, Fl_Fontsize s);
Fl_Fontsize      DLL_EXPORT Fl_File_ChooserGetTextSize(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetType(Fl_File_Chooser* fc, int t);
int              DLL_EXPORT Fl_File_ChooserGetType(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetUserData(Fl_File_Chooser* fc, void* d);
void*            DLL_EXPORT Fl_File_ChooserGetUserData(Fl_File_Chooser* fc);
void             DLL_EXPORT Fl_File_ChooserSetValue(Fl_File_Chooser* fc, const char* filename);
const char*      DLL_EXPORT Fl_File_ChooserGetValue(Fl_File_Chooser* fc, int f=1);
int              DLL_EXPORT Fl_File_ChooserVisible(Fl_File_Chooser* fc);
Fl_Button*       DLL_EXPORT Fl_File_ChooserNewButton(Fl_File_Chooser* fc);
Fl_Check_Button* DLL_EXPORT Fl_File_ChooserPreviewButton(Fl_File_Chooser* fc);
Fl_Check_Button* DLL_EXPORT Fl_File_ChooserShowHiddenButton(Fl_File_Chooser* fc);

// draw
void     DLL_EXPORT DrawSetColor(Fl_Color c);
void     DLL_EXPORT DrawSetRGBColor(uchar r, uchar g, uchar b);
Fl_Color DLL_EXPORT DrawGetColor();
void     DLL_EXPORT DrawPushClip(int x, int y, int w, int h);
void     DLL_EXPORT DrawPushNoClip();
void     DLL_EXPORT DrawPopClip();
int      DLL_EXPORT DrawNotClipped(int x, int y, int w, int h);
int      DLL_EXPORT DrawClipBox(int x , int y, int w, int h, int& retx, int& rety, int& retw, int& reth);
void     DLL_EXPORT DrawRestoreClip();

void     DLL_EXPORT DrawPoint(int x, int y);

void     DLL_EXPORT DrawSetLineStyle(int style, int width=0, char* dashes=0);

void     DLL_EXPORT DrawRect(int x, int y, int w, int h);
void     DLL_EXPORT DrawRectColor(int x, int y, int w, int h,Fl_Color c);

void     DLL_EXPORT DrawRectFill(int x, int y, int w, int h);
void     DLL_EXPORT DrawRectFillColor(int x, int y, int w, int h,Fl_Color c);
void     DLL_EXPORT DrawRectFillRGBColor(int x, int y, int w, int h, uchar r, uchar g, uchar b);

void     DLL_EXPORT DrawFrame(const char* s, int x, int y, int w, int h);
void     DLL_EXPORT DrawFrame2(const char* s, int x, int y, int w, int h);
void     DLL_EXPORT DrawBox(Fl_Boxtype bt, int x, int y, int w, int h, Fl_Color c);

void     DLL_EXPORT DrawLine(int x, int y, int x1, int y1);
void     DLL_EXPORT DrawLine2(int x, int y, int x1, int y1, int x2, int y2);

void     DLL_EXPORT DrawLoop(int x, int y, int x1, int y1, int x2, int y2);
void     DLL_EXPORT DrawLoop2(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3);

void     DLL_EXPORT DrawPolygon(int x, int y, int x1, int y1, int x2, int y2);
void     DLL_EXPORT DrawPolygon2(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3);

void     DLL_EXPORT DrawXYLine(int x, int y, int x1);
void     DLL_EXPORT DrawXYLine2(int x, int y, int x1, int y1);
void     DLL_EXPORT DrawXYLine3(int x, int y, int x1, int y1, int x2);

void     DLL_EXPORT DrawYXLine(int x, int y, int y1);
void     DLL_EXPORT DrawYXLine2(int x, int y, int y1, int x2);
void     DLL_EXPORT DrawYXLine3(int x, int y, int y1, int x2, int y2);

void     DLL_EXPORT DrawArc(int x, int y, int w, int h, double a1, double a2);
void     DLL_EXPORT DrawArc2(double x, double y, double r, double start, double end);
void     DLL_EXPORT DrawCircle(double x, double y, double r);
void     DLL_EXPORT DrawCurve(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3);
void     DLL_EXPORT DrawPie(int x, int y, int w, int h, double a1, double a2);

void     DLL_EXPORT DrawPushMatrix();
void     DLL_EXPORT DrawPopMatrix();
void     DLL_EXPORT DrawMultMatrix(double a, double b, double c, double d, double x,double y);

void     DLL_EXPORT DrawScale(double s);
void     DLL_EXPORT DrawScaleXY(double sx, double sy);
void     DLL_EXPORT DrawRotate(double r);
void     DLL_EXPORT DrawTranslate(double tx, double ty);

void     DLL_EXPORT DrawBeginPoints();
void     DLL_EXPORT DrawEndPoints();
void     DLL_EXPORT DrawBeginLine();
void     DLL_EXPORT DrawEndLine();
void     DLL_EXPORT DrawBeginLoop();
void     DLL_EXPORT DrawEndLoop();
void     DLL_EXPORT DrawBeginPolygon();
void     DLL_EXPORT DrawEndPolygon();
void     DLL_EXPORT DrawBeginComplexPolygon();
void     DLL_EXPORT DrawEndComplexPolygon();
void     DLL_EXPORT DrawVertex(double x, double y);

double   DLL_EXPORT DrawTransformX(double x, double y);
double   DLL_EXPORT DrawTransformY(double x, double y);
double   DLL_EXPORT DrawTransformDX(double x, double y);
double   DLL_EXPORT DrawTransformDY(double x, double y);
void     DLL_EXPORT DrawTransformedVertex(double xf, double yf);

void     DLL_EXPORT DrawSetFont(Fl_Font face, Fl_Fontsize fsize);
Fl_Font  DLL_EXPORT DrawGetFont();
Fl_Fontsize DLL_EXPORT DrawGetFontSize();
int      DLL_EXPORT DrawGetFontHeight();
int      DLL_EXPORT DrawGetFontDescent();
int      DLL_EXPORT DrawGetStrWidth(const char* txt);
int      DLL_EXPORT DrawGetStrWidth2(const char* txt, int nchars);
int      DLL_EXPORT DrawGetCharWidth(unsigned int c);
void     DLL_EXPORT DrawStrExtents(const char* txt, int& dx, int& dy, int& w, int& h);
void     DLL_EXPORT DrawStrExtents2(const char* txt, int n, int& dx, int& dy, int& w, int& h);
void     DLL_EXPORT DrawStrMeasure(const char* txt, int& x, int& y, int draw_symbols = 1);
void     DLL_EXPORT DrawStr(const char* txt, int x, int y);
void     DLL_EXPORT DrawStr2(const char* txt, int nchars, int x, int y);
void     DLL_EXPORT DrawStrRightToLeft(const char* txt, int n, int x, int y);
void     DLL_EXPORT DrawStrRot(int angle, const char* txt, int x, int y);
void     DLL_EXPORT DrawStrRot2(int angle, const char* txt, int nchars, int x, int y);
void     DLL_EXPORT DrawStrBox(const char* str, int x, int y, int w, int h, Fl_Align align, Fl_Image* img=0, int draw_symbols = 1);

const char* DLL_EXPORT DrawLatin1ToLocal(const char* txt, int n=-1);
const char* DLL_EXPORT DrawLocalToLatin1(const char* txt, int n=-1);

void   DLL_EXPORT DrawImage(const uchar* buf, int x,int y,int w,int h, int d=3, int l=0);
void   DLL_EXPORT DrawImageMono(const uchar* buf, int x,int y,int w,int h, int d=1, int l=0);
void   DLL_EXPORT DrawImageCallback(Fl_Draw_Image_Cb cb,void *data,int x,int y,int w,int h,int d);
void   DLL_EXPORT DrawImageMonoCallback(Fl_Draw_Image_Cb cb,void *data,int x,int y,int w,int h,int d);

uchar* DLL_EXPORT DrawReadImage(uchar* p,int x,int y,int w,int h,int alpha=0);

int DLL_EXPORT DrawPixmap(char* const* data, int x,int y,Fl_Color c=FL_GRAY);
int DLL_EXPORT DrawPixmap2(const char* const* cdata, int x,int y,Fl_Color c=FL_GRAY);
int DLL_EXPORT DrawMeasurePixmap(char* const* data, int &w, int &h);
int DLL_EXPORT DrawMeasurePixmap2(const char* const* cdata, int &w, int &h);

int DLL_EXPORT DrawCanDoAlphaBlending();
#if 0
Fl_Offscreen DLL_EXPORT Fl_Create_Offscreen(int w, int h);
void DLL_EXPORT Fl_Begin_Offscreen(Fl_Offscreen o);
void DLL_EXPORT Fl_End_Offscreen(void);
void DLL_EXPORT Fl_Copy_Offscreen(int x,int y,int w,int h,Fl_Offscreen o,int srcx,int srcy);
#endif


// class FL
void           DLL_EXPORT Fl_AddCheck(Fl_Timeout_Handler h, void* data);
void           DLL_EXPORT Fl_AddHandler(Fl_Event_Handler h);
void           DLL_EXPORT Fl_AddIdle(Fl_Idle_Handler h, void* data);
void           DLL_EXPORT Fl_AddTimeout(double t, Fl_Timeout_Handler h, void* data);
void           DLL_EXPORT Fl_Awake(void *message);
int            DLL_EXPORT Fl_Awake2(Fl_Awake_Handler h, void* message);
void           DLL_EXPORT Fl_Background(uchar r, uchar g, uchar b);
void           DLL_EXPORT Fl_Background2(uchar r, uchar g, uchar b);
void           DLL_EXPORT Fl_SetBelowmouse(Fl_Widget* wgt);
Fl_Widget*     DLL_EXPORT Fl_GetBelowmouse();
int            DLL_EXPORT Fl_BoxDX(Fl_Boxtype bt);
int            DLL_EXPORT Fl_BoxDY(Fl_Boxtype bt);
int            DLL_EXPORT Fl_BoxDH(Fl_Boxtype bt);
int            DLL_EXPORT Fl_BoxDW(Fl_Boxtype bt);
int            DLL_EXPORT Fl_Check();
void           DLL_EXPORT Fl_ClearWidgetPointer(Fl_Widget const *w);
int            DLL_EXPORT Fl_Compose(int &del);
void           DLL_EXPORT Fl_Compose_Reset();
void           DLL_EXPORT Fl_Copy(const char *stuff, int len, int destination=0);
void           DLL_EXPORT Fl_SetDamage(int d);
int            DLL_EXPORT Fl_GetDamage();
void           DLL_EXPORT Fl_DefaultAtclose(Fl_Window* win, void* p);
void           DLL_EXPORT Fl_DeleteWidget(Fl_Widget* wgt);
void           DLL_EXPORT Fl_Display(const char* display);
int            DLL_EXPORT Fl_Dnd();
void           DLL_EXPORT Fl_SetDndTextOps(int v);
int            DLL_EXPORT Fl_GetDndTextOps();
void           DLL_EXPORT Fl_DoWidgetDeletion();
int            DLL_EXPORT Fl_DrawBoxActive();
void           DLL_EXPORT Fl_SetEventDispatch(Fl_Event_Dispatch d);
Fl_Event_Dispatch DLL_EXPORT Fl_GetEventDispatch();

int            DLL_EXPORT Fl_EventNumber();
int            DLL_EXPORT Fl_EventAlt();
int            DLL_EXPORT Fl_EventButton();
int            DLL_EXPORT Fl_EventButton1();
int            DLL_EXPORT Fl_EventButton2();
int            DLL_EXPORT Fl_EventButton3();
int            DLL_EXPORT Fl_EventButtons();
void           DLL_EXPORT Fl_SetEventClicks(int i);
int            DLL_EXPORT Fl_GetEventClicks();
int            DLL_EXPORT Fl_EventCommand();
int            DLL_EXPORT Fl_EventCtrl();
int            DLL_EXPORT Fl_EventX();
int            DLL_EXPORT Fl_EventY();
int            DLL_EXPORT Fl_EventXRoot();
int            DLL_EXPORT Fl_EventYRoot();
int            DLL_EXPORT Fl_EventDX();
int            DLL_EXPORT Fl_EventDY();
int            DLL_EXPORT Fl_EventInside(const Fl_Widget* wgt);
int            DLL_EXPORT Fl_EventInside2(int x, int y, int w, int h);
void           DLL_EXPORT Fl_SetEventIsClick(int i);
int            DLL_EXPORT Fl_GetEventIsClick();
int            DLL_EXPORT Fl_EventKey();
int            DLL_EXPORT Fl_EventKey2(int key);
int            DLL_EXPORT Fl_EventLength();
int            DLL_EXPORT Fl_EventOriginalKey();
int            DLL_EXPORT Fl_EventShift();
int            DLL_EXPORT Fl_EventState();
int            DLL_EXPORT Fl_EventState2(int i);
const char*    DLL_EXPORT Fl_EventText();

Fl_Window*     DLL_EXPORT Fl_GetFirstWindow();
void           DLL_EXPORT Fl_SetFirstWindow(Fl_Window* win);
void           DLL_EXPORT Fl_Flush();
Fl_Widget*     DLL_EXPORT Fl_GetFocus();
void           DLL_EXPORT Fl_SetFocus(Fl_Widget* wgt);
void           DLL_EXPORT Fl_Foreground(uchar r, uchar g, uchar b);
void           DLL_EXPORT Fl_FreeColor(Fl_Color i, int overlay=0);
int            DLL_EXPORT Fl_GetAwakeHandler_(Fl_Awake_Handler &h, void* &data);
Fl_Box_Draw_F* DLL_EXPORT Fl_GetBoxType(Fl_Boxtype bt);
void           DLL_EXPORT Fl_GetColor(Fl_Color i, uchar &r, uchar &g, uchar &b);
unsigned       DLL_EXPORT Fl_GetColor2(Fl_Color i);
const char*    DLL_EXPORT Fl_GetFont(Fl_Font f);
const char*    DLL_EXPORT Fl_GetFontName(Fl_Font f, int *attributes=0);
int            DLL_EXPORT Fl_GeFontSizes(Fl_Font f, int *&sizep);
int            DLL_EXPORT Fl_GetKey(int key);
void           DLL_EXPORT Fl_GetMouse(int &x, int &y);
void           DLL_EXPORT Fl_GetSystemColors();
void           DLL_EXPORT Fl_SetGrab(Fl_Window* win);
Fl_Window*     DLL_EXPORT Fl_GetGrab();
int            DLL_EXPORT Fl_Handle(int, Fl_Window* win);
int            DLL_EXPORT Fl_Handle_(int, Fl_Window* win);
int            DLL_EXPORT Fl_HasCheck(Fl_Timeout_Handler h, void* data=0);
int            DLL_EXPORT Fl_HasIdle(Fl_Idle_Handler h, void* data=0);
int            DLL_EXPORT Fl_HasTimeout(Fl_Timeout_Handler h, void* dtat=0);
int            DLL_EXPORT Fl_Lock();
Fl_Window*     DLL_EXPORT Fl_Modal();
Fl_Window*     DLL_EXPORT Fl_NextWindow(const Fl_Window* win);
int            DLL_EXPORT Fl_GetOption(Fl::Fl_Option opt);
void           DLL_EXPORT Fl_SetOption(Fl::Fl_Option opt, int val);
void           DLL_EXPORT Fl_OwnColormap();
void           DLL_EXPORT Fl_Paste(Fl_Widget &receiver);
void           DLL_EXPORT Fl_Paste2(Fl_Widget &receiver, int source);
Fl_Widget*     DLL_EXPORT Fl_GetPushed();
void           DLL_EXPORT Fl_SetPushed(Fl_Widget* wgt);
Fl_Widget*     DLL_EXPORT Fl_ReadQueue();
int            DLL_EXPORT Fl_Ready();
void           DLL_EXPORT Fl_Redraw();
void           DLL_EXPORT Fl_Release();
void           DLL_EXPORT Fl_ReleaseWidgetPointer(Fl_Widget* &wgt);
int            DLL_EXPORT Fl_ReloadScheme();
void           DLL_EXPORT Fl_RemoveCheck(Fl_Timeout_Handler h, void* data=0);
void           DLL_EXPORT Fl_RemoveFD(int fd);
void           DLL_EXPORT Fl_RemoveFD2(int fd, int when);
void           DLL_EXPORT Fl_RemoveHandler(Fl_Event_Handler h);
void           DLL_EXPORT Fl_RemoveIdle(Fl_Idle_Handler h, void* data=0);
void           DLL_EXPORT Fl_RemoveTimeout(Fl_Timeout_Handler h, void* datat=0);
void           DLL_EXPORT Fl_RepeatTimeout(double t, Fl_Timeout_Handler h, void* data=0);
int            DLL_EXPORT Fl_Run();
const char*    DLL_EXPORT Fl_GetScheme();
int            DLL_EXPORT Fl_SetScheme(const char* scheme);
int            DLL_EXPORT Fl_ScreenCount();
void           DLL_EXPORT Fl_ScreenDpi(float &h, float &v, int n=0);
void           DLL_EXPORT Fl_ScreenWorkAreaXYWH(int &X, int &Y, int &W, int &H);
void           DLL_EXPORT Fl_ScreenWorkAreaXYWHN(int &X, int &Y, int &W, int &H, int n);
void           DLL_EXPORT Fl_ScreenWorkAreaXYWHMXMY(int &X, int &Y, int &W, int &H, int mx, int my);
void           DLL_EXPORT Fl_ScreenXYWH(int &X, int &Y, int &W, int &H);
void           DLL_EXPORT Fl_ScreenXYWHN(int &X, int &Y, int &W, int &H, int n);
void           DLL_EXPORT Fl_ScreenXYWHMXMY(int &X, int &Y, int &W, int &H, int mx, int my);
void           DLL_EXPORT Fl_ScreenXYWHMXMYMWMH(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh);
void           DLL_EXPORT Fl_SetScrollbarSize(int size);
int            DLL_EXPORT Fl_GetScrollbarSize();
void           DLL_EXPORT Fl_Selection(Fl_Widget &owner, const char* t, int len);
void           DLL_EXPORT Fl_SetSelectionOwner(Fl_Widget* wgt);
Fl_Widget*     DLL_EXPORT Fl_GetSelectionOwner();
void           DLL_EXPORT Fl_SetAbort(Fl_Abort_Handler h);
void           DLL_EXPORT Fl_SetAtclose(Fl_Atclose_Handler h);
void           DLL_EXPORT Fl_SetBoxType(Fl_Boxtype bt, Fl_Boxtype from);
void           DLL_EXPORT Fl_SetBoxType2(Fl_Boxtype bt, Fl_Box_Draw_F* f, uchar a, uchar b, uchar c, uchar d);
void           DLL_EXPORT Fl_SetColor(Fl_Color n, unsigned c);
void           DLL_EXPORT Fl_SetColor2(Fl_Color n, uchar r, uchar g, uchar b);
void           DLL_EXPORT Fl_SetFont(Fl_Font f, const char* n);
void           DLL_EXPORT Fl_SetFont2(Fl_Font f, Fl_Font n);
Fl_Font        DLL_EXPORT Fl_SetFonts(const char* n=0);
void           DLL_EXPORT Fl_SetIdle(Fl_Old_Idle_Handler h);
void           DLL_EXPORT Fl_SetLabeltype(Fl_Labeltype lt, Fl_Label_Draw_F* df, Fl_Label_Measure_F* mf);
int            DLL_EXPORT Fl_TestShortcut(Fl_Shortcut s);
void*          DLL_EXPORT Fl_ThreadMessage();
void           DLL_EXPORT Fl_Unlock();
double         DLL_EXPORT Fl_Version();
void           DLL_EXPORT Fl_SetVisibleFocus(int v);
int            DLL_EXPORT Fl_GetVisibleFocus();
int            DLL_EXPORT Fl_Visual(int v);

int            DLL_EXPORT Fl_Wait();
double         DLL_EXPORT Fl_Wait2(double time);
void           DLL_EXPORT Fl_WatchWidgetPointer(Fl_Widget* &wgt);
int            DLL_EXPORT Fl_GetX();
int            DLL_EXPORT Fl_GetY();
int            DLL_EXPORT Fl_GetW();
int            DLL_EXPORT Fl_GetH();


// class Fl_Image
Fl_Image* DLL_EXPORT Fl_ImageNew(int w, int h, int d);
void      DLL_EXPORT Fl_ImageDelete(Fl_Image* & img);
void      DLL_EXPORT Fl_ImageColorAverage(Fl_Image* img, Fl_Color c, float i);
Fl_Image* DLL_EXPORT Fl_ImageCopy(Fl_Image* img);
Fl_Image* DLL_EXPORT Fl_ImageCopy2(Fl_Image* img, int w, int h);
int       DLL_EXPORT Fl_ImageCount(Fl_Image* img);
const char* const* DLL_EXPORT Fl_ImageData(Fl_Image* img);
void      DLL_EXPORT Fl_ImageDesaturate(Fl_Image* img);
void      DLL_EXPORT Fl_ImageDraw(Fl_Image* img, int x, int y);
void      DLL_EXPORT Fl_ImageDraw2(Fl_Image* img, int x, int y, int w, int h, int cx=0, int cy=0);
void      DLL_EXPORT Fl_ImageInactive(Fl_Image* img);
int       DLL_EXPORT Fl_ImageLD(Fl_Image* img);
void      DLL_EXPORT Fl_ImageUncache(Fl_Image* img);
int       DLL_EXPORT Fl_ImageW(Fl_Image* img);
int       DLL_EXPORT Fl_ImageH(Fl_Image* img);
int       DLL_EXPORT Fl_ImageD(Fl_Image* img);

// class Fl_Shared_Image extends Fl_Image
void DLL_EXPORT Fl_Register_Images();

Fl_Shared_Image*  DLL_EXPORT Fl_Shared_ImageGet(const char* n, int w, int h);
void              DLL_EXPORT Fl_Shared_ImageColorAverage(Fl_Shared_Image* si, Fl_Color c, float i);
Fl_Image*         DLL_EXPORT Fl_Shared_ImageCopy(Fl_Shared_Image* si);
Fl_Image*         DLL_EXPORT Fl_Shared_ImageCopy2(Fl_Shared_Image* si, int w, int h);
void              DLL_EXPORT Fl_Shared_ImageDesaturate(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageDraw(Fl_Shared_Image* si, int x, int y);
void              DLL_EXPORT Fl_Shared_ImageDraw2(Fl_Shared_Image* si, int x, int y, int w, int h, int cx, int cy);
const char*       DLL_EXPORT Fl_Shared_ImageName(Fl_Shared_Image* si);
int               DLL_EXPORT Fl_Shared_ImageRefcount(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageRelease(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageReload(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageUncache(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageAddHandler(Fl_Shared_Image* si, Fl_Shared_Handler f);
Fl_Shared_Image*  DLL_EXPORT Fl_Shared_ImageFind(Fl_Shared_Image* si, const char* n, int w, int h);
Fl_Shared_Image** DLL_EXPORT Fl_Shared_ImageImages(Fl_Shared_Image* si);
int               DLL_EXPORT Fl_Shared_ImageNumImages(Fl_Shared_Image* si);
void              DLL_EXPORT Fl_Shared_ImageRemoveHandler(Fl_Shared_Image* si, Fl_Shared_Handler f);

// class Fl_Bitmap extends Fl_Image
Fl_Bitmap* DLL_EXPORT Fl_BitmapNew(const char *bits, int w, int h);
Fl_Image*  DLL_EXPORT Fl_BitmapCopy(Fl_Bitmap* bm);
Fl_Image*  DLL_EXPORT Fl_BitmapCopy2(Fl_Bitmap* bm, int w, int h);
void       DLL_EXPORT Fl_BitmapDraw(Fl_Bitmap* bm, int x, int y);
void       DLL_EXPORT Fl_BitmapDraw2(Fl_Bitmap* bm, int x, int y, int w, int h, int cx=0, int cy=0);
void       DLL_EXPORT Fl_BitmapUncache(Fl_Bitmap* bm);
// class Fl_XBM_Image extends Fl_Bitmap
Fl_XBM_Image* DLL_EXPORT Fl_XBM_ImageNew(const char *filename);

// class Fl_Pixmap extends Fl_Image
Fl_Pixmap* DLL_EXPORT Fl_PixmapNew(const uchar *const * xpm_data);
void       DLL_EXPORT Fl_PixmapColorAverage(Fl_Pixmap* pm, Fl_Color c, float i);
Fl_Image*  DLL_EXPORT Fl_PixmapCopy(Fl_Pixmap* pm);
Fl_Image*  DLL_EXPORT Fl_PixmapCopy2(Fl_Pixmap* pm, int w, int h);
void       DLL_EXPORT Fl_PixmapDesaturate(Fl_Pixmap* pm);
void       DLL_EXPORT Fl_PixmapDraw(Fl_Pixmap* pm, int x, int y);
void       DLL_EXPORT Fl_PixmapDraw2(Fl_Pixmap* pm, int x, int y, int w, int h, int cx=0, int cy=0);
void       DLL_EXPORT Fl_PixmapUncache(Fl_Pixmap* pm);
// class Fl_GIF_Image extends Fl_Pixmap
Fl_GIF_Image* DLL_EXPORT Fl_GIF_ImageNew(const char *filename);
// class Fl_XPM_Image extends Fl_Pixmap
Fl_XPM_Image* DLL_EXPORT Fl_XPM_ImageNew(const char *filename);

// class Fl_RGB_Image extends Fl_Image
Fl_RGB_Image* DLL_EXPORT Fl_RGB_ImageNew(const uchar *bits, int W, int H, int D=3, int LD=0);
void          DLL_EXPORT Fl_RGB_ImageColorAverage(Fl_RGB_Image* rgbimg, Fl_Color c, float i);
Fl_Image*     DLL_EXPORT Fl_RGB_ImageCopy(Fl_RGB_Image* rgbimg);
Fl_Image*     DLL_EXPORT Fl_RGB_ImageCopy2(Fl_RGB_Image* rgbimg, int w, int h);
void          DLL_EXPORT Fl_RGB_ImageDesaturate(Fl_RGB_Image* rgbimg);
void          DLL_EXPORT Fl_RGB_ImageDraw(Fl_RGB_Image* rgbimg, int x, int y);
void          DLL_EXPORT Fl_RGB_ImageDraw2(Fl_RGB_Image* rgbimg, int x, int y, int w, int h, int cx=0, int cy=0);
void          DLL_EXPORT Fl_RGB_ImageUncache(Fl_RGB_Image* rgbimg);
// class Fl_BMP_Image extends Fl_RGB_Image
Fl_BMP_Image* DLL_EXPORT Fl_BMP_ImageNew(const char *filename);
// class Fl_PNG_Image extends Fl_RGB_Image
Fl_PNG_Image* DLL_EXPORT Fl_PNG_ImageNew(const char *filename);
Fl_PNG_Image* DLL_EXPORT Fl_PNG_ImageMem(const char *name_png, const unsigned char *buffer, int datasize);

// class Fl_JPEG_Image extends Fl_RGB_Image
Fl_JPEG_Image* DLL_EXPORT Fl_JPEG_ImageNew(const char *filename);
Fl_JPEG_Image* DLL_EXPORT Fl_JPEG_ImageMem(const char *name_jpeg, const unsigned char *buffer);

// class FlPNM_Image extends Fl_RGB_Image
Fl_PNM_Image* DLL_EXPORT Fl_PNM_ImageNew(const char *filename);

// class Fl_Tiled_Image extends Fl_Image
Fl_Tiled_Image* DLL_EXPORT Fl_Tiled_ImageNew(Fl_Image *img, int w=0, int h=0);
void            DLL_EXPORT Fl_Tiled_ImageColorAverage(Fl_Tiled_Image* timg, Fl_Color c, float i);
Fl_Image*       DLL_EXPORT Fl_Tiled_ImageCopy(Fl_Tiled_Image* timg);
Fl_Image*       DLL_EXPORT Fl_Tiled_ImageCopy2(Fl_Tiled_Image* timg, int w, int h);
void            DLL_EXPORT Fl_Tiled_ImageDesaturate(Fl_Tiled_Image* timg);
void            DLL_EXPORT Fl_Tiled_ImageDraw(Fl_Tiled_Image* timg, int x, int y);
void            DLL_EXPORT Fl_Tiled_ImageDraw2(Fl_Tiled_Image* timg, int x, int y, int w, int h, int cx=0, int cy=0);
Fl_Image*       DLL_EXPORT Fl_Tiled_ImageImage(Fl_Tiled_Image* timg);

// FL_Widget base class of all other FLTK widgets
void           DLL_EXPORT Fl_WidgetActivate(Fl_Widget* wgt);
unsigned int   DLL_EXPORT Fl_WidgetActive(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetActiveR(Fl_Widget* wgt);

void           DLL_EXPORT Fl_WidgetSetAlign(Fl_Widget* wgt, Fl_Align alignment);
Fl_Align       DLL_EXPORT Fl_WidgetGetAlign(Fl_Widget* wgt);

void           DLL_EXPORT Fl_WidgetSetArgument(Fl_Widget* wgt, long v);
long           DLL_EXPORT Fl_WidgetGetArgument(Fl_Widget* wgt);

Fl_Gl_Window*  DLL_EXPORT Fl_WidgetAsGl_Window(Fl_Widget* wgt);
Fl_Group*      DLL_EXPORT Fl_WidgetAsGroup(Fl_Widget* wgt);
Fl_Window*     DLL_EXPORT Fl_WidgetAsWindow(Fl_Widget* wgt);

void           DLL_EXPORT Fl_WidgetSetBox(Fl_Widget* wgt, Fl_Boxtype new_box);
Fl_Boxtype     DLL_EXPORT Fl_WidgetGetBox(Fl_Widget* wgt);

void           DLL_EXPORT Fl_WidgetSetCallback(Fl_Widget* wgt, Fl_Callback *cb);
void           DLL_EXPORT Fl_WidgetSetCallbackArg(Fl_Widget* wgt, Fl_Callback *cb, void *pdata);
void           DLL_EXPORT Fl_WidgetSetCallback0(Fl_Widget* wgt, Fl_Callback0 *cb);
void           DLL_EXPORT Fl_WidgetSetCallback1Arg(Fl_Widget* wgt, Fl_Callback1 *cb, long ldata=0);
Fl_Callback_p  DLL_EXPORT Fl_WidgetGetCallback(Fl_Widget* wgt);

unsigned int   DLL_EXPORT Fl_WidgetChanged(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetClearChanged(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetClearDamage(Fl_Widget* wgt, uchar c=0);
void           DLL_EXPORT Fl_WidgetClearOutput(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetClearVisible(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetClearVisibleFocus(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetColor(Fl_Widget* wgt, Fl_Color bg);
void           DLL_EXPORT Fl_WidgetSetColorSel(Fl_Widget* wgt, Fl_Color bg, Fl_Color sel);
Fl_Color       DLL_EXPORT Fl_WidgetGetColor(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetColor2(Fl_Widget* wgt, unsigned a);
Fl_Color       DLL_EXPORT Fl_WidgetGetColor2(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetContains(Fl_Widget* wgt, const Fl_Widget* other);
void           DLL_EXPORT Fl_WidgetCopyLabel(Fl_Widget* wgt, const char* new_label);
void           DLL_EXPORT Fl_WidgetCopyTooltip(Fl_Widget* wgt, const char *text);
uchar          DLL_EXPORT Fl_WidgetGetDamage(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetDamage(Fl_Widget* wgt, uchar c);
void           DLL_EXPORT Fl_WidgetSetDamage2(Fl_Widget* wgt, uchar c, int x, int y, int w, int h);
int            DLL_EXPORT Fl_WidgetDamageResize(Fl_Widget* wgt, int x, int y, int w, int h);
void           DLL_EXPORT Fl_WidgetDeactivate(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetDeimage(Fl_Widget* wgt, Fl_Image* img);
Fl_Image*      DLL_EXPORT Fl_WidgetGetDeimage(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetDoCallback(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetDoCallback2(Fl_Widget* wgt, Fl_Widget *o, void* parg=0);
void           DLL_EXPORT Fl_WidgetDoCallback3(Fl_Widget* wgt, Fl_Widget *o, long larg);
void           DLL_EXPORT Fl_WidgetDraw(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetDrawLabel(Fl_Widget* wgt, int x, int y, int w, int h, Fl_Align align);
int            DLL_EXPORT Fl_WidgetHandle(Fl_Widget* wgt, int event);
void           DLL_EXPORT Fl_WidgetHide(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetImage(Fl_Widget* wgt, Fl_Image* img);
Fl_Image*      DLL_EXPORT Fl_WidgetGetImage(Fl_Widget* wgt);
const Fl_Image* DLL_EXPORT Fl_WidgetGetImage2(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetInside(Fl_Widget* wgt, const Fl_Widget* other);
const char*    DLL_EXPORT Fl_WidgetGetLabel(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetLabel(Fl_Widget* wgt, const char* text);
void           DLL_EXPORT Fl_WidgetSetLabel2(Fl_Widget* wgt, Fl_Labeltype a, const char* text);
void           DLL_EXPORT Fl_WidgetSetLabelColor(Fl_Widget* wgt, Fl_Color c);
Fl_Color       DLL_EXPORT Fl_WidgetGetLabelColor(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetLabelFont(Fl_Widget* wgt, Fl_Font f);
Fl_Font        DLL_EXPORT Fl_WidgetGetLabelFont(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetLabelSize(Fl_Widget* wgt, Fl_Fontsize pix);
Fl_Fontsize    DLL_EXPORT Fl_WidgetGetLabelSize(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetLabelType(Fl_Widget* wgt, Fl_Labeltype a);
Fl_Labeltype   DLL_EXPORT Fl_WidgetGetLabelType(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetMeasureLabel(Fl_Widget* wgt,int &ww, int &hh);
unsigned int   DLL_EXPORT Fl_WidgetOutput(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetParent(Fl_Widget* wgt, Fl_Group* p);
Fl_Group*      DLL_EXPORT Fl_WidgetGetParent(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetPosition(Fl_Widget* wgt, int X, int Y);
void           DLL_EXPORT Fl_WidgetRedraw(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetRedrawLabel(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetResize(Fl_Widget* wgt, int x, int y, int w, int h);
void           DLL_EXPORT Fl_WidgetSetSelectionColor(Fl_Widget* wgt, Fl_Color a);
Fl_Color       DLL_EXPORT Fl_WidgetGetSelectionColor(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetChanged(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetOutput(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetVisible(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetVisibleFocus(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetShow(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSize(Fl_Widget* wgt, int W, int H);
int            DLL_EXPORT Fl_WidgetTakeFocus(Fl_Widget* wgt);
unsigned int   DLL_EXPORT Fl_WidgetTakesEvents(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetTestShortcut(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetTooltip(Fl_Widget* wgt, const char* text);
const char*    DLL_EXPORT Fl_WidgetGetTooltip(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetType(Fl_Widget* wgt, uchar t);
uchar          DLL_EXPORT Fl_WidgetGetType(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetSetUserData(Fl_Widget* wgt, void* v);
void*          DLL_EXPORT Fl_WidgetGetUserData(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetVisible(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetVisibleFocus(Fl_Widget* wgt, int v);
int            DLL_EXPORT Fl_WidgetGetVisibleFocus(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetVisibleR(Fl_Widget* wgt);

void           DLL_EXPORT Fl_WidgetSetWhen(Fl_Widget* wgt, Fl_When w);
Fl_When        DLL_EXPORT Fl_WidgetGetWhen(Fl_Widget* wgt);
Fl_Window*     DLL_EXPORT Fl_WidgetWindow(Fl_Widget* wgt);
void           DLL_EXPORT Fl_WidgetDefaultCallback(Fl_Widget* wgt, Fl_Widget* cb, void* d);
unsigned int   DLL_EXPORT Fl_WidgetLabelShortcut(Fl_Widget* wgt, const char* t);
int            DLL_EXPORT Fl_WidgetTestShortcut2(Fl_Widget* wgt, const char* t, int require_alt=0);

int            DLL_EXPORT Fl_WidgetGetX(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetGetY(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetGetH(Fl_Widget* wgt);
int            DLL_EXPORT Fl_WidgetGetW(Fl_Widget* wgt);

// class Fl_Box extends Fl_Widget
Fl_Box* DLL_EXPORT Fl_BoxNew(int X, int Y, int W, int H, const char* label=0);
Fl_Box* DLL_EXPORT Fl_BoxNew2(Fl_Boxtype b, int X, int Y, int W, int H, const char* label);

// class FL_Button extends Fl_Widget
Fl_Button* DLL_EXPORT Fl_ButtonNew(int X, int Y, int W, int H, const char* label=0);
int        DLL_EXPORT Fl_ButtonClear(Fl_Button* btn);
void       DLL_EXPORT Fl_ButtonSetDownBox(Fl_Button* btn, Fl_Boxtype bt);
Fl_Boxtype DLL_EXPORT Fl_ButtonGetDownBox(Fl_Button* btn);
void       DLL_EXPORT Fl_ButtonSetDownColor(Fl_Button* btn, Fl_Color c);
Fl_Color   DLL_EXPORT Fl_ButtonGetDownColor(Fl_Button* btn);
int        DLL_EXPORT Fl_ButtonHandle(Fl_Button* btn, int ev);
int        DLL_EXPORT Fl_ButtonSet(Fl_Button* btn);
void       DLL_EXPORT Fl_ButtonSetOnly(Fl_Button* btn);
void       DLL_EXPORT Fl_ButtonSetShortcut(Fl_Button* btn, int s);
int        DLL_EXPORT Fl_ButtonGetShortcut(Fl_Button* btn);
int        DLL_EXPORT Fl_ButtonSetValue(Fl_Button* btn, int v);
int        DLL_EXPORT Fl_ButtonGetValue(Fl_Button* btn);

// class Fl_Radio_Button extends Fl_button
Fl_Radio_Button* DLL_EXPORT Fl_Radio_ButtonNew(int X, int Y, int W, int H, const char* label=0);

// class Fl_Repeat_Button extends Fl_button
Fl_Repeat_Button* DLL_EXPORT Fl_Repeat_ButtonNew(int X, int Y, int W, int H, const char* label=0);
int DLL_EXPORT Fl_Repeat_ButtonHandle(Fl_Repeat_Button* btn, int ev);
void DLL_EXPORT Fl_Repeat_ButtonDeactivate(Fl_Repeat_Button* btn);

// class Fl_Return_Button extends Fl_button
Fl_Return_Button* DLL_EXPORT Fl_Return_ButtonNew(int X, int Y, int W, int H, const char* label=0);
int DLL_EXPORT Fl_Return_ButtonHandle(Fl_Return_Button* btn, int ev);

// class Fl_Toggle_Button extends Fl_button
Fl_Toggle_Button* DLL_EXPORT Fl_Toggle_ButtonNew(int X, int Y, int W, int H, const char* label=0);

// class Fl_Light_Button extends Fl_button
Fl_Light_Button* DLL_EXPORT Fl_Light_ButtonNew(int X, int Y, int W, int H, const char* label=0);
int DLL_EXPORT Fl_Light_ButtonHandle(Fl_Light_Button* btn, int ev);

// class Fl_Check_Button extends Fl_Light_Button
Fl_Check_Button* DLL_EXPORT Fl_Check_ButtonNew(int X, int Y, int W, int H, const char* label=0);

// class Fl_Radio_Light_Button extends Fl_Light_Button
Fl_Radio_Light_Button* DLL_EXPORT Fl_Radio_Light_ButtonNew(int X, int Y, int W, int H, const char* label);

// class Fl_Round_Button extends Fl_Light_Button
Fl_Round_Button* DLL_EXPORT Fl_Round_ButtonNew(int X, int Y, int W, int H, const char* label=0);

// class Fl_Radio_Round_Button extends Fl_Round_Button
Fl_Radio_Round_Button* DLL_EXPORT Fl_Radio_Round_ButtonNew(int X, int Y, int W, int H, const char* label=0);

// class Fl_Clock_Output extends Fl_Widget
Fl_Clock_Output* DLL_EXPORT Fl_Clock_OutputNew(int x, int y, int w, int h, const char *label=0);
int              DLL_EXPORT Fl_Clock_OutputHour(Fl_Clock_Output* co);
int	             DLL_EXPORT Fl_Clock_OutputMinute(Fl_Clock_Output* co);
int              DLL_EXPORT Fl_Clock_OutputSecond(Fl_Clock_Output* co);
void             DLL_EXPORT Fl_Clock_OutputValue(Fl_Clock_Output* co, int H, int m, int s);
void             DLL_EXPORT Fl_Clock_OutputSetValue(Fl_Clock_Output* co, ulong v);
ulong            DLL_EXPORT Fl_Clock_OutputGetValue(Fl_Clock_Output* co);

// class Fl_Clock extends Fl_Clock_Output
Fl_Clock* DLL_EXPORT Fl_ClockNew(int x, int y, int w, int h, const char *label=0);
Fl_Clock* DLL_EXPORT Fl_ClockNew2(uchar t, int x, int y, int w, int h, const char *label=0);

// class Fl_Round_Clock extends Fl_Clock
Fl_Round_Clock* DLL_EXPORT Fl_Round_ClockNew(int x, int y, int w, int h, const char *label=0);

// class Fl_Chart extends Fl_Widget
Fl_Chart*   DLL_EXPORT Fl_ChartNew(int x, int y, int w, int h, const char *label=0);
void        DLL_EXPORT Fl_ChartAdd(Fl_Chart* ch, double val, const char *str=0, unsigned col=0);
void        DLL_EXPORT Fl_ChartSetAutoSize(Fl_Chart* ch, int n);
int         DLL_EXPORT Fl_ChartGetAutoSize(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartSetBounds(Fl_Chart* ch, double a, double b);
void        DLL_EXPORT Fl_ChartGetBounds(Fl_Chart* ch, double *a, double *b);
void        DLL_EXPORT Fl_ChartClear(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartInsert(Fl_Chart* ch, int ind, double val, const char *str=0, unsigned col=0);
void        DLL_EXPORT Fl_ChartSetMaxSize(Fl_Chart* ch, int m);
int         DLL_EXPORT Fl_ChartGetMaxSize(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartReplace(Fl_Chart* ch, int ind, double val, const char *str=0, unsigned col=0);
void        DLL_EXPORT Fl_ChartSetSize(Fl_Chart* ch, int w, int h);
int         DLL_EXPORT Fl_ChartGetSize(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartSetTextColor(Fl_Chart* ch, Fl_Color c);
Fl_Color    DLL_EXPORT Fl_ChartGetTextColor(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartSetTextFont(Fl_Chart* ch, Fl_Font f);
Fl_Font     DLL_EXPORT Fl_ChartGetTextFont(Fl_Chart* ch);
void        DLL_EXPORT Fl_ChartSetTextSize(Fl_Chart* ch, Fl_Fontsize fs);
Fl_Fontsize DLL_EXPORT Fl_ChartGetTextSize(Fl_Chart* ch);

// class Fl_Input_ extends Fl_Widget
int         DLL_EXPORT Fl_Input_Copy(Fl_Input_* ip, int clipboard);
int         DLL_EXPORT Fl_Input_CopyCuts(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetCursorColor(Fl_Input_* ip, Fl_Color c);
Fl_Color    DLL_EXPORT Fl_Input_GetCursorColor(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_Cut(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_Cut1(Fl_Input_* ip, int n);
int         DLL_EXPORT Fl_Input_Cut2(Fl_Input_* ip, int a, int b);
Fl_Char     DLL_EXPORT Fl_Input_Index(Fl_Input_* ip, int i);
void        DLL_EXPORT Fl_Input_SetInputType(Fl_Input_* ip, int t);
int         DLL_EXPORT Fl_Input_GetInputType(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_Insert(Fl_Input_* ip, const char* txt, int l=0);
int         DLL_EXPORT Fl_Input_SetMark(Fl_Input_* ip, int m);
int         DLL_EXPORT Fl_Input_GetMark(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetMaximumSize(Fl_Input_* ip, int m);
int         DLL_EXPORT Fl_Input_GetMaximumSize(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_SetPosition(Fl_Input_* ip, int p);
int         DLL_EXPORT Fl_Input_SetPosition2(Fl_Input_* ip, int p, int m);
int         DLL_EXPORT Fl_Input_GetPosition(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetReadonly(Fl_Input_* ip, int b);
int         DLL_EXPORT Fl_Input_GetReadonly(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_Replace(Fl_Input_* ip, int b, int e, const char* text, int ilen=0);
void        DLL_EXPORT Fl_Input_Resize(Fl_Input_* ip, int x, int y, int w, int h);
void        DLL_EXPORT Fl_Input_SetShortcut(Fl_Input_* ip, int s);
int         DLL_EXPORT Fl_Input_GetShortcut(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetSize(Fl_Input_* ip, int w, int h);
int         DLL_EXPORT Fl_Input_GetSize(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_StaticValue(Fl_Input_* ip, const char* text);
int         DLL_EXPORT Fl_Input_StaticValue2(Fl_Input_* ip, const char* text, int l);
void        DLL_EXPORT Fl_Input_SetTabNav(Fl_Input_* ip, int val);
int         DLL_EXPORT Fl_Input_GetTabNav(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetTextColor(Fl_Input_* ip, Fl_Color c);
Fl_Color    DLL_EXPORT Fl_Input_GetTextColor(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetTextFont(Fl_Input_* ip, Fl_Font s);
Fl_Font     DLL_EXPORT Fl_Input_GetTextFont(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetTextSize(Fl_Input_* ip, Fl_Fontsize s);
Fl_Fontsize DLL_EXPORT Fl_Input_GetTextSize(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_Undo(Fl_Input_* ip);
int         DLL_EXPORT Fl_Input_SetValue(Fl_Input_* ip, const char* text);
int         DLL_EXPORT Fl_Input_SetValue2(Fl_Input_* ip, const char* text, int l);
const char* DLL_EXPORT Fl_Input_GetValue(Fl_Input_* ip);
void        DLL_EXPORT Fl_Input_SetWrap(Fl_Input_* ip, int b);
int         DLL_EXPORT Fl_Input_GetWrap(Fl_Input_* ip);

// Fl_Input extends Fl_Input_
Fl_Input*   DLL_EXPORT Fl_InputNew(int x, int y, int w, int h, const char *label=0);
int         DLL_EXPORT Fl_InputHandle(Fl_Input* ip, int event);

// Fl_File_Input extends Fl_Input
Fl_File_Input* DLL_EXPORT Fl_File_InputNew(int x, int y, int w, int h, const char* label=0);
void           DLL_EXPORT Fl_File_InputSetDownBox(Fl_File_Input* fi, Fl_Boxtype b);
Fl_Boxtype     DLL_EXPORT Fl_File_InputGetDownBox(Fl_File_Input* fi);
void           DLL_EXPORT Fl_File_InputSetErrorColor(Fl_File_Input* fi, Fl_Color c);
Fl_Color       DLL_EXPORT Fl_File_InputGetErrorColor(Fl_File_Input* fi);
int            DLL_EXPORT Fl_File_InputHandle(Fl_File_Input* fi, int event);
int            DLL_EXPORT Fl_File_InputSetValue(Fl_File_Input* fi, const char *str);
int            DLL_EXPORT Fl_File_InputSetValue2(Fl_File_Input* fi, const char *str, int l);
const char*    DLL_EXPORT Fl_File_InputGetValue(Fl_File_Input* fi);

// Fl_Float_Input extends Fl_Input
Fl_Float_Input* DLL_EXPORT Fl_Float_InputNew(int x, int y, int w, int h, const char* label=0);

// Fl_Int_Input extends Fl_Input
Fl_Int_Input* DLL_EXPORT Fl_Int_InputNew(int x, int y, int w, int h, const char* label=0);

// Fl_Multiline_Input extends Fl_Input
Fl_Multiline_Input* DLL_EXPORT Fl_Multiline_InputNew(int x, int y, int w, int h, const char* label=0);

// Fl_Output extends Fl_Input
Fl_Output* DLL_EXPORT Fl_OutputNew(int x, int y, int w, int h, const char* label=0);

// Fl_Multiline_Output extends Fl_Output
Fl_Multiline_Output* DLL_EXPORT Fl_Multiline_OutputNew(int x, int y, int w, int h, const char* label=0);

// Fl_Secret_Input extends Fl_Input
Fl_Secret_Input* DLL_EXPORT Fl_Secret_InputNew(int x, int y, int w, int h, const char* label=0);
int              DLL_EXPORT Fl_Secret_InputHandle(Fl_Secret_Input* si, int event);

// struct Fl_Menu_Item
void                DLL_EXPORT Fl_Menu_ItemActivate(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemActive(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemActiveVisible(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemAdd(Fl_Menu_Item* it, const char* label, int shortcut        , Fl_Callback* cb, void* userdata=0, int flag=0);
int                 DLL_EXPORT Fl_Menu_ItemAdd2(Fl_Menu_Item* it, const char* label, const char* shortcut, Fl_Callback* cb, void* userdata=0, int flag=0);
void                DLL_EXPORT Fl_Menu_ItemSetArgument(Fl_Menu_Item* it, long v);
long                DLL_EXPORT Fl_Menu_ItemGetArgument(Fl_Menu_Item* it);
Fl_Callback_p       DLL_EXPORT Fl_Menu_ItemGetCallback_p(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemCallback(Fl_Menu_Item* it, Fl_Callback *cb);
void                DLL_EXPORT Fl_Menu_ItemCallback2(Fl_Menu_Item* it, Fl_Callback *cb, void* pData=0);
void                DLL_EXPORT Fl_Menu_ItemCallback0(Fl_Menu_Item* it, Fl_Callback0 *cb);
void                DLL_EXPORT Fl_Menu_ItemCallback1(Fl_Menu_Item* it, Fl_Callback1 *cb, long lData=0);
void                DLL_EXPORT Fl_Menu_ItemCheck(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemCheckBox(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemChecked(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemClear(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemDeactivate(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemDoCallback(Fl_Menu_Item* it, Fl_Widget *o, void* arg);
void                DLL_EXPORT Fl_Menu_ItemDoCallback2(Fl_Menu_Item* it, Fl_Widget *o, long arg);
void                DLL_EXPORT Fl_Menu_ItemDoCallback3(Fl_Menu_Item* it, Fl_Widget *o);
void                DLL_EXPORT Fl_Menu_ItemDraw(Fl_Menu_Item* it, int x, int y, int w, int h, const Fl_Menu_ *, int t=0);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemFindShortcut(Fl_Menu_Item* it, int* ip=0, const int require_alt=0);
Fl_Menu_Item*       DLL_EXPORT Fl_Menu_ItemFirst(Fl_Menu_Item* it);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemFirst2(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemHide(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemInsert(Fl_Menu_Item* it, int index, const char* label, int shortcut, Fl_Callback* cb, void* userdata=0, int flag=0);
void                DLL_EXPORT Fl_Menu_ItemSetLabel(Fl_Menu_Item* it, const char* label);
void                DLL_EXPORT Fl_Menu_ItemSetLabel2(Fl_Menu_Item* it, Fl_Labeltype a, const char* label);
const char*         DLL_EXPORT Fl_Menu_ItemGetLabel(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetLabelColor(Fl_Menu_Item* it, Fl_Color a);
Fl_Color            DLL_EXPORT Fl_Menu_ItemGetLabelColor(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetLabelFont(Fl_Menu_Item* it,Fl_Font f);
Fl_Font             DLL_EXPORT Fl_Menu_ItemGetLabelFont(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetLabelSize(Fl_Menu_Item* it, Fl_Fontsize s);
Fl_Fontsize         DLL_EXPORT Fl_Menu_ItemGetLabelSize(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetLabelType(Fl_Menu_Item* it, Fl_Labeltype t);
Fl_Labeltype        DLL_EXPORT Fl_Menu_ItemGetLabelType(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemMeasure(Fl_Menu_Item* it, int *h, const Fl_Menu_* m);
Fl_Menu_Item*       DLL_EXPORT Fl_Menu_ItemNext(Fl_Menu_Item* it, int i=1);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemNext2(Fl_Menu_Item* it, int=1);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemPopup(Fl_Menu_Item* it, int x, int y, const char *title=0, const Fl_Menu_Item *picked=0, const Fl_Menu_* m=0);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemPulldown(Fl_Menu_Item* it, int x, int y, int w, int h, const Fl_Menu_Item *picked=0, const Fl_Menu_* m=0, const Fl_Menu_Item *title=0, int menubar=0);
int                 DLL_EXPORT Fl_Menu_ItemRadio(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSet(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetonly(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetShortcut(Fl_Menu_Item* it, int s);
int                 DLL_EXPORT Fl_Menu_ItemGetShortcut(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemShow(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemSize(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemSubmenu(Fl_Menu_Item* it);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemTestShortcut(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemUncheck(Fl_Menu_Item* it);
void                DLL_EXPORT Fl_Menu_ItemSetUserData(Fl_Menu_Item* it, void* v);
void*               DLL_EXPORT Fl_Menu_ItemGetUserData(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemValue(Fl_Menu_Item* it);
int                 DLL_EXPORT Fl_Menu_ItemVisible(Fl_Menu_Item* it);

// class Fl_Menu_ extends Fl_Widget
int                 DLL_EXPORT Fl_Menu_Add(Fl_Menu_* m_, const char* label, int shortcut, Fl_Callback* cb, void* userdata=0, int flag=0);
int                 DLL_EXPORT Fl_Menu_Add2(Fl_Menu_* m_, const char* label, const char *shortcut, Fl_Callback* cb, void* userdata=0, int flag=0);
int                 DLL_EXPORT Fl_Menu_Add3(Fl_Menu_* m_, const char* label);
void                DLL_EXPORT Fl_Menu_Clear(Fl_Menu_* m_);
int                 DLL_EXPORT Fl_Menu_ClearSubmenu(Fl_Menu_* m_, int index);
void                DLL_EXPORT Fl_Menu_Copy(Fl_Menu_* m_, const Fl_Menu_Item* item, void* userdata=0);
void                DLL_EXPORT Fl_Menu_SetDownBox(Fl_Menu_* m_, Fl_Boxtype b);
Fl_Boxtype          DLL_EXPORT Fl_Menu_GetDownBox(Fl_Menu_* m_);
void                DLL_EXPORT Fl_Menu_SetDownColor(Fl_Menu_* m_, Fl_Color c);
Fl_Color            DLL_EXPORT Fl_Menu_GetDownColor(Fl_Menu_* m_);
int                 DLL_EXPORT Fl_Menu_FindIndexByName(Fl_Menu_* m_, const char* name);
int                 DLL_EXPORT Fl_Menu_FindIndexByItem(Fl_Menu_* m_, const Fl_Menu_Item* item);
int                 DLL_EXPORT Fl_Menu_FindIndexByCallback(Fl_Menu_* m_, Fl_Callback *cb);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_FindItemByName(Fl_Menu_* m_, const char* name);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_FindItemByCallback(Fl_Menu_* m_, Fl_Callback* cb);
void                DLL_EXPORT Fl_Menu_Global(Fl_Menu_* m_);
int                 DLL_EXPORT Fl_Menu_Insert(Fl_Menu_* m_, int index, const char* label, const char* shortcut, Fl_Callback* cb, void* userdata=0, int flag=0);
int                 DLL_EXPORT Fl_Menu_Insert2(Fl_Menu_* m_, int index, const char* label, int shortcut        , Fl_Callback* cb, void* userdata=0, int flag=0);
int                 DLL_EXPORT Fl_Menu_ItemPathName(Fl_Menu_* m_, char* name, int namelen, const Fl_Menu_Item* finditem=0);
void                DLL_EXPORT Fl_Menu_SetMenu(Fl_Menu_* m_, const Fl_Menu_Item* m);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_GetMenu(Fl_Menu_* m_);
void                DLL_EXPORT Fl_Menu_SetMode(Fl_Menu_* m_, int index, int flag);
int                 DLL_EXPORT Fl_Menu_GetMode(Fl_Menu_* m_, int index);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_MValue(Fl_Menu_* m_);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_Picked(Fl_Menu_* m_, const Fl_Menu_Item* m);
void                DLL_EXPORT Fl_Menu_Remove(Fl_Menu_* m_, int index);
void                DLL_EXPORT Fl_Menu_Replace(Fl_Menu_* m_, int index, const char* label);
void                DLL_EXPORT Fl_Menu_Shortcut(Fl_Menu_* m_, int index, int shortcut);
int                 DLL_EXPORT Fl_Menu_GetSize(Fl_Menu_* m_);
void                DLL_EXPORT Fl_Menu_SetSize(Fl_Menu_* m_, int w, int h);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_TestShortcut(Fl_Menu_* m_);
const char*         DLL_EXPORT Fl_Menu_Text(Fl_Menu_* m_);
const char*         DLL_EXPORT Fl_Menu_TextByIndex(Fl_Menu_* m_, int index);
void                DLL_EXPORT Fl_Menu_SetTextColor(Fl_Menu_* m_, Fl_Color c);
Fl_Color            DLL_EXPORT Fl_Menu_GetTextColor(Fl_Menu_* m_);
void                DLL_EXPORT Fl_Menu_SetTextFont(Fl_Menu_* m_, Fl_Font f);
Fl_Font             DLL_EXPORT Fl_Menu_GetTextFont(Fl_Menu_* m_);
void                DLL_EXPORT Fl_Menu_SetTextSize(Fl_Menu_* m_, Fl_Fontsize c);
Fl_Fontsize         DLL_EXPORT Fl_Menu_GetTextSize(Fl_Menu_* m_);
int                 DLL_EXPORT Fl_Menu_Value(Fl_Menu_* m_);
int                 DLL_EXPORT Fl_Menu_ValueByItem(Fl_Menu_* m_, const Fl_Menu_Item* m);
int                 DLL_EXPORT Fl_Menu_ValueByIndex(Fl_Menu_* m_, int index);

// class Fl_Menu_Bar extends Fl_Menu_
Fl_Menu_Bar* DLL_EXPORT Fl_Menu_BarNew(int x, int y, int w, int h, const char* label=0);
int	         DLL_EXPORT Fl_Menu_BarHandle(Fl_Menu_Bar* mb, int event);

// class Fl_Menu_Button extends Fl_Menu_
Fl_Menu_Button*     DLL_EXPORT Fl_Menu_ButtonNew(int x, int y, int w, int h, const char* label=0);
int	                DLL_EXPORT Fl_Menu_ButtonHandle(Fl_Menu_Button* mb, int event);
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ButtonPopup(Fl_Menu_Button* mb);

// class Fl_Choice extends Fl_Menu_
Fl_Choice* DLL_EXPORT Fl_ChoiceNew(int x, int y, int w, int h, const char* label=0);
int        DLL_EXPORT Fl_ChoiceHandle(Fl_Choice* c, int event);
int        DLL_EXPORT Fl_ChoiceSetValue(Fl_Choice* c, int index);
int        DLL_EXPORT Fl_ChoiceSetValueByItem(Fl_Choice* c, const Fl_Menu_Item* v);
int        DLL_EXPORT Fl_ChoiceGetValue(Fl_Choice* c);

// class Fl_Progress extends Fl_Widget
Fl_Progress* DLL_EXPORT Fl_ProgressNew(int x, int y, int w, int h, const char *label=0);
void         DLL_EXPORT Fl_ProgressSetMaximum(Fl_Progress* prg, float v);
float        DLL_EXPORT Fl_ProgressGetMaximum(Fl_Progress* prg);
void         DLL_EXPORT Fl_ProgressSetMinimum(Fl_Progress* prg, float v);
float        DLL_EXPORT Fl_ProgressGetMinimum(Fl_Progress* prg);
void         DLL_EXPORT Fl_ProgressSetValue(Fl_Progress* prg, float v);
float        DLL_EXPORT Fl_ProgressGetValue(Fl_Progress* prg);

// class Fl_Valuator extends Fl_Widget
void   DLL_EXPORT Fl_ValuatorBounds(Fl_Valuator* va, double a, double b);
double DLL_EXPORT Fl_ValuatorClamp(Fl_Valuator* va, double v);
int    DLL_EXPORT Fl_ValuatorFormat(Fl_Valuator* va, char* buffer);
double DLL_EXPORT Fl_ValuatorIncrement(Fl_Valuator* va, double v, int n);
void   DLL_EXPORT Fl_ValuatorSetMaximum(Fl_Valuator* va, double a);
double DLL_EXPORT Fl_ValuatorGetMaximum(Fl_Valuator* va);
void   DLL_EXPORT Fl_ValuatorSetMinimum(Fl_Valuator* va, double a);
double DLL_EXPORT Fl_ValuatorGetMinimum(Fl_Valuator* va);
void   DLL_EXPORT Fl_ValuatorPrecision(Fl_Valuator* va, int p);
void   DLL_EXPORT Fl_ValuatorRange(Fl_Valuator* va, double a, double b);
double DLL_EXPORT Fl_ValuatorRound(Fl_Valuator* va, double v);
double DLL_EXPORT Fl_ValuatorStep(Fl_Valuator* va);
int    DLL_EXPORT Fl_ValuatorSetValue(Fl_Valuator* va, double v);
double DLL_EXPORT Fl_ValuatorGetValue(Fl_Valuator* va);

// class Fl_Adjuster extends Fl_Valuator
Fl_Adjuster* DLL_EXPORT Fl_AdjusterNew(int x, int y, int w, int h, const char *label=0);
void DLL_EXPORT Fl_AdjusterSetSoft(Fl_Adjuster* adj, int s);
int  DLL_EXPORT Fl_AdjusterGetSoft(Fl_Adjuster* adj);

// class Fl_Counter extends Fl_Valuator
Fl_Counter* DLL_EXPORT Fl_CounterNew(int x, int y, int w, int h, const char *label=0);
int  DLL_EXPORT Fl_CounterHandle(Fl_Counter* cnt, int event);
void DLL_EXPORT Fl_CounterLargeStep(Fl_Counter* cnt, double a);
void DLL_EXPORT Fl_CounterNormalStep(Fl_Counter* cnt, double a);
void DLL_EXPORT Fl_CounterStep(Fl_Counter* cnt, double a, double b);

// class Fl_Simple_Counter extends Fl_Counter
Fl_Simple_Counter* DLL_EXPORT Fl_Simple_CounterNew(int x, int y, int w, int h, const char *label=0);

// class Fl_Dial extends Fl_Valuator
Fl_Dial* DLL_EXPORT Fl_DialNew(int x, int y, int w, int h, const char *label=0);
void     DLL_EXPORT Fl_DialSetAngle1(Fl_Dial* dial, short a);
short    DLL_EXPORT Fl_DialGetAngle1(Fl_Dial* dial);
void     DLL_EXPORT Fl_DialSetAngle2(Fl_Dial* dial, short a);
short    DLL_EXPORT Fl_DialGetAngle2(Fl_Dial* dial);
void     DLL_EXPORT Fl_DialAngles(Fl_Dial* dial, short a, short b);
int      DLL_EXPORT Fl_DialHandle(Fl_Dial* dial, int event);

// class Fl_Fill_Dial extends Fl_Dial
Fl_Fill_Dial* DLL_EXPORT Fl_Fill_DialNew(int x, int y, int w, int h, const char *label=0);

// class Fl_Line_Dial extends Fl_Dial
Fl_Line_Dial* DLL_EXPORT Fl_Line_DialNew(int x, int y, int w, int h, const char *label=0);

// class Fl_Roller extends Fl_Valuator
Fl_Roller* DLL_EXPORT Fl_RollerNew(int x, int y, int w, int h, const char *label=0);


// class Fl_Slider extends Fl_Valuator
Fl_Slider* DLL_EXPORT Fl_SliderNew(int x, int y, int w, int h, const char* label=0);
Fl_Slider* DLL_EXPORT Fl_SliderNew2(uchar t, int x, int y, int w,int h, const char* label=0);
void       DLL_EXPORT Fl_SliderBounds(Fl_Slider* sl, double a, double b);
int        DLL_EXPORT Fl_SliderHandle(Fl_Slider* sl, int event);
int        DLL_EXPORT Fl_SliderScrollValue(Fl_Slider* sl, int pos, int size, int first, int total);
void       DLL_EXPORT Fl_SliderSetSlider(Fl_Slider* sl, Fl_Boxtype c);
Fl_Boxtype DLL_EXPORT Fl_SliderGetSlider(Fl_Slider* sl);
void       DLL_EXPORT Fl_SliderSetSliderSize(Fl_Slider* sl, double v);
double     DLL_EXPORT Fl_SliderGetSliderSize(Fl_Slider* sl);

// class Fl_Hor_Fill_Slider extends Fl_Slider
Fl_Hor_Slider* DLL_EXPORT Fl_Hor_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Fill_Slider extends Fl_Slider
Fl_Fill_Slider* DLL_EXPORT Fl_Fill_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Hor_Fill_Slider extends Fl_Slider
Fl_Hor_Fill_Slider* DLL_EXPORT Fl_Hor_Fill_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Nice_Slider extends Fl_Slider
Fl_Nice_Slider* DLL_EXPORT Fl_Nice_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Hor_Nice_Slider extends Fl_Slider
Fl_Hor_Nice_Slider* DLL_EXPORT Fl_Hor_Nice_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Scrollbar extends Fl_Slider
Fl_Scrollbar* DLL_EXPORT Fl_ScrollbarNew(int x, int y, int w, int h, const char* label=0);
int           DLL_EXPORT Fl_ScrollbarHandle(Fl_Scrollbar* sb, int event);
void          DLL_EXPORT Fl_ScrollbarSetLineSize(Fl_Scrollbar* sb, int i);
int           DLL_EXPORT Fl_ScrollbarGetLineSize(Fl_Scrollbar* sb);
int           DLL_EXPORT Fl_ScrollbarSetValue(Fl_Scrollbar* sb, int p);
int           DLL_EXPORT Fl_ScrollbarGetValue(Fl_Scrollbar* sb);
int           DLL_EXPORT Fl_ScrollbarValue(Fl_Scrollbar* sb, int pos, int windowSize, int first, int total);

// class Fl_Value_Slider extends Fl_Slider
Fl_Value_Slider* DLL_EXPORT Fl_Value_SliderNew(int x, int y, int w, int h, const char* label=0);
int              DLL_EXPORT Fl_Value_SliderHandle(Fl_Value_Slider* sl,  int event);
void             DLL_EXPORT Fl_Value_SliderSetTextColor(Fl_Value_Slider* sl, Fl_Color s);
Fl_Color         DLL_EXPORT Fl_Value_SliderGetTextColor(Fl_Value_Slider* sl);
void             DLL_EXPORT Fl_Value_SliderSetTextFont(Fl_Value_Slider* sl, Fl_Font s);
Fl_Font          DLL_EXPORT Fl_Value_SliderGetTextFont(Fl_Value_Slider* sl);
void             DLL_EXPORT Fl_Value_SliderSetTextSize(Fl_Value_Slider* sl, Fl_Fontsize s);
Fl_Fontsize      DLL_EXPORT Fl_Value_SliderGetTextSize(Fl_Value_Slider* sl);

// class Fl_Hor_Value_Slider extends Fl_Value_Slider
Fl_Hor_Value_Slider*  DLL_EXPORT Fl_Hor_Value_SliderNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Value_Input extends Fl_Valuator
Fl_Value_Input* DLL_EXPORT Fl_Value_InputNew(int x, int y, int w, int h, const char* label);
void            DLL_EXPORT Fl_Value_InputSetCursorColor(Fl_Value_Input* vi, Fl_Color n);
Fl_Color        DLL_EXPORT Fl_Value_InputGetCursorColor(Fl_Value_Input* vi);
int             DLL_EXPORT Fl_Value_InputHandle(Fl_Value_Input* vi, int event);
void            DLL_EXPORT Fl_Value_InputResize(Fl_Value_Input* vi, int x, int y, int w, int h);
void            DLL_EXPORT Fl_Value_InputSetShortcut(Fl_Value_Input* vi, int s);
int             DLL_EXPORT Fl_Value_InputGetShortcut(Fl_Value_Input* vi);
void            DLL_EXPORT Fl_Value_InputSetSoft(Fl_Value_Input* vi, int s);
int             DLL_EXPORT Fl_Value_InputGetSoft(Fl_Value_Input* vi);
void            DLL_EXPORT Fl_Value_InputSetTextColor(Fl_Value_Input* vi, Fl_Color n);
Fl_Color        DLL_EXPORT Fl_Value_InputGetTextColor(Fl_Value_Input* vi);
void 	          DLL_EXPORT Fl_Value_InputSetTextFont(Fl_Value_Input* vi, Fl_Font s);
Fl_Font         DLL_EXPORT Fl_Value_InputGetTextFont(Fl_Value_Input* vi);
void            DLL_EXPORT Fl_Value_InputSetTextSize(Fl_Value_Input* vi, Fl_Fontsize s);
Fl_Fontsize     DLL_EXPORT Fl_Value_InputGetTextSize(Fl_Value_Input* vi);

// class Fl_Value_Output extends Fl_Valuator
Fl_Value_Output* DLL_EXPORT Fl_Value_OutputNew(int x, int y, int w, int h, const char* label);
int             DLL_EXPORT Fl_Value_OutputHandle(Fl_Value_Output* vo, int event);
void            DLL_EXPORT Fl_Value_OutputResize(Fl_Value_Output* vo, int x, int y, int w, int h);
void            DLL_EXPORT Fl_Value_OutputSetSoft(Fl_Value_Output* vo, int s);
int             DLL_EXPORT Fl_Value_OutputGetSoft(Fl_Value_Output* vo);
void            DLL_EXPORT Fl_Value_OutputSetTextColor(Fl_Value_Output* vo, Fl_Color n);
Fl_Color        DLL_EXPORT Fl_Value_OutputGetTextColor(Fl_Value_Output* vo);
void 	          DLL_EXPORT Fl_Value_OutputSetTextFont(Fl_Value_Output* vo, Fl_Font s);
Fl_Font         DLL_EXPORT Fl_Value_OutputGetTextFont(Fl_Value_Output* vo);
void            DLL_EXPORT Fl_Value_OutputSetTextSize(Fl_Value_Output* vo, Fl_Fontsize s);
Fl_Fontsize     DLL_EXPORT Fl_Value_OutputGetTextSize(Fl_Value_Output* vo);

// class Fl_Group extends Fl_Widget
Fl_Group*  DLL_EXPORT Fl_GroupNew(int x, int y, int w, int h, const char* label=0);
void       DLL_EXPORT Fl_GroupAdd(Fl_Group* grp, Fl_Widget *o);
void       DLL_EXPORT Fl_GroupAddResizable(Fl_Group* grp, Fl_Widget &o);
Fl_Group*  DLL_EXPORT Fl_GroupAsGroup(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupBegin(Fl_Group* grp);
Fl_Widget* DLL_EXPORT Fl_GroupChild(Fl_Group* grp, int n);
int        DLL_EXPORT Fl_GroupChildren(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupClear(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupSetClipChildren(Fl_Group* grp, int c);
int        DLL_EXPORT Fl_GroupGetClipChildren(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupEnd(Fl_Group* grp);
int        DLL_EXPORT Fl_GroupFind(Fl_Group* grp, const Fl_Widget* wgt);
void       DLL_EXPORT Fl_GroupFormsEnd(Fl_Group* grp);
int        DLL_EXPORT Fl_GroupHandle(Fl_Group* grp, int ev);
void       DLL_EXPORT Fl_GroupInitSizes(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupInsert(Fl_Group* grp, Fl_Widget& o, Fl_Widget* before);
void       DLL_EXPORT Fl_GroupInsert2(Fl_Group* grp, Fl_Widget& o, int i);
void       DLL_EXPORT Fl_GroupRemove(Fl_Group* grp, int index);
void       DLL_EXPORT Fl_GroupRemove2(Fl_Group* grp, Fl_Widget* o);
Fl_Widget* DLL_EXPORT Fl_GroupGetResizable(Fl_Group* grp);
void       DLL_EXPORT Fl_GroupSetResizable(Fl_Group* grp, Fl_Widget* o);
void       DLL_EXPORT Fl_GroupResize(Fl_Group* grp, int x, int y, int w, int h);

// class Fl_Pack extends Fl_Group
Fl_Pack* DLL_EXPORT Fl_PackNew(int x, int y, int w, int h, const char* label=0);
void     DLL_EXPORT Fl_PackSetSpacing(Fl_Pack* pk, int i);
int      DLL_EXPORT Fl_PackGetSpacing(Fl_Pack* pk);

// class Fl_Tile extends Fl_Group
Fl_Tile*   DLL_EXPORT Fl_TileNew(int x, int y, int w, int h, const char* label=0);
int        DLL_EXPORT Fl_TileHandle(Fl_Tile* til, int event);
void       DLL_EXPORT Fl_TilePosition(Fl_Tile* til, int from_x, int from_y, int to_x, int to_y);
void       DLL_EXPORT Fl_TileResize(Fl_Tile* til, int x, int y, int w, int h);

// class Fl_Scroll extends Fl_Group
Fl_Scroll* DLL_EXPORT Fl_ScrollNew(int x, int y, int w, int h, const char* label=0);
void       DLL_EXPORT Fl_ScrollClear(Fl_Scroll* sc);
int        DLL_EXPORT Fl_ScrollHandle(Fl_Scroll* sc, int event);
void       DLL_EXPORT Fl_ScrollResize(Fl_Scroll* sc, int x, int y, int w, int h);
void       DLL_EXPORT Fl_ScrollScrollTo(Fl_Scroll* sc, int x, int y);
void       DLL_EXPORT Fl_ScrollSetScrollbarSize(Fl_Scroll* sc, int newSize);
int        DLL_EXPORT Fl_ScrollGetScrollbarSize(Fl_Scroll* sc);
int        DLL_EXPORT Fl_ScrollXPosition(Fl_Scroll* sc);
int        DLL_EXPORT Fl_ScrollYPosition(Fl_Scroll* sc);

// class Fl_Browser_ extends Fl_Group
int         DLL_EXPORT Fl_Browser_Deselect(Fl_Browser_* br, int docallbacks=0);
void        DLL_EXPORT Fl_Browser_Display(Fl_Browser_* br, void* item);
int         DLL_EXPORT Fl_Browser_Handle(Fl_Browser_* br, int event);
void        DLL_EXPORT Fl_Browser_SetHasScrollbar(Fl_Browser_* br, uchar mode);
uchar       DLL_EXPORT Fl_Browser_GetHasSscrollbar(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetHPosition(Fl_Browser_* br, int p);
int         DLL_EXPORT Fl_Browser_GetHPosition(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetPosition(Fl_Browser_* br, int p);
int         DLL_EXPORT Fl_Browser_GetPosition(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_Resize(Fl_Browser_* br, int x, int y, int w, int h);
void        DLL_EXPORT Fl_Browser_ScrollbarLeft(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_ScrollbarRight(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetScrollbarSize(Fl_Browser_* br, int s);
int         DLL_EXPORT Fl_Browser_GetScrollbarSize(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetScrollbarWidth(Fl_Browser_* br, int w);
int         DLL_EXPORT Fl_Browser_GetScrollbarWidth(Fl_Browser_* br);
int         DLL_EXPORT Fl_Browser_Select(Fl_Browser_* br, void* item, int v=1, int docallbacks=0);
int         DLL_EXPORT Fl_Browser_SelectOnly(Fl_Browser_* br, void* item, int docallbacks=0);
void        DLL_EXPORT Fl_Browser_Sort(Fl_Browser_* br, int flags=0);
void        DLL_EXPORT Fl_Browser_SetTextColor(Fl_Browser_* br, Fl_Color c);
Fl_Color    DLL_EXPORT Fl_Browser_GetTextColor(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetTextFont(Fl_Browser_* br, Fl_Font f);
Fl_Font     DLL_EXPORT Fl_Browser_GetTextFont(Fl_Browser_* br);
void        DLL_EXPORT Fl_Browser_SetTextsize(Fl_Browser_* br, Fl_Fontsize fs);
Fl_Fontsize DLL_EXPORT Fl_Browser_GetTextsize(Fl_Browser_* br);

// class Fl_Check_Browser extends Fl_Browser_
Fl_Check_Browser* DLL_EXPORT Fl_Check_BrowserNew(int x, int y, int w, int h, const char* label=0);
int               DLL_EXPORT Fl_Check_BrowserAdd(Fl_Check_Browser* cb, char *s);
int               DLL_EXPORT Fl_Check_BrowserAdd2(Fl_Check_Browser* cb, char *s, int b);
void              DLL_EXPORT Fl_Check_BrowserCheckAll(Fl_Check_Browser* cb);
void              DLL_EXPORT Fl_Check_BrowserCheckNone(Fl_Check_Browser* cb);
void              DLL_EXPORT Fl_Check_BrowserChecked(Fl_Check_Browser* cb, int item, int b);
void              DLL_EXPORT Fl_Check_BrowserClear(Fl_Check_Browser* cb);
int               DLL_EXPORT Fl_Check_BrowserNChecked(Fl_Check_Browser* cb);
int               DLL_EXPORT Fl_Check_BrowserNItems(Fl_Check_Browser* cb);
int               DLL_EXPORT Fl_Check_BrowserRemove(Fl_Check_Browser* cb, int item);
void              DLL_EXPORT Fl_Check_BrowserSetChecked(Fl_Check_Browser* cb, int item);
int               DLL_EXPORT Fl_Check_BrowserGetChecked(Fl_Check_Browser* cb, int item);
char*             DLL_EXPORT Fl_Check_BrowserText(Fl_Check_Browser* cb, int item);
int               DLL_EXPORT Fl_Check_BrowserValue(Fl_Check_Browser* cb);

// class Fl_Browser extends Fl_Browser_
Fl_Browser* DLL_EXPORT Fl_BrowserNew(int x, int y, int w, int h, const char* label=0);
void        DLL_EXPORT Fl_BrowserAdd(Fl_Browser* br, const char* newtext, void* d=0);
void        DLL_EXPORT Fl_BrowserBottomLine(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserClear(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserSetColumnChar(Fl_Browser* br, char c);
char        DLL_EXPORT Fl_BrowserGetColumnChar(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserSetColumnWidths(Fl_Browser* br, const int* arr);
const int*  DLL_EXPORT Fl_BrowserGetColumnWidths(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserSetData(Fl_Browser* br, int line, void* d);
void*       DLL_EXPORT Fl_BrowserGetData(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserDisplay(Fl_Browser* br, int line, int v=1);
int         DLL_EXPORT Fl_BrowserDisplayed(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserSetFormatChar(Fl_Browser* br, char c);
char        DLL_EXPORT Fl_BrowserGetFormatChar(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserHide(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserHide2(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserSetIcon(Fl_Browser* br, int line, Fl_Image* icon);
Fl_Image*   DLL_EXPORT Fl_BrowserGetIcon(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserInsert(Fl_Browser* br, int line, const char* newtext, void* d=0);
void        DLL_EXPORT Fl_BrowserLinePosition(Fl_Browser* br, int line, Fl_Browser::Fl_Line_Position pos);
int         DLL_EXPORT Fl_BrowserLoad(Fl_Browser* br, const char* filename);
void        DLL_EXPORT Fl_BrowserMakeVisible(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserMiddleLine(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserMove(Fl_Browser* br, int to, int from);
void        DLL_EXPORT Fl_BrowserRemove(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserRemoveIcon(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserReplace(Fl_Browser* br, int a, const char* b);
int         DLL_EXPORT Fl_BrowserSelect(Fl_Browser* br, int line, int v=1);
int         DLL_EXPORT Fl_BrowserSelected(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserShow(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserShow2(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserSetSize(Fl_Browser* br, int w, int h);
int         DLL_EXPORT Fl_BrowserGetSize(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserSwap(Fl_Browser* br, int a, int b);
void        DLL_EXPORT Fl_BrowserSetText(Fl_Browser* br, int line, const char* newtext);
const char* DLL_EXPORT Fl_BrowserGetText(Fl_Browser* br, int line);
void        DLL_EXPORT Fl_BrowserSetTopline(Fl_Browser* br, int line);
int         DLL_EXPORT Fl_BrowserGetTopline(Fl_Browser* br);
void        DLL_EXPORT Fl_BrowserSetValue(Fl_Browser* br, int line);
int         DLL_EXPORT Fl_BrowserGetValue(Fl_Browser* br);
int         DLL_EXPORT Fl_BrowserVisible(Fl_Browser* br, int line);

// class Fl_File_Browser extends Fl_Browser
Fl_File_Browser* DLL_EXPORT Fl_File_BrowserNew(int x, int y, int w, int h, const char* label=0);
void             DLL_EXPORT Fl_File_BrowserSetFiletype(Fl_File_Browser* fb, int t);
int              DLL_EXPORT Fl_File_BrowserGetFiletype(Fl_File_Browser* fb);
void             DLL_EXPORT Fl_File_BrowserSetFilter(Fl_File_Browser* fb, const char* pattern);
const char*      DLL_EXPORT Fl_File_BrowserGetFilter(Fl_File_Browser* fb);
void             DLL_EXPORT Fl_File_BrowserSetIconSize(Fl_File_Browser* fb, uchar s);
uchar            DLL_EXPORT Fl_File_BrowserGetIconSize(Fl_File_Browser* fb);
int              DLL_EXPORT Fl_File_BrowserLoad(Fl_File_Browser* fb, const char* directory);
void             DLL_EXPORT Fl_File_BrowserSetTextSize(Fl_File_Browser* fb, Fl_Fontsize s);
Fl_Fontsize      DLL_EXPORT Fl_File_BrowserGetTextSize(Fl_File_Browser* fb);

// class Fl_Hold_Browser extends Fl_Browser
Fl_Hold_Browser* DLL_EXPORT Fl_Hold_BrowserNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Multi_Browser extends Fl_Browser
Fl_Multi_Browser* DLL_EXPORT Fl_Multi_BrowserNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Select_Browser extends Fl_Browser
Fl_Select_Browser* DLL_EXPORT Fl_Select_BrowserNew(int x, int y, int w, int h, const char* label=0);

// class Fl_Color_Chooser extends Fl_Group
Fl_Color_Chooser* DLL_EXPORT Fl_Color_ChooserNew(int x, int y, int w, int h, const char* label=0);
void              DLL_EXPORT Fl_Color_ChooserSetMode(Fl_Color_Chooser* cc, int newMode);
int               DLL_EXPORT Fl_Color_ChooserGetMode(Fl_Color_Chooser* cc);
int               DLL_EXPORT Fl_Color_ChooserRGB(Fl_Color_Chooser* cc, double r, double g, double b);
double            DLL_EXPORT Fl_Color_ChooserR(Fl_Color_Chooser* cc);
double            DLL_EXPORT Fl_Color_ChooserG(Fl_Color_Chooser* cc);
double            DLL_EXPORT Fl_Color_ChooserB(Fl_Color_Chooser* cc);
int               DLL_EXPORT Fl_Color_ChooserHSV(Fl_Color_Chooser* cc, double h, double s, double v);
double            DLL_EXPORT Fl_Color_ChooserHue(Fl_Color_Chooser* cc);
double            DLL_EXPORT Fl_Color_ChooserSaturation(Fl_Color_Chooser* cc);
double            DLL_EXPORT Fl_Color_ChooserValue(Fl_Color_Chooser* cc);
void              DLL_EXPORT Fl_Color_ChooserHSV2RGB(Fl_Color_Chooser* cc, double h, double s, double v, double &r, double &g, double &b);
void              DLL_EXPORT Fl_Color_ChooserRGB2HSV(Fl_Color_Chooser* cc, double r, double g, double b, double &h, double &s, double &v);


// class Fl_Help_View extends Fl_Group
Fl_Help_View* DLL_EXPORT Fl_Help_ViewNew(int x, int y, int w, int h, const char* label=0);
void          DLL_EXPORT Fl_Help_ViewClearSelection(Fl_Help_View* hv);
const char*   DLL_EXPORT Fl_Help_ViewDirectory(Fl_Help_View* hv);
const char*   DLL_EXPORT Fl_Help_ViewFilename(Fl_Help_View* hv);
int           DLL_EXPORT Fl_Help_ViewFind(Fl_Help_View* hv, const char *s, int p=0);
void          DLL_EXPORT Fl_Help_ViewSetLeftLine(Fl_Help_View* hv,int ll);
int           DLL_EXPORT Fl_Help_ViewGetLeftLine(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewLink(Fl_Help_View* hv, Fl_Help_Func *fn);
int           DLL_EXPORT Fl_Help_ViewLoad(Fl_Help_View* hv,const char* filename);
void          DLL_EXPORT Fl_Help_ViewResize(Fl_Help_View* hv, int x, int y, int w, int h);
void          DLL_EXPORT Fl_Help_ViewSetScrollbarSize(Fl_Help_View* hv, int s);
int           DLL_EXPORT Fl_Help_ViewGetScrollbarSize(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSelectAll(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSetSize(Fl_Help_View* hv, int w, int h);
int           DLL_EXPORT Fl_Help_ViewGetSize(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSetTextColor(Fl_Help_View* hv, Fl_Color c);
Fl_Color      DLL_EXPORT Fl_Help_ViewGetTextColor(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSetTextFont(Fl_Help_View* hv, Fl_Font f);
Fl_Font       DLL_EXPORT Fl_Help_ViewGetTextFont(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSetTextSize(Fl_Help_View* hv, Fl_Fontsize s);
Fl_Fontsize   DLL_EXPORT Fl_Help_ViewGetTextSize(Fl_Help_View* hv);
const char*   DLL_EXPORT Fl_Help_ViewTitle(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewTopline(Fl_Help_View* hv, const char* name);
void          DLL_EXPORT Fl_Help_ViewSetTopline(Fl_Help_View* hv, int pixel);
int           DLL_EXPORT Fl_Help_ViewGetTopline(Fl_Help_View* hv);
void          DLL_EXPORT Fl_Help_ViewSetValue(Fl_Help_View* hv, const char* v);
const char*   DLL_EXPORT Fl_Help_ViewGetValue(Fl_Help_View* hv);

// class Fl_Input_Choice extends Fl_Group
Fl_Input_Choice*    DLL_EXPORT Fl_Input_ChoiceNew(int x,int y,int w,int h,const char* title);
void                DLL_EXPORT Fl_Input_ChoiceAdd(Fl_Input_Choice* ic, const char* s);
int                 DLL_EXPORT Fl_Input_ChoiceChanged(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceClear(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceClearChanged(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceSetDownBox(Fl_Input_Choice* ic, Fl_Boxtype b);
Fl_Boxtype          DLL_EXPORT Fl_Input_ChoiceGetDownBox(Fl_Input_Choice* ic);
Fl_Input*           DLL_EXPORT Fl_Input_ChoiceInput(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceSetMenu(Fl_Input_Choice* ic, const Fl_Menu_Item* m);
const Fl_Menu_Item* DLL_EXPORT Fl_Input_ChoiceGetMenu(Fl_Input_Choice* ic);
Fl_Menu_Button*     DLL_EXPORT Fl_Input_ChoiceMenuButton(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceResize(Fl_Input_Choice* ic, int x, int y, int w, int h);
void                DLL_EXPORT Fl_Input_ChoiceSetChanged(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceSetTextColor(Fl_Input_Choice* ic, Fl_Color c);
Fl_Color            DLL_EXPORT Fl_Input_ChoiceGetTextColor(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceSetTextFont(Fl_Input_Choice* ic, Fl_Font f);
Fl_Font             DLL_EXPORT Fl_Input_ChoiceGetTextFont(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceSetTextSize(Fl_Input_Choice* ic, Fl_Fontsize s);
Fl_Fontsize         DLL_EXPORT Fl_Input_ChoiceGetTextSize(Fl_Input_Choice* ic);
void                DLL_EXPORT Fl_Input_ChoiceValue(Fl_Input_Choice* ic, int val);
void                DLL_EXPORT Fl_Input_ChoiceSetValue(Fl_Input_Choice* ic, const char* v);
const char*         DLL_EXPORT Fl_Input_ChoiceGetValue(Fl_Input_Choice* ic);


// class Fl_Spinner extends Fl_Group
Fl_Spinner* DLL_EXPORT Fl_SpinnerNew(int x, int y, int w, int h, const char* label=0);
void        DLL_EXPORT Fl_SpinnerSetColor(Fl_Spinner* spi, Fl_Color v);
Fl_Color    DLL_EXPORT Fl_SpinnerGetColor(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetFormat(Fl_Spinner* spi, const char* f);
const char* DLL_EXPORT Fl_SpinnerGetFormat(Fl_Spinner* spi);
int         DLL_EXPORT Fl_SpinnerHandle(Fl_Spinner* spi, int event);
void        DLL_EXPORT Fl_SpinnerSetMaximum(Fl_Spinner* spi, double m);
double      DLL_EXPORT Fl_SpinnerGetMaximum(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetMinimum(Fl_Spinner* spi, double m);
double      DLL_EXPORT Fl_SpinnerGetMinimum(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerRange(Fl_Spinner* spi, double a, double b);
void        DLL_EXPORT Fl_SpinnerResize(Fl_Spinner* spi, int x, int y, int w, int h);
void        DLL_EXPORT Fl_SpinnerSetStep(Fl_Spinner* spi, double s);
double      DLL_EXPORT Fl_SpinnerGetStep(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetTextColor(Fl_Spinner* spi, Fl_Color c);
Fl_Color    DLL_EXPORT Fl_SpinnerGetTextColor(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetTextFont(Fl_Spinner* spi, Fl_Font f);
Fl_Font     DLL_EXPORT Fl_SpinnerGetTextFont(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetTextSize(Fl_Spinner* spi, Fl_Fontsize s);
Fl_Fontsize DLL_EXPORT Fl_SpinnerGetTextSize(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetType(Fl_Spinner* spi, uchar v);
uchar       DLL_EXPORT Fl_SpinnerGetType(Fl_Spinner* spi);
void        DLL_EXPORT Fl_SpinnerSetValue(Fl_Spinner* spi, double v);
double      DLL_EXPORT Fl_SpinnerGetValue(Fl_Spinner* spi);

// class Fl_Table extends Fl_Group
Fl_Table*         DLL_EXPORT Fl_TableNew(int x, int y, int w, int h, const char* label=0);
void              DLL_EXPORT Fl_TableAdd(Fl_Table* t, Fl_Widget* wgt);
Fl_Widget* const* DLL_EXPORT Fl_TableArray(Fl_Table* t);
void              DLL_EXPORT Fl_TableBegin(Fl_Table* t);
int               DLL_EXPORT Fl_TableCallbackCol(Fl_Table* t);
Fl_Table::TableContext DLL_EXPORT Fl_TableCallbackContext(Fl_Table* t);
int               DLL_EXPORT Fl_TableCallbackRow(Fl_Table* t);
Fl_Widget*        DLL_EXPORT Fl_TableChild(Fl_Table* t, int n);
int               DLL_EXPORT Fl_TableChildren(Fl_Table* t);
void              DLL_EXPORT Fl_TableClear(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColHeader(Fl_Table* t, int flag);
int               DLL_EXPORT Fl_TableGetColHeader(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColHeaderColor(Fl_Table* t, Fl_Color c);
Fl_Color          DLL_EXPORT Fl_TableGetColHeaderColor(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColHeaderHeight(Fl_Table* t, int h);
int               DLL_EXPORT Fl_TableGetColHeaderHeight(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColPosition(Fl_Table* t, int c);
int               DLL_EXPORT Fl_TableGetColPosition(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColResize(Fl_Table* t, int flag);
int               DLL_EXPORT Fl_TableGetColResize(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColResizeMin(Fl_Table* t,int m);
int               DLL_EXPORT Fl_TableGetColResizeMin(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetColWidth(Fl_Table* t, int c, int w);
int               DLL_EXPORT Fl_TableGetColWidth(Fl_Table* t,int c);

void              DLL_EXPORT Fl_TableColWidthAll(Fl_Table* t,int w);

void              DLL_EXPORT Fl_TableSetCols(Fl_Table* t,int c);
int               DLL_EXPORT Fl_TableGetCols(Fl_Table* t);

void              DLL_EXPORT Fl_TableDoCallback(Fl_Table* t, Fl_Table::TableContext context, int r, int c);
void              DLL_EXPORT Fl_TableDraw(Fl_Table* t);
void              DLL_EXPORT Fl_TableEnd(Fl_Table* t);
int               DLL_EXPORT Fl_TableFind(Fl_Table* t,const Fl_Widget* wgt);
void              DLL_EXPORT Fl_TableGetSelection(Fl_Table* t, int &row_top, int &col_left, int &row_bot, int &col_right);
void              DLL_EXPORT Fl_TableInitSizes(Fl_Table* t);
void              DLL_EXPORT Fl_TableInsert(Fl_Table* t, Fl_Widget& wgt, int n);
void              DLL_EXPORT Fl_TableInsert2(Fl_Table* t, Fl_Widget& wgt, Fl_Widget *w2);
int               DLL_EXPORT Fl_TableIsInteractiveResize(Fl_Table* t);
int               DLL_EXPORT Fl_TableIsSelected(Fl_Table* t, int r, int c);
int               DLL_EXPORT Fl_TableMoveCursor(Fl_Table* t, int r, int c);
void              DLL_EXPORT Fl_TableRemove(Fl_Table* t, Fl_Widget& wgt);
void              DLL_EXPORT Fl_TableResize(Fl_Table* t,int x, int y, int w, int h);

void              DLL_EXPORT Fl_TableSetRowHeader(Fl_Table* t, int flag);
int               DLL_EXPORT Fl_TableGetRowHeader(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRowHeaderColor(Fl_Table* t, Fl_Color c);
Fl_Color          DLL_EXPORT Fl_TableGetRowHeaderColor(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRowHeaderWidth(Fl_Table* t,int w);
int               DLL_EXPORT Fl_TableGetRowHeaderWidth(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRowHeight(Fl_Table* t,int r, int h);
int               DLL_EXPORT Fl_TableGetRowHeight(Fl_Table* t,int r);
void              DLL_EXPORT Fl_TableRowHeightAll(Fl_Table* t,int height);

void              DLL_EXPORT Fl_TableSetRowPosition(Fl_Table* t,int p);
int               DLL_EXPORT Fl_TableGetRowPosition(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRowResize(Fl_Table* t, int flag);
int               DLL_EXPORT Fl_TableGetRowResize(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRowResizeMin(Fl_Table* t,int m);
int               DLL_EXPORT Fl_TableGetRowResizeMin(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetRows(Fl_Table* t,int r);
int               DLL_EXPORT Fl_TableGetRows(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetSelection(Fl_Table* t, int row_top, int col_left, int row_bot, int col_right);

void              DLL_EXPORT Fl_TableSetTableBox(Fl_Table* t, Fl_Boxtype bt);
Fl_Boxtype        DLL_EXPORT Fl_TableGetTableBox(Fl_Table* t);

void              DLL_EXPORT Fl_TableSetTopRow(Fl_Table* t, int row);
int               DLL_EXPORT Fl_TableGetTopRow(Fl_Table* t);

void              DLL_EXPORT Fl_TableVisibleCells(Fl_Table* t, int &r1, int &r2, int &c1, int &c2);
void              DLL_EXPORT Fl_TableWhen(Fl_Table* t, Fl_When flags);

// class Fl_TableEx extends Fl_Table
Fl_TableEx* DLL_EXPORT Fl_TableExNew(int x, int y, int w, int h, char* label);
void        DLL_EXPORT Fl_TableExSetDrawCB(Fl_TableEx*, Fl_drawEx cb);
void        DLL_EXPORT Fl_TableExSetDrawCellCB(Fl_TableEx*, Fl_drawcellEx cb);
void        DLL_EXPORT Fl_TableExSetHandleCB(Fl_TableEx*, Fl_handleEx cb);
void        DLL_EXPORT Fl_TableExSetResizeCB(Fl_TableEx*, Fl_resizeEx cb);


// class Fl_Table_Row extends Fl_Table
Fl_Table_Row* DLL_EXPORT Fl_Table_RowNew(int x, int y, int w, int h, const char* label=0);
void          DLL_EXPORT Fl_Table_RowClear(Fl_Table_Row* tr);
int           DLL_EXPORT Fl_Table_RowRowSelected(Fl_Table_Row* tr, int row);
void          DLL_EXPORT Fl_Table_RowSetRows(Fl_Table_Row* tr, int r);
int           DLL_EXPORT Fl_Table_RowGetRows(Fl_Table_Row* tr);
void          DLL_EXPORT Fl_Table_RowSelectAllRows(Fl_Table_Row* tr, int flag=1);
int           DLL_EXPORT Fl_Table_RowSelectRow(Fl_Table_Row* tr, int row, int flag=1);
void          DLL_EXPORT Fl_Table_RowSetType(Fl_Table_Row* tr, Fl_Table_Row::TableRowSelectMode t);
Fl_Table_Row::TableRowSelectMode DLL_EXPORT Fl_Table_RowGetType(Fl_Table_Row* tr);

// class Fl_Tabs extends Fl_Group
Fl_Tabs*   DLL_EXPORT Fl_TabsNew(int x, int y, int w, int h, const char* label=0);
void       DLL_EXPORT Fl_TabsClientArea(Fl_Tabs* tbs, int &rx, int &ry, int &rw, int &rh, int tabh=0);
int        DLL_EXPORT Fl_TabsHandle(Fl_Tabs* tbs, int event);
int        DLL_EXPORT Fl_TabsSetPush(Fl_Tabs* tbs, Fl_Widget* wgt);
Fl_Widget* DLL_EXPORT Fl_TabsGetPush(Fl_Tabs* tbs);
int        DLL_EXPORT Fl_TabsSetValue(Fl_Tabs* tbs, Fl_Widget* wgt);
Fl_Widget* DLL_EXPORT Fl_TabsGetValue(Fl_Tabs* tbs);
Fl_Widget* DLL_EXPORT Fl_TabsWhich(Fl_Tabs* tbs, int event_x, int event_y);


int  DLL_EXPORT Fl_Text_SelectionEnd(Fl_Text_Selection* ts);
int  DLL_EXPORT Fl_Text_SelectionIncludes(Fl_Text_Selection* ts, int pos);
int  DLL_EXPORT Fl_Text_SelectionPosition(Fl_Text_Selection* ts, int* start, int* end);
void DLL_EXPORT Fl_Text_SelectionSetSelected(Fl_Text_Selection* ts, int b);
int  DLL_EXPORT Fl_Text_SelectionGetSelected(Fl_Text_Selection* ts);
void DLL_EXPORT Fl_Text_SelectionSet(Fl_Text_Selection* ts,int start, int end);
int  DLL_EXPORT Fl_Text_SelectionStart(Fl_Text_Selection* ts);
void DLL_EXPORT Fl_Text_SelectionUpdate(Fl_Text_Selection* ts,int pos, int nDeleted, int nInserted);

// class Fl_Text_Buffer used by Fl_Text_Display
Fl_Text_Buffer* DLL_EXPORT Fl_Text_BufferNew(int requestedSize=0, int preferredGapSize=1024);
void            DLL_EXPORT Fl_Text_BufferAddModifyCallback(Fl_Text_Buffer* tb, Fl_Text_Modify_Cb cb, void* cbArg);
void            DLL_EXPORT Fl_Text_BufferAddPredeleteCallback(Fl_Text_Buffer* tb, Fl_Text_Predelete_Cb cb, void* cbArg);
char*           DLL_EXPORT Fl_Text_BufferAddress(Fl_Text_Buffer* tb, int pos);
const char*     DLL_EXPORT Fl_Text_BufferAddress2(Fl_Text_Buffer* tb, int pos);
void            DLL_EXPORT Fl_Text_BufferAppend(Fl_Text_Buffer* tb, const char* text);
int             DLL_EXPORT Fl_Text_BufferAppendFile(Fl_Text_Buffer* tb, const char* file, int buflen = 128*1024);
char            DLL_EXPORT Fl_Text_BufferByteAt(Fl_Text_Buffer* tb, int pos);
void            DLL_EXPORT Fl_Text_BufferCallModifyCallbacks(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferCallPredeleteCallbacks(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferCanUndo(Fl_Text_Buffer* tb, char flag=1);
unsigned int    DLL_EXPORT Fl_Text_BufferCharAt(Fl_Text_Buffer* tb, int pos);
void            DLL_EXPORT Fl_Text_BufferCopy(Fl_Text_Buffer* tb, Fl_Text_Buffer* fromBuf, int fromStart, int fromEnd, int toPos);
int             DLL_EXPORT Fl_Text_BufferCountDisplayedCharacters(Fl_Text_Buffer* tb, int lineStartPos, int targetPos);
int             DLL_EXPORT Fl_Text_BufferCountLines(Fl_Text_Buffer* tb, int startPos, int endPos);
int             DLL_EXPORT Fl_Text_BufferFindCharBackward(Fl_Text_Buffer* tb, int startPos, unsigned int searchChar, int* foundPos);
int             DLL_EXPORT Fl_Text_BufferFindCharForward(Fl_Text_Buffer* tb, int startPos, unsigned searchChar, int* foundPos);
void            DLL_EXPORT Fl_Text_BufferSetHighlight(Fl_Text_Buffer* tb, int start, int end);
int             DLL_EXPORT Fl_Text_BufferGetHighlight(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferHighlightPosition(Fl_Text_Buffer* tb, int* start, int* end);
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferHighlightSelection(Fl_Text_Buffer* tb);
char*           DLL_EXPORT Fl_Text_BufferHighlightText(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferInsert(Fl_Text_Buffer* tb, int pos, const char* text);
int             DLL_EXPORT Fl_Text_BufferInsertFile(Fl_Text_Buffer* tb, const char* file, int pos, int buflen = 128*1024);
int             DLL_EXPORT Fl_Text_BufferLength(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferLineEnd(Fl_Text_Buffer* tb, int pos);
int             DLL_EXPORT Fl_Text_BufferLineStart(Fl_Text_Buffer* tb, int pos);
char*           DLL_EXPORT Fl_Text_BufferLineText(Fl_Text_Buffer* tb, int pos);
int             DLL_EXPORT Fl_Text_BufferLoadFile(Fl_Text_Buffer* tb, const char* file, int buflen = 128*1024);
int             DLL_EXPORT Fl_Text_BufferNextChar(Fl_Text_Buffer* tb, int ix);
int             DLL_EXPORT Fl_Text_BufferNextCharClipped(Fl_Text_Buffer* tb, int ix);
int             DLL_EXPORT Fl_Text_BufferOutputFile(Fl_Text_Buffer* tb, const char* file, int start, int end, int buflen = 128*1024);
int             DLL_EXPORT Fl_Text_BufferPrevChar(Fl_Text_Buffer* tb, int ix);
int             DLL_EXPORT Fl_Text_BufferPrevCharClipped(Fl_Text_Buffer* tb, int ix);
Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferPrimarySelection(Fl_Text_Buffer* tb);
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferPrimarySelection2(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferRemove(Fl_Text_Buffer* tb, int start, int end);
void            DLL_EXPORT Fl_Text_BufferRemoveModifyCallback(Fl_Text_Buffer* tb, Fl_Text_Modify_Cb cb, void* cbArg);
void            DLL_EXPORT Fl_Text_BufferRemovePredeleteCallback(Fl_Text_Buffer* tb, Fl_Text_Predelete_Cb cb, void* cbArg);
void            DLL_EXPORT Fl_Text_BufferRemoveSecondarySelection(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferRemoveSelection(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferReplace(Fl_Text_Buffer* tb, int start, int end, const char* text);
void            DLL_EXPORT Fl_Text_BufferReplaceSecondarySelection(Fl_Text_Buffer* tb, const char* text);
void            DLL_EXPORT Fl_Text_BufferReplaceSelection(Fl_Text_Buffer* tb, const char* text);
int             DLL_EXPORT Fl_Text_BufferRewindLines(Fl_Text_Buffer* tb, int startPos, int nLines);
int             DLL_EXPORT Fl_Text_BufferSaveFile(Fl_Text_Buffer* tb, const char* file, int buflen = 128*1024);
int             DLL_EXPORT Fl_Text_BufferSearchBackward(Fl_Text_Buffer* tb, int startPos, const char* searchString, int* foundPos, int matchCase=0);
int             DLL_EXPORT Fl_Text_BufferSearchForward(Fl_Text_Buffer* tb, int startPos, const char* searchString, int* foundPos, int matchCase=0);
void            DLL_EXPORT Fl_Text_BufferSecondarySelect(Fl_Text_Buffer* tb, int start, int end);
int             DLL_EXPORT Fl_Text_BufferSecondarySelected(Fl_Text_Buffer* tb);
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferSecondarySelection(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferSecondarySelectionPosition(Fl_Text_Buffer* tb, int* start, int* end);
char*           DLL_EXPORT Fl_Text_BufferSecondarySelectionText(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferSecondaryUnselect(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferSelect(Fl_Text_Buffer* tb, int start, int end);
int             DLL_EXPORT Fl_Text_BufferSelected(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferSelectionPosition(Fl_Text_Buffer* tb, int* start, int* end);
char*           DLL_EXPORT Fl_Text_BufferSelectionText(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferSkipDisplayedCharacters(Fl_Text_Buffer* tb, int lineStartPos, int nChars);
int             DLL_EXPORT Fl_Text_BufferSkipLines(Fl_Text_Buffer* tb, int startPos, int nLines);
void            DLL_EXPORT Fl_Text_BufferSetTabDistance(Fl_Text_Buffer* tb, int tabDist);
int             DLL_EXPORT Fl_Text_BufferGetTabDistance(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferSetText(Fl_Text_Buffer* tb, const char* text);
char*           DLL_EXPORT Fl_Text_BufferGetText(Fl_Text_Buffer* tb);
char*           DLL_EXPORT Fl_Text_BufferTextRange(Fl_Text_Buffer* tb, int start, int end);
int             DLL_EXPORT Fl_Text_BufferUndo(Fl_Text_Buffer* tb, int* cp=0);
void            DLL_EXPORT Fl_Text_BufferUnhighlight(Fl_Text_Buffer* tb);
void            DLL_EXPORT Fl_Text_BufferUnselect(Fl_Text_Buffer* tb);
int             DLL_EXPORT Fl_Text_BufferUtf8Align(Fl_Text_Buffer* tb, int a);
int             DLL_EXPORT Fl_Text_BufferWordEnd(Fl_Text_Buffer* tb, int pos);
int             DLL_EXPORT Fl_Text_BufferWordStart(Fl_Text_Buffer* tb, int pos);

// class Fl_Text_Display extends Fl_Group
Fl_Text_Display* DLL_EXPORT Fl_Text_DisplayNew(int x,int y,int w,int h,const char* label);
void             DLL_EXPORT Fl_Text_DisplaySetBuffer(Fl_Text_Display* td, Fl_Text_Buffer* buf);
Fl_Text_Buffer*  DLL_EXPORT Fl_Text_DisplayGetBuffer(Fl_Text_Display* td);
double           DLL_EXPORT Fl_Text_DisplayColToX(Fl_Text_Display* td, double col);
int              DLL_EXPORT Fl_Text_DisplayCountLines(Fl_Text_Display* td, int start, int end, bool start_pos_is_line_start);
void             DLL_EXPORT Fl_Text_DisplaySetCursorColor(Fl_Text_Display* td, Fl_Color c);
Fl_Color         DLL_EXPORT Fl_Text_DisplayGetCursorColor(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayCursorStyle(Fl_Text_Display* td, int style);
int	             DLL_EXPORT Fl_Text_DisplayHandle(Fl_Text_Display* td, int e);
void             DLL_EXPORT Fl_Text_DisplayHideCursor(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayHighlightData(Fl_Text_Display* td, Fl_Text_Buffer* styleBuffer, const Fl_Text_Display::Style_Table_Entry* styleTable, int nStyles, char unfinishedStyle, Fl_Text_Display::Unfinished_Style_Cb cb, void* cbArg);
int              DLL_EXPORT Fl_Text_DisplayInSelection(Fl_Text_Display* td, int x, int y);
void             DLL_EXPORT Fl_Text_DisplayInsert(Fl_Text_Display* td, const char* text);
void             DLL_EXPORT Fl_Text_DisplaySetInsertPosition(Fl_Text_Display* td, int newPos);
int              DLL_EXPORT Fl_Text_DisplayGetInsertPosition(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplayLineEnd(Fl_Text_Display* td, int startPos, bool startPosIsLineStart);
int              DLL_EXPORT Fl_Text_DisplayLineStart(Fl_Text_Display* td, int pos);
int              DLL_EXPORT Fl_Text_DisplayMoveDown(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplayMoveLeft(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplayMoveRight(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplayMoveUp(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayNextWord(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayOverStrike(Fl_Text_Display* td, const char* text);
int              DLL_EXPORT Fl_Text_DisplayPositionStyle(Fl_Text_Display* td, int lineStartPos, int lineLen, int lineIndex);
int              DLL_EXPORT Fl_Text_DisplayPositionToXY(Fl_Text_Display* td, int pos, int* x, int* y);
void             DLL_EXPORT Fl_Text_DisplayPreviousWord(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayRedisplayRange(Fl_Text_Display* td, int start, int end);
void             DLL_EXPORT Fl_Text_DisplayResize(Fl_Text_Display* td, int x, int y, int w, int h);
int              DLL_EXPORT Fl_Text_DisplayRewindLines(Fl_Text_Display* td, int startPos, int nLines);
void             DLL_EXPORT Fl_Text_DisplayScroll(Fl_Text_Display* td, int topLineNum, int horizOffset);
void             DLL_EXPORT Fl_Text_DisplaySetScrollbarAlign(Fl_Text_Display* td, Fl_Align a);
Fl_Align         DLL_EXPORT Fl_Text_DisplayGetScrollbarAlign(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplaySetScrollbarWidth(Fl_Text_Display* td, int w);
int              DLL_EXPORT Fl_Text_DisplayGetScrollbarWidth(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplaySetShortcut(Fl_Text_Display* td, int s);
int              DLL_EXPORT Fl_Text_DisplayGetShortcut(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplayShowCursor(Fl_Text_Display* td, int b=1);
void             DLL_EXPORT Fl_Text_DisplayShowInsertPosition(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplaySkipLines(Fl_Text_Display* td, int startPos, int nLines, bool startPosIsLineStart);
void             DLL_EXPORT Fl_Text_DisplaySetTextColor(Fl_Text_Display* td, Fl_Color n);
Fl_Color         DLL_EXPORT Fl_Text_DisplayGetTextColor(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplaySetTextFont(Fl_Text_Display* td, Fl_Font s);
Fl_Font          DLL_EXPORT Fl_Text_DisplayGetTextFont(Fl_Text_Display* td);
void             DLL_EXPORT Fl_Text_DisplaySetTextSize(Fl_Text_Display* td, Fl_Fontsize s);
Fl_Fontsize      DLL_EXPORT Fl_Text_DisplayGetTextSize(Fl_Text_Display* td);
int              DLL_EXPORT Fl_Text_DisplayWordEnd(Fl_Text_Display* td, int pos);
int              DLL_EXPORT Fl_Text_DisplayWordStart(Fl_Text_Display* td, int pos);
void             DLL_EXPORT Fl_Text_DisplayWrapMode(Fl_Text_Display* td, int wrap, int wrap_margin);
int              DLL_EXPORT Fl_Text_DisplayWrappedColumn(Fl_Text_Display* td, int row, int column);
int              DLL_EXPORT Fl_Text_DisplayWrappedRow(Fl_Text_Display* td, int row);
double           DLL_EXPORT Fl_Text_DisplayXToCol(Fl_Text_Display* td, double x);

// class Fl_Text_Editor extends Fl_Text_Display
Fl_Text_Editor* DLL_EXPORT Fl_Text_EditorNew(int x,int y,int w,int h,const char* label);
void            DLL_EXPORT Fl_Text_EditorAddDefaultKeyBindings(Fl_Text_Editor* te, Fl_Text_Editor::Key_Binding** list);
void            DLL_EXPORT Fl_Text_EditorAddKeyBinding(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Func f);
void            DLL_EXPORT Fl_Text_EditorAddKeyBinding2(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Func f, Fl_Text_Editor::Key_Binding** list);
Fl_Text_Editor::Key_Func DLL_EXPORT Fl_Text_EditorBoundKeyFunction(Fl_Text_Editor* te, int key, int state);
Fl_Text_Editor::Key_Func DLL_EXPORT Fl_Text_EditorBoundKeyFunction2(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Binding* list);
void            DLL_EXPORT Fl_Text_EditorDefaultKeyFunction(Fl_Text_Editor* te, Fl_Text_Editor::Key_Func f);
int             DLL_EXPORT Fl_Text_EditorHandle(Fl_Text_Editor* te, int e);
void            DLL_EXPORT Fl_Text_EditorSetInsertMode(Fl_Text_Editor* te, int m);
int             DLL_EXPORT Fl_Text_EditorGetInsertMode(Fl_Text_Editor* te);
void            DLL_EXPORT Fl_Text_EditorRemoveAllKeyBindings(Fl_Text_Editor* te);
void            DLL_EXPORT Fl_Text_EditorRemoveAllKeyBindings2(Fl_Text_Editor* te, Fl_Text_Editor::Key_Binding **list);
void            DLL_EXPORT Fl_Text_EditorRemoveKeyBinding(Fl_Text_Editor* te, int key, int state);
void            DLL_EXPORT Fl_Text_EditorRemoveKeyBinding2(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Binding **list);

// class Fl_Tree_Itm is used by Fl_Tree
void             DLL_EXPORT Fl_Tree_ItemSetLabel(Fl_Tree_Item* item, const char* newlabel);
const char*      DLL_EXPORT Fl_Tree_ItemGetLabel(Fl_Tree_Item* item);
void             DLL_EXPORT Fl_Tree_ItemSetWidget(Fl_Tree_Item* item, Fl_Widget *wgt);
const Fl_Widget* DLL_EXPORT Fl_Tree_ItemGetWidget(Fl_Tree_Item* item);

// class Fl_Tree extends Fl_Group
Fl_Tree*       DLL_EXPORT Fl_TreeNew(int x,int y,int w,int h,const char* label=0);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeAdd(Fl_Tree* tr, const char* path);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeAddItem(Fl_Tree* tr, Fl_Tree_Item *item, const char *name);
void           DLL_EXPORT Fl_TreeSetCallbackItem (Fl_Tree* tr, Fl_Tree_Item *item);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeGetCallbackItem(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetCallbackReason(Fl_Tree* tr, Fl_Tree_Reason reason);
Fl_Tree_Reason DLL_EXPORT Fl_TreeGetCallbackReason(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeClear(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeClearChildren(Fl_Tree* tr, Fl_Tree_Item* item);
int            DLL_EXPORT Fl_TreeClose(Fl_Tree* tr, const char* path, int docallback=1);
int            DLL_EXPORT Fl_TreeCloseItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);
void           DLL_EXPORT Fl_TreeSetCloseIcon(Fl_Tree* tr, Fl_Image* ic);
Fl_Image*      DLL_EXPORT Fl_TreeGetCloseIcon(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetConnectorColor(Fl_Tree* tr, Fl_Color c);
Fl_Color       DLL_EXPORT Fl_TreeGetConnectorColor(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetConnectorStyle(Fl_Tree* tr, Fl_Tree_Connector s);
Fl_Tree_Connector DLL_EXPORT Fl_TreeGetConnectorStyle(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetConnectorWidth(Fl_Tree* tr, int w);
int            DLL_EXPORT Fl_TreeGetConnectorWidth(Fl_Tree* tr);
int            DLL_EXPORT Fl_TreeDeselect(Fl_Tree* tr, const char* path, int docallback=1);
int            DLL_EXPORT Fl_TreeDeselectItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);
int            DLL_EXPORT Fl_TreeDeselectAll(Fl_Tree* tr, Fl_Tree_Item* item=0, int docallback=1);
void           DLL_EXPORT Fl_TreeDisplay(Fl_Tree* tr, Fl_Tree_Item* item);
int            DLL_EXPORT Fl_TreeDisplayed(Fl_Tree* tr, Fl_Tree_Item* item);
const Fl_Tree_Item* DLL_EXPORT Fl_TreeFindClicked(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeFindItem(Fl_Tree* tr, const char* path);
const Fl_Tree_Item* DLL_EXPORT Fl_TreeFindItem2(Fl_Tree* tr, const char* path);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeFirst(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeFirstSelectedItem(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeFirstVisible(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeGetItemFocus(Fl_Tree* tr);
int            DLL_EXPORT Fl_TreeHandle(Fl_Tree* tr, int e);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeInsert(Fl_Tree* tr, Fl_Tree_Item* item, const char* name, int pos);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeInsertAbove(Fl_Tree* tr, Fl_Tree_Item* above, const char* name);
int            DLL_EXPORT Fl_TreeIsClose(Fl_Tree* tr, const char* path);
int            DLL_EXPORT Fl_TreeIsCloseItem(Fl_Tree* tr, Fl_Tree_Item* item);
int            DLL_EXPORT Fl_TreeIsOpen(Fl_Tree* tr, const char* path);
int            DLL_EXPORT Fl_TreeIsOpenItem(Fl_Tree* tr, Fl_Tree_Item* item);
int            DLL_EXPORT Fl_TreeIsScrollbar(Fl_Tree* tr, Fl_Widget* wgt);
int            DLL_EXPORT Fl_TreeIsSelected(Fl_Tree* tr, const char* path);
int            DLL_EXPORT Fl_TreeIsSelectedItem(Fl_Tree* tr, Fl_Tree_Item* item);
int            DLL_EXPORT Fl_TreeIsVScrollVisible(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeItemClicked(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetItemLabelBGColor(Fl_Tree* tr, Fl_Color c);
Fl_Color       DLL_EXPORT Fl_TreeGetItemLabelBGClor(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetItemLabelFGColor(Fl_Tree* tr, Fl_Color c);
Fl_Color       DLL_EXPORT Fl_TreeGetItemLabelFGColor(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetItemLabelFont(Fl_Tree* tr, Fl_Font f);
Fl_Font        DLL_EXPORT Fl_TreeGetItemLabelFont(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetItemLabelSize(Fl_Tree* tr, Fl_Fontsize s);
Fl_Fontsize    DLL_EXPORT Fl_TreeGetItemLabelSize(Fl_Tree* tr);
int            DLL_EXPORT Fl_TreeItemPathName(Fl_Tree* tr, char* pathname, int pathnamelen, const Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeSetLabelMarginLeft(Fl_Tree* tr, int m);
int            DLL_EXPORT Fl_TreeGetLabelMarginLeft(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeLast(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeLastVisible(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetLineSpacing(Fl_Tree* tr, int ls);
int            DLL_EXPORT Fl_TreeGetLineSpacing(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetMarginLeft(Fl_Tree* tr, int m);
int            DLL_EXPORT Fl_TreeGetMarginLeft(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetMarginTop(Fl_Tree* tr, int m);
int            DLL_EXPORT Fl_TreeGetMarginTop(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeNext(Fl_Tree* tr, Fl_Tree_Item* item=0);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeNextSelectedItem(Fl_Tree* tr, Fl_Tree_Item* item=0);
int            DLL_EXPORT Fl_TreeOpen(Fl_Tree* tr, const char* path, int docallback=1);
int            DLL_EXPORT Fl_TreeOpenItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);
void           DLL_EXPORT Fl_TreeOpenToggle(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);
void           DLL_EXPORT Fl_TreeSetOpenchildMarginBottom(Fl_Tree* tr, int m);
int            DLL_EXPORT Fl_TreeGetOpenchildMarginBottom(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeSetOpenIcon(Fl_Tree* tr, Fl_Image* ic);
Fl_Image*      DLL_EXPORT Fl_TreeGetOpenIcon(Fl_Tree* tr);
Fl_Tree_Item*  DLL_EXPORT Fl_TreePrev(Fl_Tree* tr, Fl_Tree_Item* item=0);
int            DLL_EXPORT Fl_TreeRemove(Fl_Tree* tr, Fl_Tree_Item* item);
Fl_Tree_Item*  DLL_EXPORT Fl_TreeRoot(Fl_Tree* tr);
void           DLL_EXPORT Fl_TreeRootLabel(Fl_Tree* tr, const char* new_label);

void           DLL_EXPORT Fl_TreeSetScrollbarSize(Fl_Tree* tr, int s);
int            DLL_EXPORT Fl_TreeGetScrollbarSize(Fl_Tree* tr);

int            DLL_EXPORT Fl_TreeSelect(Fl_Tree* tr, const char* path, int docallback=1);
int            DLL_EXPORT Fl_TreeSelectItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);
int            DLL_EXPORT Fl_TreeSelectAll(Fl_Tree* tr, Fl_Tree_Item* item=0, int docallback=1);
int            DLL_EXPORT Fl_TreeSelectOnly(Fl_Tree* tr, Fl_Tree_Item* selitem, int docallback=1);
void           DLL_EXPORT Fl_TreeSelectToggle(Fl_Tree* tr, Fl_Tree_Item* item, int docallback=1);

void           DLL_EXPORT Fl_TreeSetSelectBox(Fl_Tree* tr, Fl_Boxtype bt);
Fl_Boxtype     DLL_EXPORT Fl_TreeGetSelectBox(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetSelectMode(Fl_Tree* tr, Fl_Tree_Select m);
Fl_Tree_Select DLL_EXPORT Fl_TreeGetSelectMode(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetItemFocus(Fl_Tree* tr, Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeShowItem(Fl_Tree* tr, Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeShowItem2(Fl_Tree* tr, Fl_Tree_Item* item, int yoff);
void           DLL_EXPORT Fl_TreeShowItemBottom(Fl_Tree* tr, Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeShowItemMiddle(Fl_Tree* tr, Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeShowItemTop(Fl_Tree* tr, Fl_Tree_Item* item);
void           DLL_EXPORT Fl_TreeShowSelf(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetShowCollapse(Fl_Tree* tr, int c);
int            DLL_EXPORT Fl_TreeGetShowCollapse(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetShowRoot(Fl_Tree* tr, int r);
int            DLL_EXPORT Fl_TreeGetShowRoot(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetSortOrder(Fl_Tree* tr, Fl_Tree_Sort s);
Fl_Tree_Sort   DLL_EXPORT Fl_TreeGetSortorder(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetUserIcon(Fl_Tree* tr, Fl_Image* i);
Fl_Image*      DLL_EXPORT Fl_TreeGetUserIcon(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetUserIconMarginLeft(Fl_Tree* tr, int m);
int            DLL_EXPORT Fl_TreeGetUserIconMarginLeft(Fl_Tree* tr);

void           DLL_EXPORT Fl_TreeSetVPosition(Fl_Tree* tr, int p);
int            DLL_EXPORT Fl_TreeGetVPosition(Fl_Tree* tr);

// class Fl_Wizard extends Fl_Group
Fl_Wizard* DLL_EXPORT Fl_WizardNew(int x,int y,int w,int h,const char* title);
void       DLL_EXPORT Fl_WizardNext(Fl_Wizard* wi);
void       DLL_EXPORT Fl_WizardPrev(Fl_Wizard* wi);
void       DLL_EXPORT Fl_WizardSetValue(Fl_Wizard* wi, Fl_Widget* wgt);
Fl_Widget* DLL_EXPORT Fl_WizardGetValue(Fl_Wizard* wi);


// class Fl_Window extends Fl_Group
Fl_Window*  DLL_EXPORT Fl_WindowNew(int w,int h,const char* title);
Fl_Window*  DLL_EXPORT Fl_WindowNew2(int x,int y,int w,int h,const char* title);
void        DLL_EXPORT Fl_WindowBegin(Fl_Window* w);
void        DLL_EXPORT Fl_WindowEnd(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetBorder(Fl_Window* w,int b);
int         DLL_EXPORT Fl_WindowGetBorder(Fl_Window* w);

void        DLL_EXPORT Fl_WindowClearBorder(Fl_Window* w);

void        DLL_EXPORT Fl_WindowCopyLabel(Fl_Window* w, const char* new_label);

Fl_Window*  DLL_EXPORT Fl_WindowCurrent(Fl_Window* w);

void        DLL_EXPORT Fl_WindowCursor(Fl_Window* w, Fl_Cursor c,	Fl_Color fg, Fl_Color bg);

int         DLL_EXPORT Fl_WindowDecorated_h(Fl_Window* w);
int         DLL_EXPORT Fl_WindowDecorated_w(Fl_Window* w);

void        DLL_EXPORT Fl_WindowFreePosition(Fl_Window* w);

void        DLL_EXPORT Fl_WindowFullscreen(Fl_Window* w);
int         DLL_EXPORT Fl_WindowFullscreenActive(Fl_Window* w);
void        DLL_EXPORT Fl_WindowFullscreenOff(Fl_Window* w);
void        DLL_EXPORT Fl_WindowFullscreenOffResize(Fl_Window* w, int x, int y, int width, int height);

int         DLL_EXPORT Fl_WindowHandle(Fl_Window* w,int event);

void        DLL_EXPORT Fl_WindowHide(Fl_Window* w);

void        DLL_EXPORT Fl_WindowHotspot(Fl_Window* w, int x, int y, int offscreen);
void        DLL_EXPORT Fl_WindowHotspotWidget(Fl_Window* w, const Fl_Widget* wgt,int offscreen);

void        DLL_EXPORT Fl_WindowSetIcon(Fl_Window* w, const void* ic);
const void* DLL_EXPORT Fl_WindowGetIcon(Fl_Window* w);

void        DLL_EXPORT Fl_WindowIconize(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetIconLabel(Fl_Window* w, const char* il);
const char* DLL_EXPORT Fl_WindowGetIconLabel(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetLabel(Fl_Window* w, const char* wl);
const char* DLL_EXPORT Fl_WindowGetLabel(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetLabels(Fl_Window* w, const char* wl, const char* il);

void        DLL_EXPORT Fl_WindowMakeCurrent(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetModal(Fl_Window* w);
int         DLL_EXPORT Fl_WindowGetModal(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetNonModal(Fl_Window* w);
int         DLL_EXPORT Fl_WindowGetNonModal(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetOverride(Fl_Window* w);
int         DLL_EXPORT Fl_WindowGetOverride(Fl_Window* w);

void        DLL_EXPORT Fl_WindowResize(Fl_Window* w, int x, int y, int width, int height);

void        DLL_EXPORT Fl_WindowShow(Fl_Window* w);
void        DLL_EXPORT Fl_WindowShowArgs(Fl_Window* w,int argc,char** argv);

int         DLL_EXPORT Fl_WindowShown(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSizeRange(Fl_Window* w, int minw, int minh, int maxw, int maxh, int dw, int dh, int aspect);

void        DLL_EXPORT Fl_WindowSetTooltipWindow(Fl_Window* w);
int         DLL_EXPORT Fl_WindowGetTooltipWindow(Fl_Window* w);

void        DLL_EXPORT Fl_WindowSetXClass(Fl_Window* w, const char* xclass);
const char* DLL_EXPORT Fl_WindowGetXClass(Fl_Window* w);

int         DLL_EXPORT Fl_WindowXRoot(Fl_Window* w);
int         DLL_EXPORT Fl_WindowYRoot(Fl_Window* w);

// class Fl_Single_Window extends Fl_Window
Fl_Single_Window* DLL_EXPORT Fl_Single_WindowNew(int w, int h, const char *label=0);
Fl_Single_Window* DLL_EXPORT Fl_Single_WindowNew2(int x, int y, int w, int h, const char *label=0);
void              DLL_EXPORT Fl_Single_WindowFlush(Fl_Single_Window* sngwin);
void              DLL_EXPORT Fl_Single_WindowShow(Fl_Single_Window* sngbdblwin);
void              DLL_EXPORT Fl_Single_WindowShowArgs(Fl_Single_Window* sngwin, int argc, char **argv);

// class Fl_Menu_Window extends Fl_Single_Window
Fl_Menu_Window* DLL_EXPORT Fl_Menu_WindowNew(int w, int h, const char *label=0);
Fl_Menu_Window* DLL_EXPORT Fl_Menu_WindowNew2(int x, int y, int w, int h, const char *label=0);
void            DLL_EXPORT Fl_Menu_WindowClearOverlay(Fl_Menu_Window* mwin);
void            DLL_EXPORT Fl_Menu_WindowErase(Fl_Menu_Window* mwin);
void            DLL_EXPORT Fl_Menu_WindowFlush(Fl_Menu_Window* mwin);
void            DLL_EXPORT Fl_Menu_WindowHide(Fl_Menu_Window* mwin);
unsigned int    DLL_EXPORT Fl_Menu_WindowOverlay(Fl_Menu_Window* mwin);
void            DLL_EXPORT Fl_Menu_WindowSetOverlay(Fl_Menu_Window* mwin);
void            DLL_EXPORT Fl_Menu_WindowShow(Fl_Menu_Window* mwin);

// class Fl_Double_Window extends Fl_Window
Fl_Double_Window* DLL_EXPORT Fl_Double_WindowNew(int w, int h, const char *label=0);
Fl_Double_Window* DLL_EXPORT Fl_Double_WindowNew2(int x, int y, int w, int h, const char *label=0);
void              DLL_EXPORT Fl_Double_WindowFlush(Fl_Double_Window* dblwin);
void              DLL_EXPORT Fl_Double_WindowHide(Fl_Double_Window* dblwin);
void              DLL_EXPORT Fl_Double_WindowResize(Fl_Double_Window* dblwin, int x, int y, int w, int h);
void              DLL_EXPORT Fl_Double_WindowShow(Fl_Double_Window* dblwin);
void              DLL_EXPORT Fl_Double_WindowShowArgs(Fl_Double_Window* dblwin, int argc, char **argv);

// class Fl_Gl_Window extends Fl_Window
Fl_Gl_Window* DLL_EXPORT Fl_Gl_WindowNew(int w, int h, const char* title);
Fl_Gl_Window* DLL_EXPORT Fl_Gl_WindowNew2(int x, int y, int w, int h, const char* title);
int           DLL_EXPORT Fl_Gl_WindowCanDo(Fl_Gl_Window* win);
int           DLL_EXPORT Fl_Gl_WindowCanDoOverlay(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowSetContext(Fl_Gl_Window* win, void* ctx, int destroy_flag=0);
void*         DLL_EXPORT Fl_Gl_WindowGetContext(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowSetContextValid(Fl_Gl_Window* win, int v);
int           DLL_EXPORT Fl_Gl_WindowGetContextValid(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowFlush(Fl_Gl_Window* win);
int           DLL_EXPORT Fl_Gl_WindowHandle(Fl_Gl_Window* win, int ev);
void          DLL_EXPORT Fl_Gl_WindowHide(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowHideOverlay(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowInvalidate(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowMakeCurrent(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowMakeOverlayCurrent(Fl_Gl_Window* win);
int           DLL_EXPORT Fl_Gl_WindowSetMode(Fl_Gl_Window* win, Fl_Mode m);
Fl_Mode       DLL_EXPORT Fl_Gl_WindowGetMode(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowOrtho(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowRedrawOverlay(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowResize(Fl_Gl_Window* win, int x, int y, int w, int h);
void          DLL_EXPORT Fl_Gl_WindowShowArgs(Fl_Gl_Window* win, int argc, char** argv);
void          DLL_EXPORT Fl_Gl_WindowShow(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowSwapBuffers(Fl_Gl_Window* win);
void          DLL_EXPORT Fl_Gl_WindowSetValid(Fl_Gl_Window* win, int v);
int           DLL_EXPORT Fl_Gl_WindowGetValid(Fl_Gl_Window* win);


Fl_Printer* DLL_EXPORT Fl_PrinterNew(void);
void        DLL_EXPORT Fl_PrinterDelete(Fl_Printer* & p);
const char* DLL_EXPORT Fl_PrinterGetClassName(Fl_Printer* p);
Fl_Graphics_Driver* DLL_EXPORT Fl_PrinterGetDriver(Fl_Printer* p);

int         DLL_EXPORT Fl_PrinterStartJob(Fl_Printer* p,int pagecount, int * frompage, int * topage);
void        DLL_EXPORT Fl_PrinterEndJob(Fl_Printer* p);

int         DLL_EXPORT Fl_PrinterStartPage(Fl_Printer* p);
int         DLL_EXPORT Fl_PrinterEndPage(Fl_Printer* p);

void        DLL_EXPORT Fl_PrinterGetMargins(Fl_Printer* p,int & left, int & top, int & right, int & bottom);
void        DLL_EXPORT Fl_PrinterSetOrigin(Fl_Printer* p,int x, int y);
void        DLL_EXPORT Fl_PrinterGetOrigin(Fl_Printer* p,int *x, int *y);
void        DLL_EXPORT Fl_PrinterPrintWidget(Fl_Printer* p,Fl_Widget *widget, int delta_x, int delta_y);
void        DLL_EXPORT Fl_PrinterPrintWindow(Fl_Printer* p,Fl_Window *win, int x_offset, int y_offset);
void        DLL_EXPORT Fl_PrinterPrintWindowPart(Fl_Printer* p,Fl_Window *win, int x, int y, int w, int h, int delta_x, int delta_y);
int         DLL_EXPORT Fl_PrinterGetPrintableRect(Fl_Printer* p,int & w, int & h);
void        DLL_EXPORT Fl_PrinterRotate(Fl_Printer* p,float angle);
void        DLL_EXPORT Fl_PrinterScale(Fl_Printer* p,float scale_x, float scale_y);
void        DLL_EXPORT Fl_PrinterSetCurrent(Fl_Printer* p);
void        DLL_EXPORT Fl_PrinterTranslate(Fl_Printer* p,int x, int y);
void        DLL_EXPORT Fl_PrinterUntranslate(Fl_Printer* p);


#ifdef __cplusplus
}
#endif

#endif // __MAIN_H__
