#include "fltk-c.h"

/*
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // attach to process
            // return FALSE to fail DLL load
            break;

        case DLL_PROCESS_DETACH:
            // detach from process
            break;

        case DLL_THREAD_ATTACH:
            // attach to thread
            break;

        case DLL_THREAD_DETACH:
            // detach from thread
            break;
    }
    return TRUE; // succesful
}
*/

// utf8
int DLL_EXPORT Fl_utf8bytes(unsigned ucs){
  return fl_utf8bytes(ucs);
}
int DLL_EXPORT Fl_utf8len(char c){
  return fl_utf8len(c);
}
int DLL_EXPORT Fl_utf8len1(char c){
  return fl_utf8len1(c);
}
int DLL_EXPORT Fl_utf_nb_char(const unsigned char* buf, int len){
  return fl_utf_nb_char(buf, len);
}
unsigned DLL_EXPORT Fl_utf8decode(const char* p, const char* end, int* len){
  return fl_utf8decode(p, end, len);
}
int DLL_EXPORT Fl_utf8encode(unsigned ucs, char* buf){
  return fl_utf8encode(ucs,buf);
}
const char* DLL_EXPORT Fl_utf8fwd(const char* p, const char* start, const char* end){
  return fl_utf8fwd(p,start,end);
}
const char* DLL_EXPORT Fl_utf8back(const char* p, const char* start, const char* end){
  return fl_utf8back(p,start,end);
}
unsigned DLL_EXPORT Fl_ucs_to_Utf16(const unsigned ucs, unsigned short *dst, const unsigned dstlen){
  return fl_ucs_to_Utf16(ucs,dst,dstlen);
}
unsigned DLL_EXPORT Fl_utf8toUtf16(const char* src, unsigned srclen, unsigned short* dst, unsigned dstlen){
  return fl_utf8toUtf16(src, srclen, dst, dstlen);
}
unsigned DLL_EXPORT Fl_utf8towc(const char *src, unsigned srclen, wchar_t *dst, unsigned dstlen){
  return fl_utf8towc(src, srclen, dst, dstlen);
}
unsigned DLL_EXPORT Fl_utf8fromwc(char *dst, unsigned dstlen, const wchar_t *src, unsigned srclen){
  return fl_utf8fromwc(dst, dstlen, src, srclen);
}
unsigned DLL_EXPORT Fl_utf8toa (const char *src, unsigned srclen, char *dst, unsigned dstlen){
  return fl_utf8toa (src, srclen, dst, dstlen);
}
unsigned DLL_EXPORT Fl_utf8froma (char *dst, unsigned dstlen, const char *src, unsigned srclen){
  return fl_utf8froma (dst, dstlen, src, srclen);
}
int DLL_EXPORT Fl_utf8locale(){
  return fl_utf8locale();
}
int DLL_EXPORT Fl_utf8test(const char *src, unsigned len){
  return fl_utf8test(src,len);
}
int DLL_EXPORT Fl_wcwidth_(unsigned int ucs){
  return fl_wcwidth_(ucs);
}
int DLL_EXPORT Fl_wcwidth(const char *src){
  return fl_wcwidth(src);
}
unsigned int DLL_EXPORT Fl_nonspacing(unsigned int ucs){
  return fl_nonspacing(ucs);
}
unsigned DLL_EXPORT Fl_utf8to_mb(const char *src, unsigned srclen, char *dst, unsigned dstlen){
  return fl_utf8to_mb(src, srclen, dst, dstlen);
}
char* DLL_EXPORT Fl_utf2mbcs(const char *src){
  return fl_utf2mbcs(src);
}
unsigned DLL_EXPORT Fl_utf8from_mb(char *dst, unsigned dstlen, const char *src, unsigned srclen){
  return fl_utf8from_mb(dst, dstlen, src, srclen);
}
#ifdef WIN32
char* DLL_EXPORT Fl_utf8_to_locale(const char *s, int len, unsigned int codepage){
  return fl_utf8_to_locale(s,len,codepage);
}
char* DLL_EXPORT Fl_locale_to_utf8(const char *s, int len, unsigned int codepage){
  return fl_locale_to_utf8(s, len, codepage);
}
#endif
int DLL_EXPORT Fl_utf_strncasecmp(const char *s1, const char *s2, int n){
  return fl_utf_strncasecmp(s1, s2, n);
}
int DLL_EXPORT Fl_utf_strcasecmp(const char *s1, const char *s2){
  return fl_utf_strcasecmp(s1, s2);
}
int DLL_EXPORT Fl_tolower(unsigned int ucs){
  return fl_tolower(ucs);
}
int DLL_EXPORT Fl_toupper(unsigned int ucs){
  return fl_toupper(ucs);
}
int DLL_EXPORT Fl_utf_tolower(const unsigned char *str, int len, char *buf){
  return fl_utf_tolower(str, len, buf);
}
int DLL_EXPORT Fl_utf_toupper(const unsigned char *str, int len, char *buf){
  return fl_utf_toupper(str, len, buf);
}
int DLL_EXPORT Fl_chmod(const char* f, int mode){
  return fl_chmod(f, mode);
}
int DLL_EXPORT Fl_access(const char* f, int mode){
  return fl_access(f,mode);
}
int DLL_EXPORT Fl_stat( const char *path, struct stat *buffer){
  return fl_stat(path, buffer);
}
char* DLL_EXPORT Fl_getcwd( char *buf, int maxlen){
  return fl_getcwd(buf, maxlen);
}
FILE* DLL_EXPORT Fl_fopen(const char *f, const char *mode){
  return fl_fopen(f,mode);
}
int DLL_EXPORT Fl_system(const char* f){
  return fl_system(f);
}
int DLL_EXPORT Fl_execvp(const char* file, char* const* argv){
  return fl_execvp(file, argv);
}
int DLL_EXPORT Fl_open(const char* f, int o){
  return fl_open(f, o);
}
int DLL_EXPORT Fl_unlink(const char *f){
  return fl_unlink(f);
}
int DLL_EXPORT Fl_rmdir(const char *f){
  return fl_rmdir(f);
}
char* DLL_EXPORT Fl_getenv(const char *name){
  return fl_getenv(name);
}
int DLL_EXPORT Fl_mkdir(const char* f, int mode){
  return fl_mkdir(f,mode);
}
int DLL_EXPORT Fl_rename(const char* f, const char *t){
  return fl_rename(f,t);
}
void DLL_EXPORT Fl_make_path_for_file( const char *path){
  return fl_make_path_for_file(path);
}
char DLL_EXPORT Fl_make_path( const char *path){
  return fl_make_path(path);
}

void DLL_EXPORT flAlert(const char* msg){
  fl_alert("%s",msg);
}
int DLL_EXPORT flChoice(const char* msg,const char* b1,const char* b2,const char* b3){
  return fl_choice(msg,b1,b2,b3);
}
void DLL_EXPORT flBeep(int t){
  fl_beep(t);
}
int DLL_EXPORT flColorChooser(const char *name, uchar &r, uchar &g, uchar &b, int cmode){
  return fl_color_chooser(name, r, g, b, cmode);
}
int DLL_EXPORT flColorChooser2(const char *name, double &r, double &g, double &b, int cmode){
  return fl_color_chooser(name, r, g, b, cmode);
}
char* DLL_EXPORT flDirChooser(const char *message, const char *fname, int relative){
  return fl_dir_chooser(message, fname, relative);
}
char* DLL_EXPORT flFileChooser(const char *message, const char *pat, const char *fname, int relative){
  return fl_file_chooser(message, pat, fname, relative);
}
void DLL_EXPORT flFileChooserCallback(void(*cb)(const char* f)){
  fl_file_chooser_callback(cb);
}
void DLL_EXPORT flFileChooserOkLabel(const char* l){
  fl_file_chooser_ok_label(l);
}
const char* DLL_EXPORT flInput(const char* fmt, const char* defstr){
  return fl_input(fmt, defstr);
}
void DLL_EXPORT flMessage(const char* txt){
  fl_message(txt);
}
void DLL_EXPORT flMessageSetHotspot(int enable){
  fl_message_hotspot(enable);
}
int DLL_EXPORT flMessageGetHotspot(void){
  return fl_message_hotspot();
}
Fl_Widget* DLL_EXPORT flMessageIcon(){
  return fl_message_icon();
}
void DLL_EXPORT flMessageTitle(const char* title){
  fl_message_title(title);
}
void DLL_EXPORT flMessageTitleDefault(const char* title){
  fl_message_title_default(title);
}
const char* DLL_EXPORT flPassword(const char* fmt, const char* defstr){
  return fl_password(fmt, defstr);
}
// class Fl_File_Chooser
Fl_File_Chooser* DLL_EXPORT Fl_File_ChooserNew(const char* d, const char* p, int t, const char* title){
  return new Fl_File_Chooser(d,p,t,title);
}
Fl_Widget* DLL_EXPORT Fl_File_ChooserAddExtra(Fl_File_Chooser* fc, Fl_Widget* wgt){
  return fc->add_extra(wgt);
}
void DLL_EXPORT Fl_File_ChooserCallback(Fl_File_Chooser* fc, void(*cb)(Fl_File_Chooser *, void *), void *d){
  fc->callback(cb,d);
}
void DLL_EXPORT Fl_File_ChooserSetColor(Fl_File_Chooser* fc, Fl_Color c){
  fc->color(c);
}
Fl_Color DLL_EXPORT Fl_File_ChooserGetColor(Fl_File_Chooser* fc){
  return fc->color();
}
int DLL_EXPORT Fl_File_ChooserCount(Fl_File_Chooser* fc){
  return fc->count();
}
void DLL_EXPORT Fl_File_ChooserSetDirectory(Fl_File_Chooser* fc, const char* d){
  fc->directory(d);
}
char* DLL_EXPORT Fl_File_ChooserGetDirectory(Fl_File_Chooser* fc){
  return fc->directory();
}
void DLL_EXPORT Fl_File_ChooserSetFilter(Fl_File_Chooser* fc, const char* f){
  fc->filter(f);
}
const char* DLL_EXPORT Fl_File_ChooserGetFilter(Fl_File_Chooser* fc){
  return fc->filter();
}
void DLL_EXPORT Fl_File_ChooserSetFilterValue(Fl_File_Chooser* fc, int f){
  fc->filter_value(f);
}
int DLL_EXPORT Fl_File_ChooserGetFilterValue(Fl_File_Chooser* fc){
  return fc->filter_value();
}
void DLL_EXPORT Fl_File_ChooserHide(Fl_File_Chooser* fc){
  fc->hide();
}
void  DLL_EXPORT Fl_File_ChooserSetIconSize(Fl_File_Chooser* fc, uchar s){
  fc->iconsize(s);
}
uchar DLL_EXPORT Fl_File_ChooserGetIconSize(Fl_File_Chooser* fc){
  return fc->iconsize();
}
void DLL_EXPORT Fl_File_ChooserSetLabel(Fl_File_Chooser* fc, const char* l){
  fc->label(l);
}
const char* DLL_EXPORT Fl_File_ChooserGetLabel(Fl_File_Chooser* fc){
  return fc->label();
}
void DLL_EXPORT Fl_File_ChooserSetOkLabel(Fl_File_Chooser* fc, const char* l){
  fc->ok_label(l);
}
const char* DLL_EXPORT Fl_File_ChooserGetOkLabel(Fl_File_Chooser* fc){
  return fc->ok_label();
}
void DLL_EXPORT Fl_File_ChooserSetPreview(Fl_File_Chooser* fc, int e){
  fc->preview(e);
}
int DLL_EXPORT Fl_File_ChooserGetPreview(Fl_File_Chooser* fc){
  return fc->preview();
}
void DLL_EXPORT Fl_File_ChooserRescan(Fl_File_Chooser* fc){
  fc->rescan();
}
void DLL_EXPORT Fl_File_ChooserRescanKeepFilename(Fl_File_Chooser* fc){
  fc->rescan_keep_filename();
}
void DLL_EXPORT Fl_File_ChooserShow(Fl_File_Chooser* fc){
  fc->show();
}
int DLL_EXPORT Fl_File_ChooserShown(Fl_File_Chooser* fc){
  return fc->shown();
}
void DLL_EXPORT Fl_File_ChooserSetTextColor(Fl_File_Chooser* fc, Fl_Color c){
  fc->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_File_ChooserGetTextColor(Fl_File_Chooser* fc){
  return fc->textcolor();
}
void DLL_EXPORT Fl_File_ChooserSetTextFont(Fl_File_Chooser* fc, Fl_Font f){
  fc->textfont(f);
}
Fl_Font DLL_EXPORT Fl_File_ChooserGetTextFont(Fl_File_Chooser* fc){
  return fc->textfont();
}
void DLL_EXPORT Fl_File_ChooserSetTextSize(Fl_File_Chooser* fc, Fl_Fontsize s){
  fc->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_File_ChooserGetTextSize(Fl_File_Chooser* fc){
  return fc->textsize();
}
void DLL_EXPORT Fl_File_ChooserSetType(Fl_File_Chooser* fc, int t){
  fc->type(t);
}
int DLL_EXPORT Fl_File_ChooserGetType(Fl_File_Chooser* fc){
  return fc->type();
}
void DLL_EXPORT Fl_File_ChooserSetUserData(Fl_File_Chooser* fc, void* d){
  fc->user_data(d);
}
void* DLL_EXPORT Fl_File_ChooserGetUserData(Fl_File_Chooser* fc){
 return fc->user_data();
}
void DLL_EXPORT Fl_File_ChooserSetValue(Fl_File_Chooser* fc, const char* filename){
  fc->value(filename);
}
const char* DLL_EXPORT Fl_File_ChooserGetValue(Fl_File_Chooser* fc, int f){
  return fc->value(f);
}
int DLL_EXPORT Fl_File_ChooserVisible(Fl_File_Chooser* fc){
  return fc->visible();
}
Fl_Button* DLL_EXPORT Fl_File_ChooserNewButton(Fl_File_Chooser* fc){
  return fc->newButton;
}
Fl_Check_Button* DLL_EXPORT Fl_File_ChooserPreviewButton(Fl_File_Chooser* fc){
  return fc->previewButton;
}
Fl_Check_Button* DLL_EXPORT Fl_File_ChooserShowHiddenButton(Fl_File_Chooser* fc){
  return fc->showHiddenButton;
}

// FLTK drawing
void DLL_EXPORT DrawSetColor(Fl_Color c){
  fl_color(c);
}
void DLL_EXPORT DrawSetRGBColor(uchar r, uchar g, uchar b){
  fl_color(r, g, b);
}
Fl_Color DLL_EXPORT DrawGetColor(){
  return fl_color();
}
void DLL_EXPORT DrawPushClip(int x, int y, int w, int h){
  fl_push_clip(x,y,w,h);
}
void DLL_EXPORT DrawPushNoClip(){
 fl_push_no_clip();
}
void DLL_EXPORT DrawPopClip(){
 fl_pop_clip();
}
int DLL_EXPORT DrawNotClipped(int x, int y, int w, int h){
  return fl_not_clipped(x, y, w, h);
}
int DLL_EXPORT DrawClipBox(int x , int y, int w, int h, int& retx, int& rety, int& retw, int& reth){
  return fl_clip_box(x,y,w,h,retx,rety,retw,reth);
}

void DLL_EXPORT DrawSetLineStyle(int style, int width, char* dashes){
  fl_line_style(style, width, dashes);
}

void DLL_EXPORT DrawRestoreClip(){
  fl_restore_clip();
}
void DLL_EXPORT DrawRect(int x, int y, int w, int h){
  fl_rect(x, y, w, h);
}
void DLL_EXPORT DrawRectColor(int x, int y, int w, int h,Fl_Color c){
  fl_rect(x, y, w, h, c);
}
void DLL_EXPORT DrawRectFill(int x, int y, int w, int h){
  fl_rectf(x, y, w, h);
}
void DLL_EXPORT DrawRectFillColor(int x, int y, int w, int h,Fl_Color c){
  fl_rectf(x, y, w, h, c);
}
void DLL_EXPORT DrawRectFillRGBColor(int x, int y, int w, int h, uchar r, uchar g, uchar b){
  fl_rectf(x,y,w,h, r,g,b);
}

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

void DLL_EXPORT DrawPoint(int x, int y){
  fl_point(x,y);
}
void DLL_EXPORT DrawLine(int x, int y, int x1, int y1){
  fl_line(x,y,x1,y1);
}
void DLL_EXPORT DrawLine2(int x, int y, int x1, int y1, int x2, int y2){
  fl_line(x,y,x1,y1,x2,y2);
}
void DLL_EXPORT DrawLoop(int x, int y, int x1, int y1, int x2, int y2){
  fl_loop(x,y, x1,y1, x2,y2);
}
void DLL_EXPORT DrawLoop2(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3){
  fl_loop(x,y, x1,y1, x2,y2, x3,y3);
}
void DLL_EXPORT DrawPolygon(int x, int y, int x1, int y1, int x2, int y2){
  fl_polygon(x,y, x1,y1, x2,y2);
}
void DLL_EXPORT DrawPolygon2(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3){
  fl_polygon(x,y, x1,y1, x2,y2, x3,y3);
}
void DLL_EXPORT DrawXYLine(int x, int y, int x1){
  fl_xyline(x,y, x1);
}
void DLL_EXPORT DrawXYLine2(int x, int y, int x1, int y1){
  fl_xyline(x,y, x1,y1);
}
void DLL_EXPORT DrawXYLine3(int x, int y, int x1, int y1, int x2){
  fl_xyline(x,y, x1,y1, x2);
}
void DLL_EXPORT DrawYXLine(int x, int y, int y1){
  fl_yxline(x,y, y1);
}
void DLL_EXPORT DrawYXLine2(int x, int y, int y1, int x2){
  fl_yxline(x,y, y1,x2);
}
void DLL_EXPORT DrawYXLine3(int x, int y, int y1, int x2, int y2){
  fl_yxline(x,y, y1,x2, y2);
}
void DLL_EXPORT DrawArc(int x, int y, int w, int h, double a1, double a2){
  fl_arc(x,y,w,h, a1,a2);
}
void DLL_EXPORT DrawArc2(double x, double y, double r, double start, double end){
  fl_arc(x,y,r,start,end);
}
void DLL_EXPORT DrawCircle(double x, double y, double r){
  fl_circle(x,y,r);
}
void DLL_EXPORT DrawCurve(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3){
  fl_curve(x0,y0, x1,y1, x2,y2, x3,y3);
}
void DLL_EXPORT DrawPie(int x, int y, int w, int h, double a1, double a2){
  fl_pie(x,y,w,h, a1,a2);
}

void DLL_EXPORT DrawPushMatrix(){
  fl_push_matrix();
}
void DLL_EXPORT DrawPopMatrix(){
  fl_pop_matrix();
}

void DLL_EXPORT DrawScale(double s){
  fl_scale(s);
}
void DLL_EXPORT DrawScaleXY(double sx, double sy){
  fl_scale(sx,sy);
}

void DLL_EXPORT DrawRotate(double r){
  fl_rotate(r);
}
void DLL_EXPORT DrawTranslate(double tx, double ty){
  fl_translate(tx,ty);
}

void DLL_EXPORT DrawMultMatrix(double a, double b, double c, double d, double x,double y){
  fl_mult_matrix(a,b,c,d,x,y);
}

void DLL_EXPORT DrawBeginPoints(){
  fl_begin_points();
}
void DLL_EXPORT DrawEndPoints(){
  fl_end_points();
}
void DLL_EXPORT DrawBeginLine(){
  fl_begin_line();
}
void DLL_EXPORT DrawEndLine(){
  fl_end_line();
}
void DLL_EXPORT DrawBeginLoop(){
  fl_begin_loop();
}
void DLL_EXPORT DrawEndLoop(){
  fl_end_loop();
}
void DLL_EXPORT DrawBeginPolygon(){
  fl_begin_polygon();
}
void DLL_EXPORT DrawEndPolygon(){
  fl_end_polygon();
}
void DLL_EXPORT DrawBeginComplexPolygon(){
  fl_begin_complex_polygon();
}
void DLL_EXPORT DrawEndComplexPolygon(){
  fl_end_complex_polygon();
}
void DLL_EXPORT DrawVertex(double x, double y){
  fl_vertex(x,y);
}

double DLL_EXPORT DrawTransformX(double x, double y){
  return fl_transform_x(x,y);
}
double DLL_EXPORT DrawTransformY(double x, double y){
  return fl_transform_y(x,y);
}
double DLL_EXPORT DrawTransformDX(double x, double y){
  return fl_transform_dx(x,y);
}
double DLL_EXPORT DrawTransformDY(double x, double y){
  return fl_transform_dy(x,y);
}
void DLL_EXPORT DrawTransformedVertex(double xf, double yf){
  fl_transformed_vertex(xf,yf);
}

void DLL_EXPORT DrawSetFont(Fl_Font face, Fl_Fontsize fsize){
  fl_font(face,fsize);
}
Fl_Font DLL_EXPORT DrawGetFont(){
  return fl_font();
}
Fl_Fontsize DLL_EXPORT DrawGetFontSize(){
  return fl_size();
}
int DLL_EXPORT DrawGetFontHeight(){
  return fl_height();
}
int DLL_EXPORT DrawGetFontDescent(){
  return fl_descent();
}
int DLL_EXPORT DrawGetStrWidth(const char* txt){
  return fl_width(txt);
}
int DLL_EXPORT DrawGetStrWidth2(const char* txt, int nchars){
  return fl_width(txt,nchars);
}
int DLL_EXPORT DrawGetCharWidth(unsigned int c){
  return fl_width(c);
}
void DLL_EXPORT DrawStrExtents(const char* txt, int& dx, int& dy, int& w, int& h){
  fl_text_extents(txt,dx,dy,w,h);
}
void DLL_EXPORT DrawStrExtents2(const char* txt, int n, int& dx, int& dy, int& w, int& h){
  fl_text_extents(txt,n,dx,dy,w,h);
}
void DLL_EXPORT DrawStrMeasure(const char* txt, int& x, int& y, int draw_symbols){
  fl_measure(txt,x,y,draw_symbols);
}
void DLL_EXPORT DrawStr(const char* txt, int x, int y){
  fl_draw(txt,x,y);
}
void DLL_EXPORT DrawStr2(const char* txt, int nchars, int x, int y){
  fl_draw(txt,nchars,x,y);
}
void DLL_EXPORT DrawStrRightToLeft(const char* txt, int n, int x, int y){
  fl_rtl_draw(txt,n,x,y);
}
void DLL_EXPORT DrawStrRot(int angle, const char* txt, int x, int y){
  fl_draw(angle,txt,x,y);
}
void DLL_EXPORT DrawStrRot2(int angle, const char* txt, int nchars, int x, int y){
  fl_draw(angle,txt,nchars,x,y);
}
void DLL_EXPORT DrawStrBox(const char* str, int x, int y, int w, int h, Fl_Align align, Fl_Image* img, int draw_symbols){
   fl_draw(str,x,y,w,h,align,img,draw_symbols);
}

const char* DLL_EXPORT DrawLatin1ToLocal(const char* txt, int n){
  return fl_latin1_to_local(txt,n);
}
const char* DLL_EXPORT DrawLocalToLatin1(const char* txt, int n){
  return fl_local_to_latin1(txt,n);
}

void DLL_EXPORT DrawImage(const uchar* buf, int x,int y,int w,int h, int d, int l){
  fl_draw_image(buf,x,y,w,h,d,l);
}
void DLL_EXPORT DrawImageMono(const uchar* buf, int x,int y,int w,int h, int d, int l){
  fl_draw_image_mono(buf,x,y,w,h,d,l);
}

void DLL_EXPORT DrawImageCallback(Fl_Draw_Image_Cb cb,void *data,int x,int y,int w,int h,int d){
  fl_draw_image(cb,data,x,y,w,h,d);
}
void DLL_EXPORT DrawImageMonoCallback(Fl_Draw_Image_Cb cb,void *data,int x,int y,int w,int h,int d){
  fl_draw_image_mono(cb,data,x,y,w,h,d);
}

uchar* DLL_EXPORT DrawReadImage(uchar* p,int x,int y,int w,int h,int alpha){
  return fl_read_image(p,x,y,w,h,alpha);
}

int DLL_EXPORT DrawPixmap(char* const* data, int x,int y,Fl_Color c){
  return fl_draw_pixmap(data,x,y,c);
}
int DLL_EXPORT DrawPixmap2(const char* const* cdata, int x,int y,Fl_Color c){
  return fl_draw_pixmap(cdata,x,y,c);
}
int DLL_EXPORT DrawMeasurePixmap(char* const* data, int &w, int &h){
  return fl_measure_pixmap(data,w,h);
}
int DLL_EXPORT DrawMeasurePixmap2(const char* const* cdata, int &w, int &h){
  return fl_measure_pixmap(cdata,w,h);
}
#if 0
// Fl_Offscreen
Fl_Offscreen DLL_EXPORT Fl_Create_Offscreen(int w, int h) {
  return fl_create_offscreen(w,h);
}
void DLL_EXPORT Fl_Begin_Offscreen(Fl_Offscreen o){
  fl_begin_offscreen(o);
}
void DLL_EXPORT Fl_End_Offscreen(void){
  fl_end_offscreen();

}
void DLL_EXPORT Fl_Copy_Offscreen(int x,int y,int w,int h,Fl_Offscreen o,int srcx,int srcy){
  fl_copy_offscreen(x,y,w,h,o,srcx,srcy);
}
#endif

// static Fl class
void DLL_EXPORT Fl_AddCheck(Fl_Timeout_Handler h, void* data){
  Fl::add_check(h,data);
}
void DLL_EXPORT Fl_AddHandler(Fl_Event_Handler h) {
  Fl::add_handler(h);
}
void DLL_EXPORT Fl_AddIdle(Fl_Idle_Handler h, void* data) {
  Fl::add_idle(h,data);
}
void DLL_EXPORT Fl_AddTimeout(double t, Fl_Timeout_Handler h, void* data){
  Fl::add_timeout(t,h,data);
}
void DLL_EXPORT Fl_Awake (void *message){
  Fl::awake(message);
}
int DLL_EXPORT Fl_Awake2(Fl_Awake_Handler h, void* message){
  return Fl::awake(h,message);
}
void DLL_EXPORT Fl_Background (uchar r, uchar g, uchar b){
  Fl::background(r,g,b);
}
void DLL_EXPORT Fl_Background2(uchar r, uchar g, uchar b){
  Fl::background2(r,g,b);
}
void DLL_EXPORT Fl_SetBelowmouse(Fl_Widget* wgt){
  Fl::belowmouse(wgt);
}
Fl_Widget* DLL_EXPORT Fl_GetBelowmouse(){
  return Fl::belowmouse();
}
int DLL_EXPORT Fl_BoxDH(Fl_Boxtype bt){
  return Fl::box_dh(bt);
}
int DLL_EXPORT Fl_BoxDW(Fl_Boxtype bt){
  return Fl::box_dw(bt);
}
int DLL_EXPORT Fl_BoxDX(Fl_Boxtype bt){
  return Fl::box_dx(bt);
}
int DLL_EXPORT Fl_BoxDY(Fl_Boxtype bt){
  return Fl::box_dy(bt);
}

int DLL_EXPORT Fl_Check(){
  return Fl::check();
}
void DLL_EXPORT Fl_ClearWidgetPointer(Fl_Widget const *w){
  Fl::clear_widget_pointer(w);
}
int DLL_EXPORT Fl_Compose(int &del){
  return Fl::compose(del);
}
void DLL_EXPORT Fl_Compose_Reset(){
  Fl::compose_reset();
}
void DLL_EXPORT Fl_Copy(const char *stuff, int len, int destination){
  Fl::copy(stuff,len,destination);
}
void DLL_EXPORT Fl_SetDamage(int d){
  Fl::damage(d);
}
int DLL_EXPORT Fl_GetDamage(){
  return Fl::damage();
}
void DLL_EXPORT Fl_DefaultAtclose(Fl_Window* win, void* p){
  Fl::default_atclose(win,p);
}
void DLL_EXPORT Fl_DeleteWidget(Fl_Widget* wgt){
  Fl::delete_widget(wgt);
}
void DLL_EXPORT Fl_Display(const char* display){
  Fl::display(display);
}
int DLL_EXPORT Fl_Dnd(){
  return Fl::dnd();
}
void DLL_EXPORT Fl_SetDndTextOps(int v){
  Fl::dnd_text_ops(v);
}
int DLL_EXPORT Fl_GetDndTextOps(){
  return Fl::dnd_text_ops();
}
void DLL_EXPORT Fl_DoWidgetDeletion(){
  Fl::do_widget_deletion();
}
int DLL_EXPORT Fl_DrawBoxActive(){
  return Fl::draw_box_active();
}
int DLL_EXPORT Fl_EventNumber(){
  return Fl::event();
}
int DLL_EXPORT Fl_EventAlt(){
  return Fl::event_alt();
}
int DLL_EXPORT Fl_EventButton(){
  return Fl::event_button();
}
int DLL_EXPORT Fl_EventButton1(){
  return Fl::event_button1();
}
int DLL_EXPORT Fl_EventButton2(){
  return Fl::event_button2();
}
int DLL_EXPORT Fl_EventButton3(){
  return Fl::event_button3();
}
int DLL_EXPORT Fl_EventButtons(){
  return Fl::event_buttons();
}
void DLL_EXPORT Fl_SetEventClicks(int i){
  Fl::event_clicks(i);
}
int DLL_EXPORT Fl_GetEventClicks(){
  return Fl::event_clicks();
}
int DLL_EXPORT Fl_EventCommand(){
  return Fl::event_command();
}
int DLL_EXPORT Fl_EventCtrl(){
  return Fl::event_ctrl();
}
void DLL_EXPORT Fl_SetEventDispatch(Fl_Event_Dispatch d){
  Fl::event_dispatch(d);
}
Fl_Event_Dispatch DLL_EXPORT Fl_GetEventDispatch(){
  return Fl::event_dispatch();
}
int DLL_EXPORT Fl_EventDY(){
  return Fl::event_dy();
}
int DLL_EXPORT Fl_EventDX(){
  return Fl::event_dx();
}
int DLL_EXPORT Fl_EventInside (const Fl_Widget* w){
  return Fl::event_inside(w);
}
int DLL_EXPORT Fl_EventInside2(int x, int y, int w, int h){
  return Fl::event_inside(x,y,w,h);
}
void DLL_EXPORT Fl_SetEventIsClick(int i){
  Fl::event_is_click(i);
}
int DLL_EXPORT Fl_GetEventIsClick(){
  return Fl::event_is_click();
}
int DLL_EXPORT Fl_EventKey(){
  return Fl::event_key();
}
int DLL_EXPORT Fl_EventKey2(int key){
  return Fl::event_key(key);
}
int DLL_EXPORT Fl_EventLength(){
  return Fl::event_length();
}
int DLL_EXPORT Fl_EventOriginalKey(){
  return Fl::event_original_key();
}
int DLL_EXPORT Fl_EventShift(){
  return Fl::event_shift();
}
int DLL_EXPORT Fl_EventState(){
  return Fl::event_state();
}
int DLL_EXPORT Fl_EventState2(int i){
  return Fl::event_state(i);
}
const char* DLL_EXPORT Fl_EventText(){
  return Fl::event_text();
}
int DLL_EXPORT Fl_EventX(){
  return Fl::event_x();
}
int DLL_EXPORT Fl_EventXRoot(){
  return Fl::event_x_root();
}
int DLL_EXPORT Fl_EventY(){
  return Fl::event_y();
}
int DLL_EXPORT Fl_EventYRoot(){
  return Fl::event_y_root();
}
Fl_Window* DLL_EXPORT Fl_GetFirstWindow(){
  return Fl::first_window();
}
void DLL_EXPORT Fl_SetFirstWindow(Fl_Window* win){
  Fl::first_window(win);
}
void DLL_EXPORT Fl_Flush(){
  Fl::flush();
}
Fl_Widget* DLL_EXPORT Fl_GetFocus(){
  return Fl::focus();
}
void DLL_EXPORT Fl_SetFocus(Fl_Widget* wgt){
  Fl::focus(wgt);
}
void DLL_EXPORT Fl_Foreground(uchar r, uchar g, uchar b){
  Fl::foreground(r,g,b);
}
void DLL_EXPORT Fl_FreeColor (Fl_Color i, int overlay){
  Fl::free_color(i,overlay);
}
int DLL_EXPORT Fl_GetAwakeHandler_(Fl_Awake_Handler &h, void* &data){
  return Fl::get_awake_handler_(h,data);
}
Fl_Box_Draw_F* DLL_EXPORT Fl_GetBoxType(Fl_Boxtype bt){
  return Fl::get_boxtype(bt);
}
void DLL_EXPORT Fl_GetColor(Fl_Color i, uchar &r, uchar &g, uchar &b){
  Fl::get_color(i,r,g,b);
}
unsigned DLL_EXPORT Fl_GetColor2(Fl_Color i){
  return Fl::get_color(i);
}
const char* DLL_EXPORT Fl_GetFont(Fl_Font f){
  return Fl::get_font(f);
}
const char* DLL_EXPORT Fl_GetFontName(Fl_Font f, int *attributes){
  return Fl::get_font_name(f,attributes);
}
int DLL_EXPORT Fl_GeFontSizes (Fl_Font f, int *&sizep){
  return Fl::get_font_sizes(f,sizep);
}
int DLL_EXPORT Fl_GetKey(int key){
  return Fl::get_key(key);
}
void DLL_EXPORT Fl_GetMouse (int &x, int &y){
  Fl::get_mouse(x,y);
}
void DLL_EXPORT Fl_GetSystemColors(){
  Fl::get_system_colors();
}

void DLL_EXPORT Fl_SetGrab(Fl_Window* win){
  Fl::grab(win);
}
Fl_Window* DLL_EXPORT Fl_GetGrab(){
  return Fl::grab();
}
int DLL_EXPORT Fl_GetH(){
  return Fl::h();
}
int DLL_EXPORT Fl_Handle(int ev, Fl_Window* w){
  return Fl::handle(ev,w);
}
int DLL_EXPORT Fl_Handle_(int ev, Fl_Window* w){
  return Fl::handle_(ev,w);
}
int DLL_EXPORT Fl_HasCheck(Fl_Timeout_Handler h, void* data){
  return Fl::has_check(h,data);
}
int DLL_EXPORT Fl_HasIdle(Fl_Idle_Handler h, void* data){
  return Fl::has_idle(h,data);
}
int DLL_EXPORT Fl_HasTimeout(Fl_Timeout_Handler h, void* data){
  return Fl::has_timeout(h,data);
}
int DLL_EXPORT Fl_Lock(){
  return Fl::lock();
}
Fl_Window* DLL_EXPORT Fl_Modal(){
  return Fl::modal();
}
Fl_Window* DLL_EXPORT Fl_NextWindow (const Fl_Window* win){
  return Fl::next_window(win);
}
int DLL_EXPORT Fl_GetOption(Fl::Fl_Option opt){
  return Fl::option(opt);
}
void DLL_EXPORT Fl_SetOption(Fl::Fl_Option opt, int val){
  Fl::option(opt,val);
}
void DLL_EXPORT Fl_OwnColormap(){
  Fl::own_colormap();
}
void DLL_EXPORT Fl_Paste(Fl_Widget &receiver){
  Fl::paste(receiver);
}
void DLL_EXPORT Fl_Paste2(Fl_Widget &receiver, int source){
  Fl::paste(receiver,source);
}
Fl_Widget* DLL_EXPORT Fl_GetPushed(){
  return Fl::pushed();
}
void DLL_EXPORT Fl_SetPushed(Fl_Widget* wgt){
  Fl::pushed(wgt);
}
Fl_Widget* DLL_EXPORT Fl_ReadQueue(){
  return Fl::readqueue();
}
int DLL_EXPORT Fl_Ready(){
  return Fl::ready();
}
void DLL_EXPORT Fl_Redraw(){
  Fl::redraw();
}
void DLL_EXPORT Fl_Release(){
  Fl::release();
}
void DLL_EXPORT Fl_ReleaseWidgetPointer(Fl_Widget* &wgt){
  Fl::release_widget_pointer(wgt);
}
int DLL_EXPORT Fl_ReloadScheme(){
  return Fl::reload_scheme();
}
void DLL_EXPORT Fl_RemoveCheck (Fl_Timeout_Handler h, void* data){
  Fl::remove_check(h,data);
}
void DLL_EXPORT Fl_RemoveFD(int fd){
  Fl::remove_fd(fd);
}
void DLL_EXPORT Fl_RemoveFD2(int fd, int when){
  Fl::remove_fd(fd,when);
}
void DLL_EXPORT Fl_RemoveHandler (Fl_Event_Handler h){
  Fl::remove_handler(h);
}
void DLL_EXPORT Fl_RemoveIdle (Fl_Idle_Handler h, void* data){
  Fl::remove_idle(h,data);
}
void DLL_EXPORT Fl_RemoveTimeout(Fl_Timeout_Handler h, void* data){
  Fl::remove_timeout(h,data);
}
void DLL_EXPORT Fl_RepeatTimeout(double t, Fl_Timeout_Handler h, void* data){
  Fl::repeat_timeout(t,h,data);
}
int DLL_EXPORT Fl_Run(){
  return Fl::run();
}
const char* DLL_EXPORT Fl_GetScheme(){
  return Fl::scheme();
}
int DLL_EXPORT Fl_SetScheme (const char* scheme){
  return Fl::scheme(scheme);
}
int DLL_EXPORT Fl_ScreenCount(){
  return Fl::screen_count();
}
void DLL_EXPORT Fl_ScreenDpi(float &h, float &v, int n){
  Fl::screen_dpi(h,v,n);
}
void DLL_EXPORT Fl_ScreenWorkAreaXYWH(int &X, int &Y, int &W, int &H){
  Fl::screen_work_area(X,Y,W,H);
}
void DLL_EXPORT Fl_ScreenWorkAreaXYWHN(int &X, int &Y, int &W, int &H, int n){
  Fl::screen_work_area(X,Y,W,H,n);
}
void DLL_EXPORT Fl_ScreenWorkAreaXYWHMXMY(int &X, int &Y, int &W, int &H, int mx, int my){
  Fl::screen_work_area(X,Y,W,H,mx,my);
}
void DLL_EXPORT Fl_ScreenXYWH(int &X, int &Y, int &W, int &H){
  Fl::screen_xywh(X,Y,W,H);
}
void DLL_EXPORT Fl_ScreenXYWHN (int &X, int &Y, int &W, int &H, int n){
  Fl::screen_xywh(X,Y,W,H,n);
}
void DLL_EXPORT Fl_ScreenXYWHMXMY(int &X, int &Y, int &W, int &H, int mx, int my){
  Fl::screen_xywh(X,Y,W,H,mx,my);
}
void DLL_EXPORT Fl_ScreenXYWHMXMYMWMH(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh){
  Fl::screen_xywh(X,Y,W,H,mx,my,mw,mh);
}
void DLL_EXPORT Fl_SetScrollbarSize(int size){
  Fl::scrollbar_size(size);
}
int DLL_EXPORT Fl_GetScrollbarSize(){
  return Fl::scrollbar_size();
}
void DLL_EXPORT Fl_Selection(Fl_Widget &owner, const char* t, int len){
  Fl::selection(owner,t,len);
}
void DLL_EXPORT Fl_SetSelectionOwner(Fl_Widget* wgt){
  Fl::selection_owner(wgt);
}
Fl_Widget* DLL_EXPORT Fl_GetSelectionOwner(){
  return Fl::selection_owner();
}
void DLL_EXPORT Fl_SetAbort(Fl_Abort_Handler h){
  Fl::set_abort(h);
}
void DLL_EXPORT Fl_SetAtclose(Fl_Atclose_Handler h){
  Fl::set_atclose(h);
}
void DLL_EXPORT Fl_SetBoxType(Fl_Boxtype bt, Fl_Boxtype from){
  Fl::set_boxtype(bt,from);
}
void DLL_EXPORT Fl_SetBoxType2(Fl_Boxtype bt, Fl_Box_Draw_F* f, uchar a, uchar b, uchar c, uchar d){
  Fl::set_boxtype(bt,f,a,b,c,d);
}
void DLL_EXPORT Fl_SetColor (Fl_Color n, unsigned c){
  Fl::set_color(n,c);
}
void DLL_EXPORT Fl_SetColor2(Fl_Color n, uchar r, uchar g, uchar b){
  Fl::set_color(n,r,g,b);
}
void DLL_EXPORT Fl_SetFont(Fl_Font f, const char* n){
  Fl::set_font(f,n);
}
void DLL_EXPORT Fl_SetFont2(Fl_Font f, Fl_Font n){
  Fl::set_font(f,n);
}
Fl_Font DLL_EXPORT Fl_SetFonts(const char* n){
  return Fl::set_fonts(n);
}
void DLL_EXPORT Fl_SetIdle (Fl_Old_Idle_Handler h){
  Fl::set_idle(h);
}
void DLL_EXPORT Fl_SetLabeltype(Fl_Labeltype lt, Fl_Label_Draw_F* df, Fl_Label_Measure_F* mf){
  Fl::set_labeltype(lt,df,mf);
}

int DLL_EXPORT Fl_TestShortcut(Fl_Shortcut s){
  return Fl::test_shortcut(s);
}
void* DLL_EXPORT Fl_ThreadMessage(){
  return Fl::thread_message();
}
void DLL_EXPORT Fl_Unlock(){
  Fl::unlock();
}
double DLL_EXPORT Fl_Version(){
  return Fl::version();
}
void DLL_EXPORT Fl_SetVisibleFocus(int v){
  Fl::visible_focus(v);
}
int DLL_EXPORT Fl_GetVisibleFocus(){
  return Fl::visible_focus();
}
int DLL_EXPORT Fl_Visual(int v){
  return Fl::visual(v);
}
int DLL_EXPORT Fl_GetW(){
  return Fl::w();
}
int DLL_EXPORT Fl_Wait(){
  return Fl::wait();
}
double DLL_EXPORT Fl_Wait2(double time){
  return Fl::wait(time);
}
void DLL_EXPORT Fl_WatchWidgetPointer(Fl_Widget* &wgt){
  Fl::watch_widget_pointer(wgt);
}
int DLL_EXPORT Fl_GetX(){
  return Fl::x();
}
int DLL_EXPORT Fl_GetY(){
  return Fl::y();
}


// class Fl_Shared_Image extends Fl_Image

void DLL_EXPORT Fl_Register_Images(){
  fl_register_images();
}
void DLL_EXPORT Fl_Shared_ImageColorAverage(Fl_Shared_Image* si, Fl_Color c, float i){
  si->color_average(c,i);
}
Fl_Image* DLL_EXPORT Fl_Shared_ImageCopy(Fl_Shared_Image* si){
  return si->copy();
}
Fl_Image* DLL_EXPORT Fl_Shared_ImageCopy2(Fl_Shared_Image* si, int w, int h){
  return si->copy(w,h);
}
void DLL_EXPORT Fl_Shared_ImageDesaturate(Fl_Shared_Image* si){
  si->desaturate();
}
void DLL_EXPORT Fl_Shared_ImageDraw(Fl_Shared_Image* si, int x, int y){
  si->draw(x,y);
}
void DLL_EXPORT Fl_Shared_ImageDraw2(Fl_Shared_Image* si, int x, int y, int w, int h, int cx, int cy){
  si->draw(x,y,w,h,cx,cy);
}
const char* DLL_EXPORT Fl_Shared_ImageName(Fl_Shared_Image* si){
  return si->name();
}
int DLL_EXPORT Fl_Shared_ImageRefcount(Fl_Shared_Image* si){
  return si->refcount();
}
void DLL_EXPORT Fl_Shared_ImageRelease(Fl_Shared_Image* si){
  si->release();
}
void DLL_EXPORT Fl_Shared_ImageReload(Fl_Shared_Image* si){
  si->reload();
}
void DLL_EXPORT Fl_Shared_ImageUncache(Fl_Shared_Image* si){
  si->uncache();
}
void DLL_EXPORT Fl_Shared_ImageAddHandler(Fl_Shared_Image* si, Fl_Shared_Handler f){
  si->add_handler(f);
}
Fl_Shared_Image* DLL_EXPORT Fl_Shared_ImageFind(Fl_Shared_Image* si, const char* n, int w, int h){
  return si->find(n,w,h);
}
Fl_Shared_Image* DLL_EXPORT Fl_Shared_ImageGet(const char* n, int w, int h){
  return Fl_Shared_Image::get(n,w,h);
}
Fl_Shared_Image** DLL_EXPORT Fl_Shared_ImageImages(Fl_Shared_Image* si){
  return si->images();
}
int DLL_EXPORT Fl_Shared_ImageNumImages(Fl_Shared_Image* si){
  return si->num_images();
}
void DLL_EXPORT Fl_Shared_ImageRemoveHandler(Fl_Shared_Image* si, Fl_Shared_Handler f){
  si->remove_handler(f);
}

// class Fl_Image
Fl_Image* DLL_EXPORT Fl_ImageNew(int w, int h, int d) {
  return new Fl_Image(w,h,d);
}
void DLL_EXPORT Fl_ImageDelete(Fl_Image* & img){
  if (img) {
    delete img; img=0;
  }
}
void DLL_EXPORT Fl_ImageColorAverage(Fl_Image* img, Fl_Color c, float i){
  img->color_average(c,i);
}
Fl_Image* DLL_EXPORT Fl_ImageCopy(Fl_Image* img){
  return img->copy();
}
Fl_Image* DLL_EXPORT Fl_ImageCopy2(Fl_Image* img, int w, int h){
  return img->copy(w,h);
}
int DLL_EXPORT Fl_ImageCount(Fl_Image* img){
  return img->count();
}
const char* const* DLL_EXPORT Fl_ImageData(Fl_Image* img){
  return img->data();
}
void DLL_EXPORT Fl_ImageDesaturate(Fl_Image* img){
  img->desaturate();
}
void DLL_EXPORT Fl_ImageDraw(Fl_Image* img, int x, int y){
  img->draw(x,y);
}
void DLL_EXPORT Fl_ImageDraw2(Fl_Image* img, int x, int y, int w, int h, int cx, int cy){
  img->draw(x,y,w,h, cx,cy);
}
void DLL_EXPORT Fl_ImageInactive(Fl_Image* img){
  img->inactive();
}
int DLL_EXPORT Fl_ImageLD(Fl_Image* img){
  return img->ld();
}
void DLL_EXPORT Fl_ImageUncache(Fl_Image* img){
  img->uncache();
}
int DLL_EXPORT Fl_ImageW(Fl_Image* img){
  return img->w();
}
int DLL_EXPORT Fl_ImageH(Fl_Image* img){
  return img->h();
}
int DLL_EXPORT Fl_ImageD(Fl_Image* img){
  return img->d();
}


// class Fl_Bitmap extends Fl_Image
Fl_Bitmap* DLL_EXPORT Fl_BitmapNew(const char *bits, int w, int h) {
  return new Fl_Bitmap(bits,w,h);
}
Fl_Image* DLL_EXPORT Fl_BitmapCopy(Fl_Bitmap* bm){
  return bm->copy();
}
Fl_Image* DLL_EXPORT Fl_BitmapCopy2(Fl_Bitmap* bm, int w, int h){
  return bm->copy(w,h);
}
void DLL_EXPORT Fl_BitmapDraw(Fl_Bitmap* bm, int x, int y){
  bm->draw(x,y);
}
void DLL_EXPORT Fl_BitmapDraw2(Fl_Bitmap* bm, int x, int y, int w, int h, int cx, int cy){
  bm->draw(x,y,w,h, cx,cy);
}
void DLL_EXPORT Fl_BitmapUncache(Fl_Bitmap* bm){
  bm->uncache();
}

// class Fl_XBM_Image extends Fl_Bitmap
Fl_XBM_Image* DLL_EXPORT Fl_XBM_ImageNew(const char *filename){
  return new Fl_XBM_Image(filename);
}

// class Fl_Pixmap extends Fl_Image
Fl_Pixmap* DLL_EXPORT Fl_PixmapNew(const uchar *const * xpm_data){
  return new Fl_Pixmap(xpm_data);
}
void DLL_EXPORT Fl_PixmapColorAverage(Fl_Pixmap* pm, Fl_Color c, float i){
  pm->color_average(c,i);
}
Fl_Image* DLL_EXPORT Fl_PixmapCopy(Fl_Pixmap* pm){
  return pm->copy();
}
Fl_Image* DLL_EXPORT Fl_PixmapCopy2(Fl_Pixmap* pm, int w, int h){
  return pm->copy(w,h);
}
void DLL_EXPORT Fl_PixmapDesaturate(Fl_Pixmap* pm){
  pm->desaturate();
}
void DLL_EXPORT Fl_PixmapDraw(Fl_Pixmap* pm, int x, int y){
  pm->draw(x,y);
}
void DLL_EXPORT Fl_PixmapDraw2(Fl_Pixmap* pm, int x, int y, int w, int h, int cx, int cy){
  pm->draw(x,y,w,h, cx,cy);
}
void DLL_EXPORT Fl_PixmapUncache(Fl_Pixmap* pm){
  pm->uncache();
}
// class Fl_XPM_Image extends Fl_Pixmap
Fl_XPM_Image* DLL_EXPORT Fl_XPM_ImageNew(const char *filename){
  return new Fl_XPM_Image(filename);
}
// class Fl_GIF_Image extends Fl_Pixmap
Fl_GIF_Image* DLL_EXPORT Fl_GIF_ImageNew(const char *filename){
  return new Fl_GIF_Image(filename);
}

Fl_RGB_Image* DLL_EXPORT Fl_RGB_ImageNew(const uchar *bits, int w, int h, int d, int ld) {
  return new Fl_RGB_Image(bits,w,h,d,ld);
}
void DLL_EXPORT Fl_RGB_ImageColorAverage(Fl_RGB_Image* rgbimg, Fl_Color c, float i){
  rgbimg->color_average(c,i);
}
Fl_Image* DLL_EXPORT Fl_RGB_ImageCopy(Fl_RGB_Image* rgbimg){
  return rgbimg->copy();
}
Fl_Image* DLL_EXPORT Fl_RGB_ImageCopy2(Fl_RGB_Image* rgbimg, int w, int h){
  return rgbimg->copy(w,h);
}
void DLL_EXPORT Fl_RGB_ImageDesaturate(Fl_RGB_Image* rgbimg){
  rgbimg->desaturate();
}
void DLL_EXPORT Fl_RGB_ImageDraw(Fl_RGB_Image* rgbimg, int x, int y){
  rgbimg->draw(x,y);
}
void DLL_EXPORT Fl_RGB_ImageDraw2(Fl_RGB_Image* rgbimg, int x, int y, int w, int h, int cx, int cy){
  rgbimg->draw(x,y,w,h, cx,cy);
}
void DLL_EXPORT Fl_RGB_ImageUncache(Fl_RGB_Image* rgbimg){
  rgbimg->uncache();
}
// class Fl_BMP_Image extends Fl_RGB_Image
Fl_BMP_Image* DLL_EXPORT Fl_BMP_ImageNew(const char *filename){
  return new Fl_BMP_Image(filename);
}
// class Fl_PNG_Image extends Fl_RGB_Image
Fl_PNG_Image* DLL_EXPORT Fl_PNG_ImageNew(const char *filename){
  return new Fl_PNG_Image(filename);
}
Fl_PNG_Image* DLL_EXPORT Fl_PNG_ImageMem(const char *name_png, const unsigned char *buffer, int datasize){
  return new Fl_PNG_Image(name_png,buffer,datasize);
}


// class Fl_JPEG_Image extends Fl_RGB_Image
Fl_JPEG_Image* DLL_EXPORT Fl_JPEG_ImageNew(const char *filename){
  return new Fl_JPEG_Image(filename);
}
Fl_JPEG_Image* DLL_EXPORT Fl_JPEG_ImageMem(const char *name, const unsigned char *data){
  return new Fl_JPEG_Image(name,data);
}
// class FlPNM_Image extends Fl_RGB_Image
Fl_PNM_Image* DLL_EXPORT Fl_PNM_ImageNew(const char *filename){
  return new Fl_PNM_Image(filename);
}
// class Fl_Tiled_Image extends Fl_Image
Fl_Tiled_Image* DLL_EXPORT Fl_Tiled_ImageNew(Fl_Image *img, int w, int h){
  return new Fl_Tiled_Image(img,w,h);
}
void DLL_EXPORT Fl_Tiled_ImageColorAverage(Fl_Tiled_Image* timg, Fl_Color c, float i){
  timg->color_average(c,i);
}
Fl_Image* DLL_EXPORT Fl_Tiled_ImageCopy(Fl_Tiled_Image* timg){
  return timg->copy();
}
Fl_Image* DLL_EXPORT Fl_Tiled_ImageCopy2(Fl_Tiled_Image* timg, int w, int h){
  return timg->copy(w,h);
}
void DLL_EXPORT Fl_Tiled_ImageDesaturate(Fl_Tiled_Image* timg){
  timg->desaturate();
}
void DLL_EXPORT Fl_Tiled_ImageDraw(Fl_Tiled_Image* timg, int x, int y){
  timg->draw(x,y);
}
void DLL_EXPORT Fl_Tiled_ImageDraw2(Fl_Tiled_Image* timg, int x, int y, int w, int h, int cx, int cy){
  timg->draw(x,y,w,h, cx,cy);
}
Fl_Image* DLL_EXPORT Fl_Tiled_ImageImage(Fl_Tiled_Image* timg){
  return timg->image();
}

// class FL_Widget is the base class of all other widget's
void DLL_EXPORT Fl_WidgetActivate(Fl_Widget* wgt){
  wgt->activate();
}
unsigned int DLL_EXPORT Fl_WidgetActive(Fl_Widget* wgt){
  return wgt->active();
}
int DLL_EXPORT Fl_WidgetActiveR(Fl_Widget* wgt){
  return wgt->active_r();
}
void DLL_EXPORT Fl_WidgetSetAlign(Fl_Widget* wgt, Fl_Align alignment){
  wgt->align(alignment);
}
Fl_Align DLL_EXPORT Fl_WidgetGetAlign(Fl_Widget* wgt){
  return wgt->argument();
}
void DLL_EXPORT Fl_WidgetSetArgument(Fl_Widget* wgt, long v){
  wgt->argument(v);
}
long DLL_EXPORT Fl_WidgetGetArgument(Fl_Widget* wgt){
  return wgt->argument();
}
Fl_Gl_Window* DLL_EXPORT Fl_WidgetAsGl_Window(Fl_Widget* wgt){
  return wgt->as_gl_window();
}
Fl_Group* DLL_EXPORT Fl_WidgetAsGroup(Fl_Widget* wgt){
  return wgt->as_group();
}
Fl_Window* DLL_EXPORT Fl_WidgetAsWindow(Fl_Widget* wgt){
  return wgt->as_window();
}
void DLL_EXPORT Fl_WidgetSetBox(Fl_Widget* wgt, Fl_Boxtype new_box){
  wgt->box(new_box);
}
Fl_Boxtype DLL_EXPORT Fl_WidgetGetBox(Fl_Widget* wgt){
  return wgt->box();
}
void DLL_EXPORT Fl_WidgetSetCallback(Fl_Widget* wgt, Fl_Callback *cb){
  wgt->callback(cb);
}
void DLL_EXPORT Fl_WidgetSetCallbackArg(Fl_Widget* wgt, Fl_Callback *cb, void *pdata){
  wgt->callback(cb,pdata);
}
void DLL_EXPORT Fl_WidgetSetCallback0(Fl_Widget* wgt, Fl_Callback0 *cb){
  wgt->callback(cb);
}
void DLL_EXPORT Fl_WidgetSetCallback1Arg(Fl_Widget* wgt, Fl_Callback1 *cb, long ldata){
  wgt->callback(cb,ldata);
}
Fl_Callback_p DLL_EXPORT Fl_WidgetGetCallback(Fl_Widget* wgt){
  return wgt->callback();
}
unsigned int DLL_EXPORT Fl_WidgetChanged(Fl_Widget* wgt){
  return wgt->changed();
}
void DLL_EXPORT Fl_WidgetClearChanged(Fl_Widget* wgt){
  wgt->clear_changed();
}
void DLL_EXPORT Fl_WidgetClearDamage(Fl_Widget* wgt, uchar c){
  wgt->clear_damage(c);
}
void DLL_EXPORT Fl_WidgetClearOutput(Fl_Widget* wgt){
  wgt->clear_output();
}
void DLL_EXPORT Fl_WidgetClearVisible(Fl_Widget* wgt){
  wgt->clear_visible();
}
void DLL_EXPORT Fl_WidgetClearVisibleFocus(Fl_Widget* wgt){
  wgt->clear_visible_focus();
}
void DLL_EXPORT Fl_WidgetSetColor(Fl_Widget* wgt, Fl_Color bg){
  wgt->color(bg);
}
void DLL_EXPORT Fl_WidgetSetColorSel(Fl_Widget* wgt, Fl_Color bg, Fl_Color sel){
  wgt->color(bg,sel);
}
Fl_Color DLL_EXPORT Fl_WidgetGetColor(Fl_Widget* wgt){
  return wgt->color();
}
void DLL_EXPORT Fl_WidgetSetColor2(Fl_Widget* wgt, unsigned a){
  wgt->color2(a);
}
Fl_Color DLL_EXPORT Fl_WidgetGetColor2(Fl_Widget* wgt){
  return wgt->color2();
}
int DLL_EXPORT Fl_WidgetContains(Fl_Widget* wgt, const Fl_Widget* other){
  return wgt->contains(other);
}
void DLL_EXPORT Fl_WidgetCopyLabel(Fl_Widget* wgt, const char* new_label){
  wgt->copy_label(new_label);
}
void DLL_EXPORT Fl_WidgetCopyTooltip(Fl_Widget* wgt, const char *text){
  wgt->copy_tooltip(text);
}
uchar DLL_EXPORT Fl_WidgetGetDamage(Fl_Widget* wgt){
  return wgt->damage();
}
void DLL_EXPORT Fl_WidgetSetDamage(Fl_Widget* wgt, uchar c){
  wgt->damage(c);
}
void DLL_EXPORT Fl_WidgetSetDamage2(Fl_Widget* wgt, uchar c, int x, int y, int w, int h){
  wgt->damage(c,x,y,w,h);
}
int DLL_EXPORT Fl_WidgetDamageResize(Fl_Widget* wgt, int x, int y, int w, int h){
  return wgt->damage_resize(x,y,w,h);
}
void DLL_EXPORT Fl_WidgetDeactivate(Fl_Widget* wgt){
  wgt->deactivate();
}
void DLL_EXPORT Fl_WidgetSetDeimage(Fl_Widget* wgt, Fl_Image* img){
  wgt->deimage(img);
}
Fl_Image* DLL_EXPORT Fl_WidgetGetDeimage(Fl_Widget* wgt){
  return wgt->deimage();
}
void DLL_EXPORT Fl_WidgetDoCallback(Fl_Widget* wgt){
  wgt->do_callback();
}
void DLL_EXPORT Fl_WidgetDoCallback2(Fl_Widget* wgt, Fl_Widget *o, void* parg){
  wgt->do_callback(o,parg);
}
void DLL_EXPORT Fl_WidgetDoCallback3(Fl_Widget* wgt, Fl_Widget *o, long larg){
  wgt->do_callback(o,larg);
}
void DLL_EXPORT Fl_WidgetDraw(Fl_Widget* wgt){
  wgt->draw();
}
void DLL_EXPORT Fl_WidgetDrawLabel(Fl_Widget* wgt, int x, int y, int w, int h, Fl_Align align){
  wgt->draw_label(x,y,w,h,align);
}
int DLL_EXPORT Fl_WidgetGetH(Fl_Widget* wgt){
  return wgt->h();
}
int DLL_EXPORT Fl_WidgetHandle(Fl_Widget* wgt, int event){
  return wgt->handle(event);
}
void DLL_EXPORT Fl_WidgetHide(Fl_Widget* wgt){
  wgt->hide();
}
void DLL_EXPORT Fl_WidgetSetImage(Fl_Widget* wgt, Fl_Image* img){
  wgt->image(img);
}
Fl_Image* DLL_EXPORT Fl_WidgetGetImage(Fl_Widget* wgt){
  return wgt->image();
}
const Fl_Image* DLL_EXPORT Fl_WidgetGetImage2(Fl_Widget* wgt){
  return wgt->image();
}
int DLL_EXPORT Fl_WidgetInside (Fl_Widget* wgt, const Fl_Widget* other){
  return wgt->inside(other);
}
const char* DLL_EXPORT Fl_WidgetGetLabel(Fl_Widget* wgt){
  return wgt->label();
}
void DLL_EXPORT Fl_WidgetSetLabel(Fl_Widget* wgt, const char* text){
  wgt->label(text);
}
void DLL_EXPORT Fl_WidgetSetLabel2(Fl_Widget* wgt, Fl_Labeltype a, const char* text){
  wgt->label(a,text);
}
void DLL_EXPORT Fl_WidgetSetLabelColor(Fl_Widget* wgt, Fl_Color c){
  wgt->labelcolor(c);
}
Fl_Color DLL_EXPORT Fl_WidgetGetLabelColor(Fl_Widget* wgt){
  return wgt->labelcolor();
}
void DLL_EXPORT Fl_WidgetSetLabelFont(Fl_Widget* wgt, Fl_Font f){
  wgt->labelfont(f);
}
Fl_Font DLL_EXPORT Fl_WidgetGetLabelFont(Fl_Widget* wgt){
  return wgt->labelfont();
}
void DLL_EXPORT Fl_WidgetSetLabelSize(Fl_Widget* wgt, Fl_Fontsize pix){
  wgt->labelsize(pix);
}
Fl_Fontsize DLL_EXPORT Fl_WidgetGetLabelSize(Fl_Widget* wgt){
  return wgt->labelsize();
}
void DLL_EXPORT Fl_WidgetSetLabelType(Fl_Widget* wgt, Fl_Labeltype a){
  wgt->labeltype(a);
}
Fl_Labeltype DLL_EXPORT Fl_WidgetGetLabelType(Fl_Widget* wgt){
  return wgt->labeltype();
}
void DLL_EXPORT Fl_WidgetMeasureLabel(Fl_Widget* wgt,int &ww, int &hh){
  wgt->measure_label(ww,hh);
}
unsigned int DLL_EXPORT Fl_WidgetOutput(Fl_Widget* wgt){
  return wgt->output();
}
void DLL_EXPORT Fl_WidgetSetParent(Fl_Widget* wgt, Fl_Group* p){
  wgt->parent(p);
}
Fl_Group* DLL_EXPORT Fl_WidgetGetParent(Fl_Widget* wgt){
  return wgt->parent();
}
void DLL_EXPORT Fl_WidgetPosition(Fl_Widget* wgt, int X, int Y){
  wgt->position(X,Y);
}
void DLL_EXPORT Fl_WidgetRedraw(Fl_Widget* wgt){
  wgt->redraw();
}
void DLL_EXPORT Fl_WidgetRedrawLabel(Fl_Widget* wgt){
  wgt->redraw_label();
}
void DLL_EXPORT Fl_WidgetResize(Fl_Widget* wgt, int x, int y, int w, int h){
  wgt->resize(x,y,w,h);
}
void DLL_EXPORT Fl_WidgetSetSelectionColor(Fl_Widget* wgt, Fl_Color a){
  wgt->selection_color(a);
}
Fl_Color DLL_EXPORT Fl_WidgetGetSelectionColor(Fl_Widget* wgt){
  return wgt->selection_color();
}
void DLL_EXPORT Fl_WidgetSetChanged(Fl_Widget* wgt){
  wgt->set_changed();
}
void DLL_EXPORT Fl_WidgetSetOutput(Fl_Widget* wgt){
  wgt->set_output();
}
void DLL_EXPORT Fl_WidgetSetVisible(Fl_Widget* wgt){
  wgt->set_visible();
}
void DLL_EXPORT Fl_WidgetSetVisibleFocus(Fl_Widget* wgt){
  wgt->set_visible_focus();
}
void DLL_EXPORT Fl_WidgetShow(Fl_Widget* wgt){
  wgt->show();
}
void DLL_EXPORT Fl_WidgetSize(Fl_Widget* wgt, int W, int H){
  wgt->size(W,H);
}
int DLL_EXPORT Fl_WidgetTakeFocus(Fl_Widget* wgt){
  return wgt->take_focus();
}
unsigned int DLL_EXPORT Fl_WidgetTakesEvents(Fl_Widget* wgt){
  return wgt->takesevents();
}
int DLL_EXPORT Fl_WidgetTestShortcut(Fl_Widget* wgt){
  return wgt->test_shortcut();
}
void DLL_EXPORT Fl_WidgetSetTooltip(Fl_Widget* wgt, const char* text){
  wgt->tooltip(text);
}
const char* DLL_EXPORT Fl_WidgetGetTooltip(Fl_Widget* wgt){
  return wgt->tooltip();
}

void DLL_EXPORT Fl_WidgetSetType(Fl_Widget* wgt, uchar t){
  wgt->type(t);
}
uchar DLL_EXPORT Fl_WidgetGetType(Fl_Widget* wgt){
  return wgt->type();
}
void DLL_EXPORT Fl_WidgetSetUserData(Fl_Widget* wgt, void* v){
  wgt->user_data(v);
}
void* DLL_EXPORT Fl_WidgetGetUserData(Fl_Widget* wgt){
  return wgt->user_data();
}
int DLL_EXPORT Fl_WidgetVisible(Fl_Widget* wgt){
  return wgt->visible();
}
void DLL_EXPORT Fl_WidgetVisibleFocus(Fl_Widget* wgt, int v){
  wgt->visible_focus(v);
}
int DLL_EXPORT Fl_WidgetGetVisibleFocus(Fl_Widget* wgt){
  return wgt->visible_focus();
}
int DLL_EXPORT Fl_WidgetVisibleR(Fl_Widget* wgt){
  return wgt->visible_r();
}
int DLL_EXPORT Fl_WidgetGetW(Fl_Widget* wgt){
  return wgt->w();
}
void DLL_EXPORT Fl_WidgetSetWhen(Fl_Widget* wgt, Fl_When w){
  wgt->when(w);
}
Fl_When DLL_EXPORT Fl_WidgetGetWhen(Fl_Widget* wgt){
  return wgt->when();
}
Fl_Window* DLL_EXPORT Fl_WidgetWindow(Fl_Widget* wgt){
  return wgt->window();
}
int DLL_EXPORT Fl_WidgetGetX(Fl_Widget* wgt){
  return wgt->x();
}
int DLL_EXPORT Fl_WidgetGetY(Fl_Widget* wgt){
  return wgt->y();
}
void DLL_EXPORT Fl_WidgetDefaultCallback(Fl_Widget* wgt, Fl_Widget* cb, void* d){
  wgt->default_callback(cb,d);
}
unsigned int DLL_EXPORT Fl_WidgetLabelShortcut(Fl_Widget* wgt, const char* t){
  return wgt->label_shortcut(t);
}
int DLL_EXPORT Fl_WidgetTestShortcut2(Fl_Widget* wgt, const char* t, int require_alt){
    if (require_alt!=0)
      return wgt->test_shortcut(t,true);
    else
      return wgt->test_shortcut(t,false);
}


// class Fl_Box
ImplementEx(Fl_Box);
Fl_Box* DLL_EXPORT Fl_BoxNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Box(X,Y,W,H,label);
}
Fl_Box* DLL_EXPORT Fl_BoxNew2(Fl_Boxtype bt, int X, int Y, int W, int H, const char* label){
  return new Fl_Box(bt,X,Y,W,H,label);
}

// class Fl_Button
ImplementEx(Fl_Button);
Fl_Button* DLL_EXPORT Fl_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Button(X,Y,W,H,label);
}
int DLL_EXPORT Fl_ButtonClear(Fl_Button* btn){
  return btn->clear();
}
void DLL_EXPORT Fl_ButtonSetDownBox(Fl_Button* btn, Fl_Boxtype bt){
  btn->down_box(bt);
}
Fl_Boxtype DLL_EXPORT Fl_ButtonGetDownBox(Fl_Button* btn){
  return btn->down_box();
}
void DLL_EXPORT Fl_ButtonSetDownColor(Fl_Button* btn, Fl_Color c){
  btn->down_color(c);
}
Fl_Color DLL_EXPORT Fl_ButtonGetDownColor(Fl_Button* btn){
  return btn->down_color();
}
int DLL_EXPORT Fl_ButtonHandle(Fl_Button* btn, int ev){
  return btn->handle(ev);
}
int DLL_EXPORT Fl_ButtonSet(Fl_Button* btn){
  return btn->set();
}
void DLL_EXPORT Fl_ButtonSetOnly(Fl_Button* btn){
  btn->setonly();
}
void DLL_EXPORT Fl_ButtonSetShortcut(Fl_Button* btn, int s){
  btn->shortcut(s);
}
int DLL_EXPORT Fl_ButtonGetShortcut(Fl_Button* btn){
  return btn->shortcut();
}
int DLL_EXPORT Fl_ButtonSetValue(Fl_Button* btn, int v){
  return btn->value(v);
}
int DLL_EXPORT Fl_ButtonGetValue(Fl_Button* btn){
  return btn->value();
}

// class Fl_Radio_Button
ImplementEx(Fl_Radio_Button);
Fl_Radio_Button* DLL_EXPORT Fl_Radio_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Radio_Button(X,Y,W,H,label);
}

// class Fl_Repeat_Button
ImplementEx(Fl_Repeat_Button);
Fl_Repeat_Button* DLL_EXPORT Fl_Repeat_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Repeat_Button(X,Y,W,H,label);
}
int DLL_EXPORT Fl_Repeat_ButtonHandle(Fl_Repeat_Button* btn, int ev){
  return btn->handle(ev);
}
void DLL_EXPORT Fl_Repeat_ButtonDeactivate(Fl_Repeat_Button* btn){
  btn->deactivate();
}

// class Fl_Return_Button
ImplementEx(Fl_Return_Button);
Fl_Return_Button* DLL_EXPORT Fl_Return_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Return_Button(X,Y,W,H,label);
}
int DLL_EXPORT Fl_Return_ButtonHandle(Fl_Return_Button* btn, int ev){
  return btn->handle(ev);
}

// class Fl_Toggle_Button
ImplementEx(Fl_Toggle_Button);
Fl_Toggle_Button* DLL_EXPORT Fl_Toggle_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Toggle_Button(X,Y,W,H,label);
}

// class Fl_Light_Button
ImplementEx(Fl_Light_Button);
Fl_Light_Button* DLL_EXPORT Fl_Light_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Light_Button(X,Y,W,H,label);
}
int DLL_EXPORT Fl_Light_ButtonHandle(Fl_Light_Button* btn, int ev){
  return btn->handle(ev);
}

// class Fl_Check_Button extends Fl_Light_Button
ImplementEx(Fl_Check_Button);
Fl_Check_Button* DLL_EXPORT Fl_Check_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Check_Button(X,Y,W,H,label);
}

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

// class Fl_Round_Button extends Fl_Light_Button
ImplementEx(Fl_Round_Button);
Fl_Round_Button* DLL_EXPORT Fl_Round_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Round_Button(X,Y,W,H,label);
}

// class Fl_Radio_Round_Button extends Fl_Light_Button
ImplementEx(Fl_Radio_Round_Button);
Fl_Radio_Round_Button* DLL_EXPORT Fl_Radio_Round_ButtonNew(int X, int Y, int W, int H, const char* label){
  return new Fl_Radio_Round_Button(X,Y,W,H,label);
}



// class Fl_Chart extends Fl_Widget
ImplementEx(Fl_Chart);
Fl_Chart* Fl_ChartNew(int x, int y, int w, int h, const char *label){
  return new Fl_Chart(x,y,w,h,label);
}
void DLL_EXPORT Fl_ChartAdd(Fl_Chart* ch, double val, const char *str, unsigned col){
  ch->add(val,str,col);
}
void DLL_EXPORT Fl_ChartSetAutoSize(Fl_Chart* ch, int n){
  ch->autosize(n);
}
int DLL_EXPORT Fl_ChartGetAutoSize(Fl_Chart* ch){
  return ch->autosize();
}
void DLL_EXPORT Fl_ChartSetBounds(Fl_Chart* ch, double a, double b){
  ch->bounds(a,b);
}
void DLL_EXPORT Fl_ChartGetBounds(Fl_Chart* ch, double *a, double *b){
  ch->bounds(a,b);
}
void DLL_EXPORT Fl_ChartClear(Fl_Chart* ch){
  ch->clear();
}
void DLL_EXPORT Fl_ChartInsert(Fl_Chart* ch, int ind, double val, const char *str, unsigned col){
  ch->insert(ind,val,str,col);
}
void DLL_EXPORT Fl_ChartSetMaxSize(Fl_Chart* ch, int m){
  ch->maxsize(m);
}
int DLL_EXPORT Fl_ChartGetMaxSize(Fl_Chart* ch){
  return ch->maxsize();
}
void DLL_EXPORT Fl_ChartReplace(Fl_Chart* ch, int ind, double val, const char *str, unsigned col){
  ch->replace(ind,val,str,col);
}
void DLL_EXPORT Fl_ChartSetSize(Fl_Chart* ch, int w, int h){
  ch->size(w,h);
}
int DLL_EXPORT Fl_ChartGetSize(Fl_Chart* ch){
  return ch->size();
}
void DLL_EXPORT Fl_ChartSetTextColor(Fl_Chart* ch, Fl_Color c){
  ch->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_ChartGetTextColor(Fl_Chart* ch){
  return ch->textcolor();
}
void DLL_EXPORT Fl_ChartSetTextFont(Fl_Chart* ch, Fl_Font f){
  ch->textfont(f);
}
Fl_Font DLL_EXPORT Fl_ChartGetTextFont(Fl_Chart* ch){
  return ch->textfont();
}
void DLL_EXPORT Fl_ChartSetTextSize(Fl_Chart* ch, Fl_Fontsize fs){
  ch->textsize(fs);
}
Fl_Fontsize DLL_EXPORT Fl_ChartGetTextSize(Fl_Chart* ch){
  return ch->textsize();
}

// class Fl_Clock_Output
ImplementEx(Fl_Clock_Output);
Fl_Clock_Output* DLL_EXPORT Fl_Clock_OutputNew(int x, int y, int w, int h, const char *label){
  return new Fl_Clock_Output(x,y,w,h,label);
}
int Fl_Clock_OutputHour(Fl_Clock_Output* co){
  return co->hour();
}
int	DLL_EXPORT Fl_Clock_OutputMinute(Fl_Clock_Output* co){
  return co->minute();
}
int DLL_EXPORT Fl_Clock_OutputSecond(Fl_Clock_Output* co){
  return co->second();
}
void DLL_EXPORT Fl_Clock_OutputValue(Fl_Clock_Output* co, int H, int m, int s){
  co->value(H,m,s);
}
void DLL_EXPORT Fl_Clock_OutputSetValue(Fl_Clock_Output* co, ulong v){
  co->value(v);
}
ulong DLL_EXPORT Fl_Clock_OutputGetValue(Fl_Clock_Output* co){
  return co->value();
}

// class Fl_Clock
ImplementEx(Fl_Clock);
Fl_Clock* DLL_EXPORT Fl_ClockNew(int x, int y, int w, int h, const char *label){
  return new Fl_Clock(x,y,w,h,label);
}
Fl_Clock* DLL_EXPORT Fl_ClockNew2(uchar t, int x, int y, int w, int h, const char *label){
  return new Fl_Clock(t,x,y,w,h,label);
}
// class Fl_Round_Clock
ImplementEx(Fl_Round_Clock);
Fl_Round_Clock* DLL_EXPORT Fl_Round_ClockNew(int x, int y, int w, int h, const char *label){
  return new Fl_Round_Clock(x,y,w,h,label);
}

// struct Fl_Menu_Item
void DLL_EXPORT Fl_Menu_ItemActivate(Fl_Menu_Item* it){
  it->activate();
}
int DLL_EXPORT Fl_Menu_ItemActive(Fl_Menu_Item* it){
  return it->active();
}
int DLL_EXPORT Fl_Menu_ItemActiveVisible(Fl_Menu_Item* it){
  return it->activevisible();
}
int DLL_EXPORT Fl_Menu_ItemAdd(Fl_Menu_Item* it, const char* label, int shortcut, Fl_Callback* cb, void* userdata, int flag){
  return it->add(label,shortcut,cb,userdata,flag);
}
int DLL_EXPORT Fl_Menu_ItemAdd2(Fl_Menu_Item* it, const char* label, const char* shortcut, Fl_Callback* cb, void* userdata, int flag){
  return it->add(label,shortcut,cb,userdata,flag);
}
void DLL_EXPORT Fl_Menu_ItemSetArgument(Fl_Menu_Item* it, long v){
  it->argument(v);
}
long DLL_EXPORT Fl_Menu_ItemGetArgument(Fl_Menu_Item* it){
  return it->argument();
}
Fl_Callback_p DLL_EXPORT Fl_Menu_ItemGetCallback_p(Fl_Menu_Item* it){
  return it->callback();
}
void DLL_EXPORT Fl_Menu_ItemCallback (Fl_Menu_Item* it, Fl_Callback *cb){
  it->callback(cb);
}
void DLL_EXPORT Fl_Menu_ItemCallback2(Fl_Menu_Item* it, Fl_Callback *cb, void* pData){
  it->callback(cb,pData);
}
void DLL_EXPORT Fl_Menu_ItemCallback0(Fl_Menu_Item* it, Fl_Callback0 *cb){
  it->callback(cb);
}
void DLL_EXPORT Fl_Menu_ItemCallback1(Fl_Menu_Item* it, Fl_Callback1 *cb, long lData){
  it->callback(cb,lData);
}
void DLL_EXPORT Fl_Menu_ItemCheck(Fl_Menu_Item* it){
  it->check();
}
int DLL_EXPORT Fl_Menu_ItemCheckBox(Fl_Menu_Item* it){
  return it->checkbox();
}
int DLL_EXPORT Fl_Menu_ItemChecked(Fl_Menu_Item* it){
  return it->checked();
}
void DLL_EXPORT Fl_Menu_ItemClear(Fl_Menu_Item* it){
  it->clear();
}
void DLL_EXPORT Fl_Menu_ItemDeactivate(Fl_Menu_Item* it){
  it->deactivate();
}
void DLL_EXPORT Fl_Menu_ItemDoCallback(Fl_Menu_Item* it, Fl_Widget* o, void* arg){
  it->do_callback(o,arg);
}
void DLL_EXPORT Fl_Menu_ItemDoCallback2(Fl_Menu_Item* it, Fl_Widget* o, long arg){
  it->do_callback(o,arg);
}
void DLL_EXPORT Fl_Menu_ItemDoCallback3(Fl_Menu_Item* it, Fl_Widget* o){
  it->do_callback(o);
}
void DLL_EXPORT Fl_Menu_ItemDraw(Fl_Menu_Item* it, int x, int y, int w, int h, const Fl_Menu_* m_, int t){
  it->draw(x,y,w,h,m_,t);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemFindShortcut(Fl_Menu_Item* it, int* ip, const int require_alt){
  return it->find_shortcut(ip,require_alt!=0);
}
Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemFirst(Fl_Menu_Item* it){
  return it->first();
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemFirst2(Fl_Menu_Item* it){
  return it->first();
}
void DLL_EXPORT Fl_Menu_ItemHide(Fl_Menu_Item* it){
  it->hide();
}
int DLL_EXPORT Fl_Menu_ItemInsert(Fl_Menu_Item* it, int index, const char* label, int shortcut, Fl_Callback* cb, void* userdata, int flag){
  return it->insert(index,label,shortcut,cb,userdata,flag);
}
void DLL_EXPORT Fl_Menu_ItemSetLabel(Fl_Menu_Item* it, const char* label){
  it->label(label);
}
void DLL_EXPORT Fl_Menu_ItemSetLabel2(Fl_Menu_Item* it, Fl_Labeltype lt, const char* label){
  it->label(lt,label);
}
const char* DLL_EXPORT Fl_Menu_ItemGetLabel(Fl_Menu_Item* it){
 return it->label();
}
void DLL_EXPORT Fl_Menu_ItemSetLabelColor(Fl_Menu_Item* it, Fl_Color c){
  it->labelcolor(c);
}
Fl_Color DLL_EXPORT Fl_Menu_ItemGetLabelColor(Fl_Menu_Item* it){
  return it->labelcolor();
}
void DLL_EXPORT Fl_Menu_ItemSetLabelFont(Fl_Menu_Item* it,Fl_Font f){
  it->labelfont(f);
}
Fl_Font DLL_EXPORT Fl_Menu_ItemGetLabelFont(Fl_Menu_Item* it){
  return it->labelfont();
}
void DLL_EXPORT Fl_Menu_ItemSetLabelSize(Fl_Menu_Item* it, Fl_Fontsize s){
  it->labelsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Menu_ItemGetLabelSize(Fl_Menu_Item* it){
  return it->labelsize();
}
void DLL_EXPORT Fl_Menu_ItemSetLabelType(Fl_Menu_Item* it, Fl_Labeltype t){
  it->labeltype(t);
}
Fl_Labeltype DLL_EXPORT Fl_Menu_ItemGetLabelType(Fl_Menu_Item* it){
  return it->labeltype();
}
int DLL_EXPORT Fl_Menu_ItemMeasure(Fl_Menu_Item* it, int *h, const Fl_Menu_* m){
  return it->measure(h,m);
}
Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemNext(Fl_Menu_Item* it, int index){
  return it->next(index);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemNext2(Fl_Menu_Item* it, int index){
  return it->next(index);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemPopup(Fl_Menu_Item* it, int x, int y, const char *title, const Fl_Menu_Item *picked, const Fl_Menu_* m){
  return it->popup(x,y,title,picked,m);
}
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, const Fl_Menu_* m, const Fl_Menu_Item *title, int menubar){
  return it->pulldown(x,y,w,h,picked,m,title,menubar);
}
int DLL_EXPORT Fl_Menu_ItemRadio(Fl_Menu_Item* it){
  return it->radio();
}
void DLL_EXPORT Fl_Menu_ItemSet(Fl_Menu_Item* it){
  it->set();
}
void DLL_EXPORT Fl_Menu_ItemSetonly(Fl_Menu_Item* it){
  it->setonly();
}
void DLL_EXPORT Fl_Menu_ItemSetShortcut(Fl_Menu_Item* it, int s){
  it->shortcut(s);
}
int DLL_EXPORT Fl_Menu_ItemGetShortcut(Fl_Menu_Item* it){
  return it->shortcut();
}
void  DLL_EXPORT Fl_Menu_ItemShow(Fl_Menu_Item* it){
  it->show();
}
int DLL_EXPORT Fl_Menu_ItemSize(Fl_Menu_Item* it){
  return it->size();
}
int DLL_EXPORT Fl_Menu_ItemSubmenu(Fl_Menu_Item* it){
  return it->submenu();
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ItemTestShortcut(Fl_Menu_Item* it){
  return it->test_shortcut();
}
void DLL_EXPORT Fl_Menu_ItemUncheck(Fl_Menu_Item* it){
  it->uncheck();
}
void DLL_EXPORT Fl_Menu_ItemSetUserData(Fl_Menu_Item* it, void* v){
  it->user_data(v);
}
void* DLL_EXPORT Fl_Menu_ItemGetUserData(Fl_Menu_Item* it){
  return it->user_data();
}
int DLL_EXPORT Fl_Menu_ItemValue(Fl_Menu_Item* it){
  return it->value();
}
int DLL_EXPORT Fl_Menu_ItemVisible(Fl_Menu_Item* it){
  return it->visible();
}


// class Fl_Menu_
int DLL_EXPORT Fl_Menu_Add(Fl_Menu_* m_, const char* label, int shortcut, Fl_Callback* cb, void* userdata, int flag){
  return m_->add(label,shortcut,cb,userdata,flag);
}
int DLL_EXPORT Fl_Menu_Add2(Fl_Menu_* m_, const char* label, const char* shortcut, Fl_Callback* cb, void* userdata, int flag){
  return m_->add(label,shortcut,cb,userdata,flag);
}
int DLL_EXPORT Fl_Menu_Add3(Fl_Menu_* m_, const char* label){
  return m_->add(label);
}
void DLL_EXPORT Fl_Menu_Clear(Fl_Menu_* m_){
  m_->clear();
}
int DLL_EXPORT Fl_Menu_ClearSubmenu(Fl_Menu_* m_, int index){
  return m_->clear_submenu(index);
}
void DLL_EXPORT Fl_Menu_Copy(Fl_Menu_* m_, const Fl_Menu_Item* mi, void* userdata){
  m_->copy(mi,userdata);
}
void DLL_EXPORT Fl_Menu_SetDownBox(Fl_Menu_* m_, Fl_Boxtype b){
  m_->down_box(b);
}
Fl_Boxtype DLL_EXPORT Fl_Menu_GetDownBox(Fl_Menu_* m_){
  return m_->down_box();
}
void DLL_EXPORT Fl_Menu_SetDownColor(Fl_Menu_* m_, Fl_Color c){
  m_->down_color(c);
}
Fl_Color DLL_EXPORT Fl_Menu_GetDownColor(Fl_Menu_* m_){
  return m_->down_color();
}
int DLL_EXPORT Fl_Menu_FindIndexByName(Fl_Menu_* m_, const char* name){
  return m_->find_index(name);
}
int DLL_EXPORT Fl_Menu_FindIndexByItem(Fl_Menu_* m_, const Fl_Menu_Item* item){
  return m_->find_index(item);
}
int DLL_EXPORT Fl_Menu_FindIndexByCallback(Fl_Menu_* m_, Fl_Callback *cb){
  return m_->find_index(cb);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_FindItemByName(Fl_Menu_* m_, const char* name){
  return m_->find_item(name);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_FindItemByCallback(Fl_Menu_* m_, Fl_Callback* cb){
  return m_->find_item(cb);
}
void DLL_EXPORT Fl_Menu_Global(Fl_Menu_* m_){
  m_->global();
}
int DLL_EXPORT Fl_Menu_Insert(Fl_Menu_* m_, int index, const char* label, const char* shortcut, Fl_Callback* cb, void* userdata, int flag){
  return m_->insert(index,label,shortcut,cb,userdata,flag);
}
int DLL_EXPORT Fl_Menu_Insert2(Fl_Menu_* m_, int index, const char* label, int shortcut        , Fl_Callback* cb, void* userdata, int flag){
  return m_->insert(index,label,shortcut,cb,userdata,flag);
}
int DLL_EXPORT Fl_Menu_ItemPathName(Fl_Menu_* m_, char* name, int namelen, const Fl_Menu_Item* finditem){
  return m_->item_pathname(name,namelen,finditem);
}
void DLL_EXPORT Fl_Menu_SetMenu(Fl_Menu_* m_, const Fl_Menu_Item* m){
  m_->menu(m);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_GetMenu(Fl_Menu_* m_){
  return m_->menu();
}
void DLL_EXPORT Fl_Menu_SetMode(Fl_Menu_* m_, int index, int flag){
  m_->mode(index,flag);
}
int DLL_EXPORT Fl_Menu_GetMode (Fl_Menu_* m_, int index){
  return m_->mode(index);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_MValue(Fl_Menu_* m_){
  return m_->mvalue();
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_Picked(Fl_Menu_* m_, const Fl_Menu_Item* m){
  return m_->picked(m);
}
void DLL_EXPORT Fl_Menu_Remove(Fl_Menu_* m_, int index){
  m_->remove(index);
}
void DLL_EXPORT Fl_Menu_Replace(Fl_Menu_* m_, int index, const char* label){
  m_->replace(index,label);
}
void DLL_EXPORT Fl_Menu_Shortcut(Fl_Menu_* m_, int index, int shortcut){
  m_->shortcut(index,shortcut);
}
int DLL_EXPORT Fl_Menu_GetSize(Fl_Menu_* m_){
  return m_->size();
}
void DLL_EXPORT Fl_Menu_SetSize(Fl_Menu_* m_, int w, int h){
  m_->size(w,h);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_TestShortcut(Fl_Menu_* m_){
  return m_->test_shortcut();
}
const char* DLL_EXPORT Fl_Menu_Text(Fl_Menu_* m_){
  return m_->text();
}
const char* DLL_EXPORT Fl_Menu_TextByIndex(Fl_Menu_* m_, int index){
  return m_->text(index);
}
void DLL_EXPORT Fl_Menu_SetTextColor(Fl_Menu_* m_, Fl_Color c){
  m_->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Menu_GetTextColor(Fl_Menu_* m_){
  return m_->textcolor();
}
void DLL_EXPORT Fl_Menu_SetTextFont(Fl_Menu_* m_, Fl_Font f){
  m_->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Menu_GetTextFont(Fl_Menu_* m_){
  return m_->textfont();
}
void DLL_EXPORT Fl_Menu_SetTextSize(Fl_Menu_* m_, Fl_Fontsize s){
  m_->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Menu_GetTextSize(Fl_Menu_* m_){
  return m_->textsize();
}
int DLL_EXPORT Fl_Menu_Value(Fl_Menu_* m_){
  return m_->value();
}
int DLL_EXPORT Fl_Menu_ValueByItem(Fl_Menu_* m_, const Fl_Menu_Item* m){
  return m_->value(m);
}
int DLL_EXPORT Fl_Menu_ValueByIndex(Fl_Menu_* m_, int index){
  return m_->value(index);
}

// class Fl_Menu_Bar
ImplementEx(Fl_Menu_Bar);
Fl_Menu_Bar* DLL_EXPORT Fl_Menu_BarNew(int x, int y, int w, int h, const char* label){
  return new Fl_Menu_Bar(x,y,w,h,label);
}
int	DLL_EXPORT Fl_Menu_BarHandle(Fl_Menu_Bar* mb, int event){
  return mb->handle(event);
}

// class Fl_Menu_Button
ImplementEx(Fl_Menu_Button);
Fl_Menu_Button* DLL_EXPORT Fl_Menu_ButtonNew(int x, int y, int w, int h, const char* label){
  return new Fl_Menu_Button(x,y,w,h,label);
}
int	DLL_EXPORT Fl_Menu_ButtonHandle(Fl_Menu_Button* mb, int event){
  return mb->handle(event);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Menu_ButtonPopup(Fl_Menu_Button* mb){
  return mb->popup();
}

// class Fl_Choice
ImplementEx(Fl_Choice);
Fl_Choice* DLL_EXPORT Fl_ChoiceNew(int x, int y, int w, int h, const char* label){
  return new Fl_Choice(x,y,w,h,label);
}
int DLL_EXPORT Fl_ChoiceHandle(Fl_Choice* c, int event){
  return c->handle(event);
}
int DLL_EXPORT Fl_ChoiceSetValue(Fl_Choice* c, int index){
  return c->value(index);
}
int DLL_EXPORT Fl_ChoiceSetValueByItem(Fl_Choice* c, const Fl_Menu_Item* v){
  return c->value(v);
}
int DLL_EXPORT Fl_ChoiceGetValue(Fl_Choice* c){
  return c->value();
}

// class Fl_Input_
int DLL_EXPORT Fl_Input_Copy(Fl_Input_* ip, int clipboard){
  return ip->copy(clipboard);
}
int DLL_EXPORT Fl_Input_CopyCuts(Fl_Input_* ip){
  return ip->copy_cuts();
}
void DLL_EXPORT Fl_Input_SetCursorColor(Fl_Input_* ip, Fl_Color c){
  ip->cursor_color(c);
}
Fl_Color DLL_EXPORT Fl_Input_GetCursorColor(Fl_Input_* ip){
  return ip->cursor_color();
}
int DLL_EXPORT Fl_Input_Cut(Fl_Input_* ip){
  return ip->cut();
}
int DLL_EXPORT Fl_Input_Cut1(Fl_Input_* ip, int n){
  return ip->cut(n);
}
int DLL_EXPORT Fl_Input_Cut2(Fl_Input_* ip, int a, int b){
  return ip->cut(a,b);
}
Fl_Char DLL_EXPORT Fl_Input_Index(Fl_Input_* ip, int i){
  return ip->index(i);
}
void DLL_EXPORT Fl_Input_SetInputType(Fl_Input_* ip, int t){
  ip->input_type(t);
}
int DLL_EXPORT Fl_Input_GetInputType(Fl_Input_* ip){
  return ip->input_type();
}
int DLL_EXPORT Fl_Input_Insert(Fl_Input_* ip, const char* text, int l){
  return ip->insert(text,l);
}
int DLL_EXPORT Fl_Input_SetMark(Fl_Input_* ip, int m){
  return ip->mark(m);
}
int DLL_EXPORT Fl_Input_GetMark(Fl_Input_* ip){
  return ip->mark();
}
void DLL_EXPORT Fl_Input_SetMaximumSize(Fl_Input_* ip, int m){
  ip->maximum_size(m);
}
int DLL_EXPORT Fl_Input_GetMaximumSize(Fl_Input_* ip){
  return ip->maximum_size();
}
int DLL_EXPORT Fl_Input_SetPosition(Fl_Input_* ip, int p){
  return ip->position(p);
}
int DLL_EXPORT Fl_Input_SetPosition2(Fl_Input_* ip, int p, int m){
  return ip->position(p,m);
}
int DLL_EXPORT Fl_Input_GetPosition(Fl_Input_* ip){
  return ip->position();
}
void DLL_EXPORT Fl_Input_SetReadonly(Fl_Input_* ip, int b){
  ip->readonly(b);
}
int DLL_EXPORT Fl_Input_GetReadonly(Fl_Input_* ip){
  return ip->readonly();
}
int DLL_EXPORT Fl_Input_Replace(Fl_Input_* ip, int b, int e, const char* text, int l){
  return ip->replace(b,e,text,l);
}
void DLL_EXPORT Fl_Input_Resize(Fl_Input_* ip, int x, int y, int w, int h){
  ip->resize(x,y,w,h);
}
void  DLL_EXPORT Fl_Input_SetShortcut(Fl_Input_* ip, int s){
  ip->shortcut(s);
}
int DLL_EXPORT Fl_Input_GetShortcut(Fl_Input_* ip){
  return ip->shortcut();
}
void DLL_EXPORT Fl_Input_SetSize(Fl_Input_* ip, int w, int h){
  ip->size(w,h);
}
int DLL_EXPORT Fl_Input_GetSize(Fl_Input_* ip){
  return ip->size();
}
int DLL_EXPORT Fl_Input_StaticValue(Fl_Input_* ip, const char* text){
  return ip->static_value(text);
}
int DLL_EXPORT Fl_Input_StaticValue2(Fl_Input_* ip, const char* text, int l){
  return ip->static_value(text,l);
}
void DLL_EXPORT Fl_Input_SetTabNav(Fl_Input_* ip, int val){
  ip->tab_nav(val);
}
int DLL_EXPORT Fl_Input_GetTabNav(Fl_Input_* ip){
  return ip->tab_nav();
}
void DLL_EXPORT Fl_Input_SetTextColor(Fl_Input_* ip, Fl_Color c){
  ip->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Input_GetTextColor(Fl_Input_* ip){
  return ip->textcolor();
}
void DLL_EXPORT Fl_Input_SetTextFont(Fl_Input_* ip, Fl_Font f){
  ip->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Input_GetTextFont(Fl_Input_* ip){
  return ip->textfont();
}
void DLL_EXPORT Fl_Input_SetTextSize(Fl_Input_* ip, Fl_Fontsize s){
  ip->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Input_GetTextSize(Fl_Input_* ip){
  return ip->textsize();
}
int DLL_EXPORT Fl_Input_Undo(Fl_Input_* ip){
  return ip->undo();
}
int DLL_EXPORT Fl_Input_SetValue(Fl_Input_* ip, const char* text){
  return ip->value(text);
}
int DLL_EXPORT Fl_Input_SetValue2(Fl_Input_* ip, const char* text, int l){
  return ip->value(text,l);
}
const char* DLL_EXPORT Fl_Input_GetValue(Fl_Input_* ip){
  return ip->value();
}
void DLL_EXPORT Fl_Input_SetWrap(Fl_Input_* ip, int b){
  ip->wrap(b);
}
int DLL_EXPORT Fl_Input_GetWrap(Fl_Input_* ip){
  return ip->wrap();
}

// Fl_Input extends Fl_Input_
Fl_Input* DLL_EXPORT Fl_InputNew(int x, int y, int w, int h, const char *label){
  return new Fl_Input(x,y,w,h,label);
}
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){
  return new Fl_File_Input(x,y,w,h,label);
}
void DLL_EXPORT Fl_File_InputSetDownBox(Fl_File_Input* fi, Fl_Boxtype b){
  fi->down_box(b);
}
Fl_Boxtype DLL_EXPORT Fl_File_InputGetDownBox(Fl_File_Input* fi){
  return fi->down_box();
}
void DLL_EXPORT Fl_File_InputSetErrorColor(Fl_File_Input* fi, Fl_Color c){
  fi->errorcolor(c);
}
Fl_Color DLL_EXPORT Fl_File_InputGetErrorColor(Fl_File_Input* fi){
  return fi->errorcolor();
}
int DLL_EXPORT Fl_File_InputHandle(Fl_File_Input* fi, int event){
  return fi->handle(event);
}
int DLL_EXPORT Fl_File_InputSetValue(Fl_File_Input* fi, const char* str){
  return fi->value(str);
}
int DLL_EXPORT Fl_File_InputSetValue2(Fl_File_Input* fi, const char* str, int l){
  return fi->value(str,l);
}
const char* DLL_EXPORT Fl_File_InputGetValue(Fl_File_Input* fi){
  return fi->value();
}

// 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){
  return new Fl_Float_Input(x,y,w,h,label);
}

// 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){
  return new Fl_Int_Input(x,y,w,h,label);
}

// 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){
  return new Fl_Multiline_Input(x,y,w,h,label);
}

// Fl_Output extends Fl_Input
Fl_Output* Fl_OutputNew(int x, int y, int w, int h, const char* label){
  return new Fl_Output(x,y,w,h,label);
}

// 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){
  return new Fl_Multiline_Output(x,y,w,h,label);
}

// Fl_Secret_Input extends Fl_Input
Fl_Secret_Input* Fl_Secret_InputNew(int x, int y, int w, int h, const char* label){
  return new Fl_Secret_Input(x,y,w,h,label);
}
int DLL_EXPORT Fl_Secret_InputHandle(Fl_Secret_Input* si, int event){
  return si->handle(event);
}

// class Fl_Progress
ImplementEx(Fl_Progress);
Fl_Progress* DLL_EXPORT Fl_ProgressNew(int x, int y, int w, int h, const char *label){
  return new Fl_Progress(x,y,w,h,label);
}
void DLL_EXPORT Fl_ProgressSetMaximum(Fl_Progress* prg, float v){
  prg->maximum(v);
}
float DLL_EXPORT Fl_ProgressGetMaximum(Fl_Progress* prg){
  return prg->maximum();
}
void DLL_EXPORT Fl_ProgressSetMinimum(Fl_Progress* prg, float v){
  prg->minimum(v);
}
float DLL_EXPORT Fl_ProgressGetMinimum(Fl_Progress* prg){
  return prg->minimum();
}
void DLL_EXPORT Fl_ProgressSetValue(Fl_Progress* prg, float v){
  prg->value(v);
}
float DLL_EXPORT Fl_ProgressGetValue(Fl_Progress* prg){
  return prg->value();
}

// class Fl_Valuator
void DLL_EXPORT Fl_ValuatorBounds(Fl_Valuator* va, double a, double b){
  va->bounds(a,b);
}
double DLL_EXPORT Fl_ValuatorClamp(Fl_Valuator* va, double v){
  return va->clamp(v);
}
int DLL_EXPORT Fl_ValuatorFormat(Fl_Valuator* va, char* buffer){
  return va->format(buffer);
}
double DLL_EXPORT Fl_ValuatorIncrement(Fl_Valuator* va, double v, int n){
  return va->increment(v,n);
}
void DLL_EXPORT Fl_ValuatorSetMaximum(Fl_Valuator* va, double a){
  va->maximum(a);
}
double DLL_EXPORT Fl_ValuatorGetMaximum(Fl_Valuator* va){
  return va->maximum();
}
void DLL_EXPORT Fl_ValuatorSetMinimum(Fl_Valuator* va, double a){
  va->minimum(a);
}
double DLL_EXPORT Fl_ValuatorGetMinimum(Fl_Valuator* va){
  return va->minimum();
}
void DLL_EXPORT Fl_ValuatorPrecision(Fl_Valuator* va, int p){
  va->precision(p);
}
void DLL_EXPORT Fl_ValuatorRange(Fl_Valuator* va, double a, double b){
  va->range(a,b);
}
double DLL_EXPORT Fl_ValuatorRound(Fl_Valuator* va, double v){
  return va->round(v);
}
double DLL_EXPORT Fl_ValuatorStep(Fl_Valuator* va){
  return va->step();
}
int DLL_EXPORT Fl_ValuatorSetValue(Fl_Valuator* va, double v){
  return va->value(v);
}
double DLL_EXPORT Fl_ValuatorGetValue(Fl_Valuator* va){
  return va->value();
}


// class Fl_Adjuster
ImplementEx(Fl_Adjuster);
Fl_Adjuster* DLL_EXPORT Fl_AdjusterNew(int x, int y, int w, int h, const char *label){
  return new Fl_Adjuster(x,y,w,h,label);
}
void DLL_EXPORT Fl_AdjusterSetSoft(Fl_Adjuster* adj, int s){
  adj->soft(s);
}
int DLL_EXPORT Fl_AdjusterGetSoft(Fl_Adjuster* adj){
  return adj->soft();
}

// class Fl_Counter
ImplementEx(Fl_Counter);
Fl_Counter* DLL_EXPORT Fl_CounterNew(int x, int y, int w, int h, const char *label){
  return new Fl_Counter(x,y,w,h,label);
}
int DLL_EXPORT Fl_CounterHandle(Fl_Counter* cnt, int event){
  return cnt->handle(event);
}
void DLL_EXPORT Fl_CounterLargeStep(Fl_Counter* cnt, double a){
  cnt->lstep(a);
}
void DLL_EXPORT Fl_CounterNormalStep(Fl_Counter* cnt, double a){
  cnt->step(a);
}
void DLL_EXPORT Fl_CounterStep(Fl_Counter* cnt, double a, double b){
  cnt->step(a,b);
}

// class Fl_Simple_Counter
ImplementEx(Fl_Simple_Counter);
Fl_Simple_Counter* DLL_EXPORT Fl_Simple_CounterNew(int x, int y, int w, int h, const char *label){
  return new Fl_Simple_Counter(x,y,w,h,label);
}

// class Fl_Dial
ImplementEx(Fl_Dial);
Fl_Dial* DLL_EXPORT Fl_DialNew(int x, int y, int w, int h, const char *label){
  return new Fl_Dial(x,y,w,h,label);
}
void DLL_EXPORT Fl_DialSetAngle1(Fl_Dial* dial, short a){
  dial->angle1(a);
}
short DLL_EXPORT Fl_DialGetAngle1(Fl_Dial* dial){
  return dial->angle1();
}
void DLL_EXPORT Fl_DialSetAngle2(Fl_Dial* dial, short a){
  dial->angle2(a);
}
short DLL_EXPORT Fl_DialGetAngle2(Fl_Dial* dial){
  return dial->angle2();
}
void DLL_EXPORT Fl_DialAngles(Fl_Dial* dial, short a, short b){
  dial->angles(a,b);
}
int DLL_EXPORT Fl_DialHandle(Fl_Dial* dial, int event){
  return dial->handle(event);
}

// class Fl_Fill_Dial
ImplementEx(Fl_Fill_Dial);
Fl_Fill_Dial* DLL_EXPORT Fl_Fill_DialNew(int x, int y, int w, int h, const char *label){
  return new Fl_Fill_Dial(x,y,w,h,label);
}

// class Fl_Line_Dial
ImplementEx(Fl_Line_Dial);
Fl_Line_Dial* DLL_EXPORT Fl_Line_DialNew(int x, int y, int w, int h, const char *label){
  return new Fl_Line_Dial(x,y,w,h,label);
}

// class Fl_Roller
ImplementEx(Fl_Roller);
Fl_Roller* DLL_EXPORT Fl_RollerNew(int x, int y, int w, int h, const char *label){
  return new Fl_Roller(x,y,w,h,label);
}

// class Fl_Slider extends Fl_Valuator
ImplementEx(Fl_Slider);
Fl_Slider* DLL_EXPORT Fl_SliderNew (int x, int y, int w, int h, const char* label){
  return new Fl_Slider(x,y,w,h,label);
}
Fl_Slider* DLL_EXPORT Fl_SliderNew2 (uchar t, int x, int y, int w,int h, const char* label){
  return new Fl_Slider(t,x,y,w,h,label);
}
void DLL_EXPORT Fl_SliderBounds(Fl_Slider* sl, double a, double b){
  sl->bounds(a,b);
}
int DLL_EXPORT Fl_SliderHandle(Fl_Slider* sl, int event){
  return sl->handle(event);
}
int DLL_EXPORT Fl_SliderScrollValue(Fl_Slider* sl, int pos, int size, int first, int total){
  return sl->scrollvalue(pos,size,first,total);
}
void DLL_EXPORT Fl_SliderSetSlider(Fl_Slider* sl, Fl_Boxtype c){
  sl->slider(c);
}
Fl_Boxtype DLL_EXPORT Fl_SliderGetSlider(Fl_Slider* sl){
  return sl->slider();
}
void DLL_EXPORT Fl_SliderSetSliderSize(Fl_Slider* sl, double v){
  sl->slider_size(v);
}
double DLL_EXPORT Fl_SliderGetSliderSize(Fl_Slider* sl){
  return sl->slider_size();
}

// class Fl_Hor_Fill_Slider extends Fl_Slider
ImplementEx(Fl_Hor_Slider);
Fl_Hor_Slider* DLL_EXPORT Fl_Hor_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Hor_Slider(x,y,w,h,label);
}

// class Fl_Fill_Slider extends Fl_Slider
ImplementEx(Fl_Fill_Slider);
Fl_Fill_Slider* DLL_EXPORT Fl_Fill_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Fill_Slider(x,y,w,h,label);
}

// class Fl_Hor_Fill_Slider extends Fl_Slider
ImplementEx(Fl_Hor_Fill_Slider);
Fl_Hor_Fill_Slider* DLL_EXPORT Fl_Hor_Fill_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Hor_Fill_Slider(x,y,w,h,label);
}

// class Fl_Nice_Slider extends Fl_Slider
ImplementEx(Fl_Nice_Slider);
Fl_Nice_Slider* DLL_EXPORT Fl_Nice_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Nice_Slider(x,y,w,h,label);
}

// class Fl_Hor_Nice_Slider extends Fl_Slider
ImplementEx(Fl_Hor_Nice_Slider);
Fl_Hor_Nice_Slider* DLL_EXPORT Fl_Hor_Nice_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Hor_Nice_Slider(x,y,w,h,label);
}

// class Fl_Scrollbar extends Fl_Slider
ImplementEx(Fl_Scrollbar);
Fl_Scrollbar* DLL_EXPORT Fl_ScrollbarNew(int x, int y, int w, int h, const char* label){
  return new Fl_Scrollbar(x,y,w,h,label);
}
int DLL_EXPORT Fl_ScrollbarHandle(Fl_Scrollbar* sb, int event){
  return sb->handle(event);
}
void DLL_EXPORT Fl_ScrollbarSetLineSize(Fl_Scrollbar* sb, int i){
  sb->linesize(i);
}
int DLL_EXPORT Fl_ScrollbarGetLineSize(Fl_Scrollbar* sb){
  return sb->linesize();
}
int DLL_EXPORT Fl_ScrollbarSetValue(Fl_Scrollbar* sb, int p){
  return sb->value(p);
}
int DLL_EXPORT Fl_ScrollbarGetValue(Fl_Scrollbar* sb){
  return sb->value();
}
int DLL_EXPORT Fl_ScrollbarValue(Fl_Scrollbar* sb, int pos, int windowSize, int first, int total){
  return sb->value(pos,windowSize,first,total);
}

// class Fl_Value_Slider extends Fl_Slider
ImplementEx(Fl_Value_Slider);
Fl_Value_Slider* DLL_EXPORT Fl_Value_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Value_Slider(x,y,w,h,label);
}
int DLL_EXPORT Fl_Value_SliderHandle(Fl_Value_Slider* sl,  int event){
  return sl->handle(event);
}
void DLL_EXPORT Fl_Value_SliderSetTextColor(Fl_Value_Slider* sl, Fl_Color s){
  sl->textcolor(s);
}
Fl_Color DLL_EXPORT Fl_Value_SliderGetTextColor(Fl_Value_Slider* sl){
  return sl->textcolor();
}
void DLL_EXPORT Fl_Value_SliderSetTextFont(Fl_Value_Slider* sl, Fl_Font s){
  sl->textfont(s);
}
Fl_Font DLL_EXPORT Fl_Value_SliderGetTextFont(Fl_Value_Slider* sl){
  return sl->textfont();
}
void DLL_EXPORT Fl_Value_SliderSetTextSize(Fl_Value_Slider* sl, Fl_Fontsize s){
  sl->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Value_SliderGetTextSize(Fl_Value_Slider* sl){
  return sl->textsize();
}

// class Fl_Hor_Value_Slider extends Fl_Value_Slider
ImplementEx(Fl_Hor_Value_Slider);
Fl_Hor_Value_Slider* DLL_EXPORT Fl_Hor_Value_SliderNew(int x, int y, int w, int h, const char* label){
  return new Fl_Hor_Value_Slider(x,y,w,h,label);
}

// class Fl_Value_Input extends Fl_Valuator
ImplementEx(Fl_Value_Input);
Fl_Value_Input* DLL_EXPORT Fl_Value_InputNew(int x, int y, int w, int h, const char* label){
  return new Fl_Value_Input(x,y,w,h,label);
}
void DLL_EXPORT Fl_Value_InputSetCursorColor(Fl_Value_Input* vi, Fl_Color n){
  vi->cursor_color(n);
}
Fl_Color DLL_EXPORT Fl_Value_InputGetCursorColor(Fl_Value_Input* vi){
  return vi->cursor_color();
}
int DLL_EXPORT Fl_Value_InputHandle(Fl_Value_Input* vi, int event){
  return vi->handle(event);
}
void DLL_EXPORT Fl_Value_InputResize(Fl_Value_Input* vi, int x, int y, int w, int h){
  vi->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Value_InputSetShortcut(Fl_Value_Input* vi, int s){
  vi->shortcut(s);
}
int DLL_EXPORT Fl_Value_InputGetShortcut(Fl_Value_Input* vi){
  return vi->shortcut();
}
void DLL_EXPORT Fl_Value_InputSetSoft(Fl_Value_Input* vi, int s){
  vi->soft(s);
}
int DLL_EXPORT Fl_Value_InputGetSoft(Fl_Value_Input* vi){
  return vi->soft() ;
}
void DLL_EXPORT Fl_Value_InputSetTextColor(Fl_Value_Input* vi, Fl_Color n){
  vi->textcolor(n);
}
Fl_Color DLL_EXPORT Fl_Value_InputGetTextColor(Fl_Value_Input* vi){
  return vi->textcolor();
}
void DLL_EXPORT Fl_Value_InputSetTextFont(Fl_Value_Input* vi, Fl_Font s){
  vi->textfont(s);
}
Fl_Font DLL_EXPORT Fl_Value_InputGetTextFont(Fl_Value_Input* vi){
  return vi->textfont();
}
void DLL_EXPORT Fl_Value_InputSetTextSize(Fl_Value_Input* vi, Fl_Fontsize s){
  vi->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Value_InputGetTextSize(Fl_Value_Input* vi){
  return vi->textsize();
}

// class Fl_Value_Output extends Fl_Valuator
ImplementEx(Fl_Value_Output);
Fl_Value_Output* DLL_EXPORT Fl_Value_OutputNew(int x, int y, int w, int h, const char* label){
  return new Fl_Value_Output(x,y,w,h,label);
}
int DLL_EXPORT Fl_Value_OutputHandle(Fl_Value_Output* vi, int event){
  return vi->handle(event);
}
void DLL_EXPORT Fl_Value_OutputResize(Fl_Value_Output* vi, int x, int y, int w, int h){
  vi->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Value_OutputSetSoft(Fl_Value_Output* vi, int s){
  vi->soft(s);
}
int DLL_EXPORT Fl_Value_OutputGetSoft(Fl_Value_Output* vi){
  return vi->soft() ;
}
void DLL_EXPORT Fl_Value_OutputSetTextColor(Fl_Value_Output* vi, Fl_Color n){
  vi->textcolor(n);
}
Fl_Color DLL_EXPORT Fl_Value_OutputGetTextColor(Fl_Value_Output* vi){
  return vi->textcolor();
}
void DLL_EXPORT Fl_Value_OutputSetTextFont(Fl_Value_Output* vi, Fl_Font s){
  vi->textfont(s);
}
Fl_Font DLL_EXPORT Fl_Value_OutputGetTextFont(Fl_Value_Output* vi){
  return vi->textfont();
}
void DLL_EXPORT Fl_Value_OutputSetTextSize(Fl_Value_Output* vi, Fl_Fontsize s){
  vi->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Value_OutputGetTextSize(Fl_Value_Output* vi){
  return vi->textsize();
}

// class Fl_Group
ImplementEx(Fl_Group);
Fl_Group* DLL_EXPORT Fl_GroupNew(int x, int y, int w, int h, const char* label){
  return new Fl_Group(x,y,w,h,label);
}
void DLL_EXPORT Fl_GroupAdd(Fl_Group* grp, Fl_Widget *o){
  grp->add(o);
}
void DLL_EXPORT Fl_GroupAddResizable(Fl_Group* grp, Fl_Widget &o){
  grp->add_resizable(o);
}
Fl_Group* DLL_EXPORT Fl_GroupAsGroup(Fl_Group* grp){
  return grp->as_group();
}
void DLL_EXPORT Fl_GroupBegin(Fl_Group* grp){
  grp->begin();
}
Fl_Widget* DLL_EXPORT Fl_GroupChild(Fl_Group* grp, int n){
  return grp->child(n);
}
int DLL_EXPORT Fl_GroupChildren(Fl_Group* grp){
  return grp->children();
}
void DLL_EXPORT Fl_GroupClear(Fl_Group* grp){
  grp->clear();
}
void DLL_EXPORT Fl_GroupSetClipChildren(Fl_Group* grp, int c){
  grp->clip_children(c);
}
int DLL_EXPORT Fl_GroupGetClipChildren(Fl_Group* grp){
  return grp->clip_children();
}
void DLL_EXPORT Fl_GroupEnd(Fl_Group* grp){
  grp->end();
}
int DLL_EXPORT Fl_GroupFind (Fl_Group* grp, const Fl_Widget* wgt){
  return grp->find(wgt);
}
void DLL_EXPORT Fl_GroupFormsEnd(Fl_Group* grp){
  grp->forms_end();
}
int DLL_EXPORT Fl_GroupHandle(Fl_Group* grp, int ev){
  return grp->handle(ev);
}
void DLL_EXPORT Fl_GroupInitSizes(Fl_Group* grp){
  grp->init_sizes();
}
void DLL_EXPORT Fl_GroupInsert(Fl_Group* grp, Fl_Widget& o, Fl_Widget* before){
  grp->insert(o,before);
}
void DLL_EXPORT Fl_GroupInsert2(Fl_Group* grp, Fl_Widget& o, int i){
  grp->insert(o,i);
}
void DLL_EXPORT Fl_GroupRemove(Fl_Group* grp, int index){
  grp->remove(index);
}
void DLL_EXPORT Fl_GroupRemove2(Fl_Group* grp, Fl_Widget* o){
  grp->remove(o);
}
Fl_Widget* DLL_EXPORT Fl_GroupGetResizable(Fl_Group* grp){
  return grp->resizable();
}
void DLL_EXPORT Fl_GroupSetResizable(Fl_Group* grp, Fl_Widget* o){
  grp->resizable(o);
}
void DLL_EXPORT Fl_GroupResize(Fl_Group* grp, int x, int y, int w, int h){
  grp->resize(x,y,w,h);
}
// class Fl_Pack extends Fl_Group
ImplementEx(Fl_Pack);
Fl_Pack* DLL_EXPORT Fl_PackNew(int x, int y, int w, int h, const char* label){
  return new Fl_Pack(x,y,w,h,label);
}
void DLL_EXPORT Fl_PackSetSpacing(Fl_Pack* pk, int i){
  pk->spacing(i);
}
int DLL_EXPORT Fl_PackGetSpacing(Fl_Pack* pk){
  return pk->spacing();
}

// class Fl_Tile extends Fl_Group
Fl_Tile* DLL_EXPORT Fl_TileNew(int x, int y, int w, int h, const char* label){
  return new Fl_Tile(x,y,w,h,label);
}
int DLL_EXPORT Fl_TileHandle(Fl_Tile* til, int event){
  return til->handle(event);
}
void DLL_EXPORT Fl_TilePosition(Fl_Tile* til, int from_x, int from_y, int to_x, int to_y){
  til->position(from_x,from_y,to_x,to_y);
}
void DLL_EXPORT Fl_TileResize(Fl_Tile* til, int x, int y, int w, int h){
  til->resize(x,y,w,h);
}

// class Fl_Scroll extends Fl_Group
ImplementEx(Fl_Scroll);
Fl_Scroll* DLL_EXPORT Fl_ScrollNew(int x, int y, int w, int h, const char* label) {
  return new Fl_Scroll(x,y,w,h,label);
}
void DLL_EXPORT Fl_ScrollClear(Fl_Scroll* sc){
  sc->clear();
}
int DLL_EXPORT Fl_ScrollHandle(Fl_Scroll* sc, int event){
  return sc->handle(event);
}
void DLL_EXPORT Fl_ScrollResize(Fl_Scroll* sc, int x, int y, int w, int h){
  sc->resize(x,y,w,h);
}
void DLL_EXPORT Fl_ScrollScrollTo(Fl_Scroll* sc, int x, int y){
  sc->scroll_to(x,y);
}
void DLL_EXPORT Fl_ScrollSetScrollbarSize(Fl_Scroll* sc, int newSize){
  sc->scrollbar_size(newSize);
}
int DLL_EXPORT Fl_ScrollGetScrollbarSize(Fl_Scroll* sc){
  return sc->scrollbar_size();
}
int DLL_EXPORT Fl_ScrollXPosition(Fl_Scroll* sc){
  return sc->xposition();
}
int DLL_EXPORT Fl_ScrollYPosition(Fl_Scroll* sc){
  return sc->yposition();
}

// class Fl_Browser_ extends Fl_Group
int DLL_EXPORT Fl_Browser_Deselect(Fl_Browser_* br, int docallbacks){
  return br->deselect(docallbacks);
}
void DLL_EXPORT Fl_Browser_Display(Fl_Browser_* br, void* item){
  br->display(item);
}
int DLL_EXPORT Fl_Browser_Handle(Fl_Browser_* br, int event){
  return br->handle(event);
}
void DLL_EXPORT Fl_Browser_SetHasScrollbar(Fl_Browser_* br, uchar mode){
  br->has_scrollbar(mode);
}
uchar DLL_EXPORT Fl_Browser_GetHasSscrollbar(Fl_Browser_* br){
  return br->has_scrollbar();
}
void DLL_EXPORT Fl_Browser_SetHPosition(Fl_Browser_* br, int p){
  br->hposition(p);
}
int DLL_EXPORT Fl_Browser_GetHPosition(Fl_Browser_* br){
  return br->hposition();
}
void DLL_EXPORT Fl_Browser_SetPosition(Fl_Browser_* br, int p){
  br->position(p);
}
int DLL_EXPORT Fl_Browser_GetPosition(Fl_Browser_* br){
  return br->position();
}
void DLL_EXPORT Fl_Browser_Resize(Fl_Browser_* br, int x, int y, int w, int h){
  br->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Browser_ScrollbarLeft(Fl_Browser_* br){
  br->scrollbar_left();
}
void DLL_EXPORT Fl_Browser_ScrollbarRight(Fl_Browser_* br){
  br->scrollbar_right();
}
void DLL_EXPORT Fl_Browser_SetScrollbarSize(Fl_Browser_* br, int s){
  br->scrollbar_size(s);
}
int DLL_EXPORT Fl_Browser_GetScrollbarSize(Fl_Browser_* br){
  return br->scrollbar_size();
}
void DLL_EXPORT Fl_Browser_SetScrollbarWidth(Fl_Browser_* br, int w){
  br->scrollbar_width(w);
}
int DLL_EXPORT Fl_Browser_GetScrollbarWidth(Fl_Browser_* br){
  return br->scrollbar_width();
}
int DLL_EXPORT Fl_Browser_Select(Fl_Browser_* br, void* item, int v, int docallbacks){
  return br->select(item,v,docallbacks);
}
int DLL_EXPORT Fl_Browser_SelectOnly(Fl_Browser_* br, void* item, int docallbacks){
  return br->select_only(item,docallbacks);
}
void DLL_EXPORT Fl_Browser_Sort(Fl_Browser_* br, int flags){
  br->sort(flags);
}
void DLL_EXPORT Fl_Browser_SetTextColor(Fl_Browser_* br, Fl_Color c){
  br->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Browser_GetTextColor(Fl_Browser_* br){
  return br->textcolor();
}
void DLL_EXPORT Fl_Browser_SetTextFont(Fl_Browser_* br, Fl_Font f){
  br->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Browser_GetTextFont(Fl_Browser_* br){
  return br->textfont();
}
void DLL_EXPORT Fl_Browser_SetTextsize(Fl_Browser_* br, Fl_Fontsize fs){
  br->textsize(fs);
}
Fl_Fontsize DLL_EXPORT Fl_Browser_GetTextsize(Fl_Browser_* br){
  return br->textsize();
}

// 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){
  return new Fl_Check_Browser(x,y,w,h,label);
}
int DLL_EXPORT Fl_Check_BrowserAdd(Fl_Check_Browser* cb, char *s){
  return cb->add(s);
}
int DLL_EXPORT Fl_Check_BrowserAdd2(Fl_Check_Browser* cb, char *s, int b){
  return cb->add(s,b);
}
void DLL_EXPORT Fl_Check_BrowserCheckAll(Fl_Check_Browser* cb){
  cb->check_all();
}
void DLL_EXPORT Fl_Check_BrowserCheckNone(Fl_Check_Browser* cb){
  cb->check_none();
}
void DLL_EXPORT Fl_Check_BrowserChecked(Fl_Check_Browser* cb, int item, int b){
  cb->checked(item,b);
}
void DLL_EXPORT Fl_Check_BrowserClear(Fl_Check_Browser* cb){
  cb->clear();
}
int DLL_EXPORT Fl_Check_BrowserNChecked(Fl_Check_Browser* cb){
  return cb->nchecked();
}
int DLL_EXPORT Fl_Check_BrowserNItems(Fl_Check_Browser* cb){
  return cb->nitems();
}
int DLL_EXPORT Fl_Check_BrowserRemove(Fl_Check_Browser* cb, int item){
  return cb->remove(item);
}
void DLL_EXPORT Fl_Check_BrowserSetChecked(Fl_Check_Browser* cb, int item){
  cb->set_checked(item);
}
int DLL_EXPORT Fl_Check_BrowserGetChecked(Fl_Check_Browser* cb, int item){
  return cb->checked(item);
}
char* DLL_EXPORT Fl_Check_BrowserText(Fl_Check_Browser* cb, int item){
  return cb->text(item);
}
int DLL_EXPORT Fl_Check_BrowserValue(Fl_Check_Browser* cb){
  return cb->value();
}


// class Fl_Browser extends Fl_Browser_
ImplementEx(Fl_Browser);
Fl_Browser* DLL_EXPORT Fl_BrowserNew(int x, int y, int w, int h, const char* label){
  return new Fl_Browser(x,y,w,h,label);
}
void DLL_EXPORT Fl_BrowserAdd(Fl_Browser* br, const char* newtext, void* d){
  br->add(newtext,d);
}
void DLL_EXPORT Fl_BrowserBottomLine(Fl_Browser* br, int line){
  br->bottomline(line);
}
void DLL_EXPORT Fl_BrowserClear(Fl_Browser* br){
  br->clear();
}
void DLL_EXPORT Fl_BrowserSetColumnChar(Fl_Browser* br, char c){
  br->column_char(c);
}
char DLL_EXPORT Fl_BrowserGetColumnChar(Fl_Browser* br){
  return br->column_char();
}
void DLL_EXPORT Fl_BrowserSetColumnWidths(Fl_Browser* br, const int* arr){
  br->column_widths(arr);
}
const int* DLL_EXPORT Fl_BrowserGetColumnWidths(Fl_Browser* br){
  return br->column_widths();
}
void DLL_EXPORT Fl_BrowserSetData(Fl_Browser* br, int line, void* d){
  br->data(line,d);
}
void* DLL_EXPORT Fl_BrowserGetData(Fl_Browser* br, int line){
  return br->data(line);
}
void DLL_EXPORT Fl_BrowserDisplay(Fl_Browser* br, int line, int v){
  br->display(line,v);
}
int DLL_EXPORT Fl_BrowserDisplayed(Fl_Browser* br, int line){
  return br->displayed(line);
}
void DLL_EXPORT Fl_BrowserSetFormatChar(Fl_Browser* br, char c){
  br->format_char(c);
}
char DLL_EXPORT Fl_BrowserGetFormatChar(Fl_Browser* br){
  return br->format_char();
}
void DLL_EXPORT Fl_BrowserHide(Fl_Browser* br){
  br->hide();
}
void DLL_EXPORT Fl_BrowserHide2(Fl_Browser* br, int line){
  br->hide(line);
}
void DLL_EXPORT Fl_BrowserSetIcon(Fl_Browser* br, int line, Fl_Image* icon){
  br->icon(line,icon);
}
Fl_Image* DLL_EXPORT Fl_BrowserGetIcon(Fl_Browser* br, int line){
  return br->icon(line);
}
void DLL_EXPORT Fl_BrowserInsert(Fl_Browser* br, int line, const char* newtext, void* d){
  br->insert(line,newtext,d);
}
void DLL_EXPORT Fl_BrowserLinePosition(Fl_Browser* br, int line, Fl_Browser::Fl_Line_Position pos){
  br->lineposition(line,pos);
}
int DLL_EXPORT Fl_BrowserLoad(Fl_Browser* br, const char* filename){
  return br->load(filename);
}
void DLL_EXPORT Fl_BrowserMakeVisible(Fl_Browser* br, int line){
  br->make_visible(line);
}
void DLL_EXPORT Fl_BrowserMiddleLine(Fl_Browser* br, int line){
  br->middleline(line);
}
void DLL_EXPORT Fl_BrowserMove(Fl_Browser* br, int to, int from){
  br->move(to,from);
}
void DLL_EXPORT Fl_BrowserRemove(Fl_Browser* br, int line){
  br->remove(line);
}
void DLL_EXPORT Fl_BrowserRemoveIcon(Fl_Browser* br, int line){
  br->remove_icon(line);
}
void DLL_EXPORT Fl_BrowserReplace(Fl_Browser* br, int a, const char* b){
  br->replace(a,b);
}
int DLL_EXPORT Fl_BrowserSelect(Fl_Browser* br, int line, int v){
  return br->select(line,v);
}
int DLL_EXPORT Fl_BrowserSelected(Fl_Browser* br, int line){
  return br->selected(line);
}
void DLL_EXPORT Fl_BrowserShow(Fl_Browser* br){
  br->show();
}
void DLL_EXPORT Fl_BrowserShow2(Fl_Browser* br, int line){
  br->show(line);
}
void DLL_EXPORT Fl_BrowserSetSize(Fl_Browser* br, int w, int h){
  br->size(w,h);
}
int DLL_EXPORT Fl_BrowserGetSize(Fl_Browser* br){
  return br->size();
}
void DLL_EXPORT Fl_BrowserSwap(Fl_Browser* br, int a, int b){
  br->swap(a,b);
}
void DLL_EXPORT Fl_BrowserSetText(Fl_Browser* br, int line, const char* newtext){
  br->text(line,newtext);
}
const char* DLL_EXPORT Fl_BrowserGetText(Fl_Browser* br, int line){
  return br->text(line);
}
void DLL_EXPORT Fl_BrowserSetTopline(Fl_Browser* br, int line){
  br->topline(line);
}
int DLL_EXPORT Fl_BrowserGetTopline(Fl_Browser* br){
  return br->topline();
}
void DLL_EXPORT Fl_BrowserSetValue(Fl_Browser* br, int line){
  br->value(line);
}
int DLL_EXPORT Fl_BrowserGetValue(Fl_Browser* br){
  return br->value();
}
int DLL_EXPORT Fl_BrowserVisible(Fl_Browser* br, int line){
  return br->visible(line);
}

// class Fl_File_Browser extends Fl_Browser
ImplementEx(Fl_File_Browser);
Fl_File_Browser* DLL_EXPORT Fl_File_BrowserNew(int x, int y, int w, int h, const char* label){
  return new Fl_File_Browser(x,y,w,h,label);
}
void DLL_EXPORT Fl_File_BrowserSetFiletype(Fl_File_Browser* fb, int t){
  fb->filetype(t);
}
int DLL_EXPORT Fl_File_BrowserGetFiletype(Fl_File_Browser* fb){
  return fb->filetype();
}
void DLL_EXPORT Fl_File_BrowserSetFilter(Fl_File_Browser* fb, const char* pattern){
  fb->filter(pattern);
}
const char* DLL_EXPORT Fl_File_BrowserGetFilter(Fl_File_Browser* fb){
  return fb->filter();
}
void DLL_EXPORT Fl_File_BrowserSetIconSize(Fl_File_Browser* fb, uchar s){
  fb->iconsize(s);
}
uchar DLL_EXPORT Fl_File_BrowserGetIconSize(Fl_File_Browser* fb){
  return fb->iconsize();
}
int DLL_EXPORT Fl_File_BrowserLoad(Fl_File_Browser* fb, const char* directory){
  return fb->load(directory, fl_numericsort);
}
void DLL_EXPORT Fl_File_BrowserSetTextSize(Fl_File_Browser* fb, Fl_Fontsize s){
  fb->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_File_BrowserGetTextSize(Fl_File_Browser* fb){
  return fb->textsize();
}

// class Fl_Hold_Browser extends Fl_Browser
ImplementEx(Fl_Hold_Browser);
Fl_Hold_Browser* DLL_EXPORT Fl_Hold_BrowserNew(int x, int y, int w, int h, const char* label){
  return new Fl_Hold_Browser(x,y,w,h,label);
}

// class Fl_Multi_Browser extends Fl_Browser
ImplementEx(Fl_Multi_Browser);
Fl_Multi_Browser* DLL_EXPORT Fl_Multi_BrowserNew(int x, int y, int w, int h, const char* label){
  return new Fl_Multi_Browser(x,y,w,h,label);
}

// class Fl_Select_Browser extends Fl_Browser
ImplementEx(Fl_Select_Browser);
Fl_Select_Browser* DLL_EXPORT Fl_Select_BrowserNew(int x, int y, int w, int h, const char* label){
  return new Fl_Select_Browser(x,y,w,h,label);
}

// class Fl_Color_Chooser extends Fl_Group
ImplementEx(Fl_Color_Chooser);
Fl_Color_Chooser* DLL_EXPORT Fl_Color_ChooserNew(int x, int y, int w, int h, const char* label){
  return new Fl_Color_Chooser(x,y,w,h,label);
}

void DLL_EXPORT Fl_Color_ChooserSetMode(Fl_Color_Chooser* cc, int newMode){
  cc->mode(newMode);
}
int DLL_EXPORT Fl_Color_ChooserGetMode(Fl_Color_Chooser* cc){
  return cc->mode();
}

int DLL_EXPORT Fl_Color_ChooserRGB(Fl_Color_Chooser* cc, double r, double g, double b){
  return cc->rgb(r,g,b);
}
double DLL_EXPORT Fl_Color_ChooserR(Fl_Color_Chooser* cc){
  return cc->r();
}
double DLL_EXPORT Fl_Color_ChooserG(Fl_Color_Chooser* cc){
  return cc->g();
}
double DLL_EXPORT Fl_Color_ChooserB(Fl_Color_Chooser* cc){
  return cc->b();
}

int DLL_EXPORT Fl_Color_ChooserHSV(Fl_Color_Chooser* cc, double h, double s, double v){
  return cc->hsv(h,s,v);
}
double DLL_EXPORT Fl_Color_ChooserHue(Fl_Color_Chooser* cc){
  return cc->h();
}
double DLL_EXPORT Fl_Color_ChooserSaturation(Fl_Color_Chooser* cc){
  return cc->saturation();
}
double DLL_EXPORT Fl_Color_ChooserValue(Fl_Color_Chooser* cc){
  return cc->value();
}
void DLL_EXPORT Fl_Color_ChooserHSV2RGB(Fl_Color_Chooser* cc, double h, double s, double v, double &r, double &g, double &b){
  cc->hsv2rgb(h,s,v,r,g,b);
}
void DLL_EXPORT Fl_Color_ChooserRGB2HSV(Fl_Color_Chooser* cc, double r, double g, double b, double &h, double &s, double &v){
  cc->rgb2hsv(r,g,b,h,s,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){
  return new Fl_Help_View(x,y,w,h,label);
}
void DLL_EXPORT Fl_Help_ViewClearSelection(Fl_Help_View* hv){
  hv->clear_selection();
}
const char* DLL_EXPORT Fl_Help_ViewDirectory(Fl_Help_View* hv){
  return hv->directory();
}
const char* DLL_EXPORT Fl_Help_ViewFilename(Fl_Help_View* hv){
  return hv->filename();
}
int DLL_EXPORT Fl_Help_ViewFind(Fl_Help_View* hv, const char *s, int p){
  return hv->find(s,p);
}
void DLL_EXPORT Fl_Help_ViewSetLeftLine(Fl_Help_View* hv,int ll){
  hv->leftline(ll);
}
int DLL_EXPORT Fl_Help_ViewGetLeftLine(Fl_Help_View* hv){
  return hv->leftline();
}
void DLL_EXPORT Fl_Help_ViewLink(Fl_Help_View* hv, Fl_Help_Func *fn){
  hv->link(fn);
}
int DLL_EXPORT Fl_Help_ViewLoad(Fl_Help_View* hv,const char* filename){
  return hv->load(filename);
}
void DLL_EXPORT Fl_Help_ViewResize(Fl_Help_View* hv, int x, int y, int w, int h){
  hv->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Help_ViewSetScrollbarSize(Fl_Help_View* hv, int s){
  hv->scrollbar_size(s);
}
int DLL_EXPORT Fl_Help_ViewGetScrollbarSize(Fl_Help_View* hv){
  return hv->scrollbar_size();
}
void DLL_EXPORT Fl_Help_ViewSelectAll(Fl_Help_View* hv){
  hv->select_all();
}
void DLL_EXPORT Fl_Help_ViewSetSize(Fl_Help_View* hv, int w, int h){
  hv->size(w,h);
}
int DLL_EXPORT Fl_Help_ViewGetSize(Fl_Help_View* hv){
  return hv->size();
}
void DLL_EXPORT Fl_Help_ViewSetTextColor(Fl_Help_View* hv, Fl_Color c){
  hv->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Help_ViewGetTextColor(Fl_Help_View* hv){
  return hv->textcolor();
}
void DLL_EXPORT Fl_Help_ViewSetTextFont(Fl_Help_View* hv, Fl_Font f){
  hv->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Help_ViewGetTextFont(Fl_Help_View* hv){
  return hv->textfont();
}
void DLL_EXPORT Fl_Help_ViewSetTextSize(Fl_Help_View* hv, Fl_Fontsize s){
  hv->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Help_ViewGetTextSize(Fl_Help_View* hv){
  return hv->textsize();
}
const char* DLL_EXPORT Fl_Help_ViewTitle(Fl_Help_View* hv){
  return hv->title();
}
void DLL_EXPORT Fl_Help_ViewTopline(Fl_Help_View* hv, const char* name){
  hv->topline(name);
}
void DLL_EXPORT Fl_Help_ViewSetTopline(Fl_Help_View* hv, int pixel){
  hv->topline(pixel);
}
int DLL_EXPORT Fl_Help_ViewGetTopline(Fl_Help_View* hv){
  return hv->topline();
}
void DLL_EXPORT Fl_Help_ViewSetValue(Fl_Help_View* hv, const char* v){
  hv->value(v);
}
const char* DLL_EXPORT Fl_Help_ViewGetValue(Fl_Help_View* hv){
  return hv->value();
}


// class Fl_Input_Choice extends Fl_Group
ImplementEx(Fl_Input_Choice);
Fl_Input_Choice* DLL_EXPORT Fl_Input_ChoiceNew(int x,int y,int w,int h,const char* title){
  return new Fl_Input_Choice(x,y,w,h,title);
}
void DLL_EXPORT Fl_Input_ChoiceAdd(Fl_Input_Choice* ic, const char* s){
  ic->add(s);
}
int DLL_EXPORT Fl_Input_ChoiceChanged(Fl_Input_Choice* ic){
  return ic->changed();
}
void DLL_EXPORT Fl_Input_ChoiceClear(Fl_Input_Choice* ic){
  ic->clear();
}
void DLL_EXPORT Fl_Input_ChoiceClearChanged(Fl_Input_Choice* ic){
  ic->clear_changed();
}
void DLL_EXPORT Fl_Input_ChoiceSetDownBox(Fl_Input_Choice* ic, Fl_Boxtype b){
  ic->down_box(b);
}
Fl_Boxtype DLL_EXPORT Fl_Input_ChoiceGetDownBox(Fl_Input_Choice* ic){
  return ic->down_box();
}
Fl_Input* DLL_EXPORT Fl_Input_ChoiceInput(Fl_Input_Choice* ic){
  return ic->input();
}
void DLL_EXPORT Fl_Input_ChoiceSetMenu(Fl_Input_Choice* ic, const Fl_Menu_Item* m){
  ic->menu(m);
}
const Fl_Menu_Item* DLL_EXPORT Fl_Input_ChoiceGetMenu(Fl_Input_Choice* ic){
  return ic->menu();
}
Fl_Menu_Button* DLL_EXPORT Fl_Input_ChoiceMenuButton(Fl_Input_Choice* ic){
  return ic->menubutton();
}
void DLL_EXPORT Fl_Input_ChoiceResize(Fl_Input_Choice* ic, int x, int y, int w, int h){
  ic->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Input_ChoiceSetChanged(Fl_Input_Choice* ic){
  ic->set_changed();
}
void DLL_EXPORT Fl_Input_ChoiceSetTextColor(Fl_Input_Choice* ic, Fl_Color c){
  ic->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Input_ChoiceGetTextColor(Fl_Input_Choice* ic){
  return ic->textcolor();
}
void DLL_EXPORT Fl_Input_ChoiceSetTextFont(Fl_Input_Choice* ic, Fl_Font f){
  ic->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Input_ChoiceGetTextFont(Fl_Input_Choice* ic){
  return ic->textfont();
}
void DLL_EXPORT Fl_Input_ChoiceSetTextSize(Fl_Input_Choice* ic, Fl_Fontsize s){
  ic->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Input_ChoiceGetTextSize(Fl_Input_Choice* ic){
  return ic->textsize();
}
void DLL_EXPORT Fl_Input_ChoiceValue(Fl_Input_Choice* ic, int val){
  ic->value(val);
}
void DLL_EXPORT Fl_Input_ChoiceSetValue(Fl_Input_Choice* ic, const char* v){
  ic->value(v);
}
const char* DLL_EXPORT Fl_Input_ChoiceGetValue(Fl_Input_Choice* ic){
  return ic->value();
}


// class Fl_Spinner extends Fl_Group
ImplementEx(Fl_Spinner);
Fl_Spinner* DLL_EXPORT Fl_SpinnerNew(int x, int y, int w, int h, const char* label){
  return new Fl_Spinner(x,y,w,h,label);
}
void DLL_EXPORT Fl_SpinnerSetColor(Fl_Spinner* spi, Fl_Color v){
  spi->color(v);
}
Fl_Color DLL_EXPORT Fl_SpinnerGetColor(Fl_Spinner* spi){
  return spi->color();
}
void DLL_EXPORT Fl_SpinnerSetFormat(Fl_Spinner* spi, const char* f){
  spi->format(f);
}
const char* DLL_EXPORT Fl_SpinnerGetFormat(Fl_Spinner* spi){
  return spi->format();
}
int DLL_EXPORT Fl_SpinnerHandle(Fl_Spinner* spi, int event){
  return spi->handle(event);
}
void DLL_EXPORT Fl_SpinnerSetMaximum(Fl_Spinner* spi, double m){
  spi->maximum(m);
}
double DLL_EXPORT Fl_SpinnerGetMaximum(Fl_Spinner* spi){
  return spi->maximum();
}
void DLL_EXPORT Fl_SpinnerSetMinimum(Fl_Spinner* spi, double m){
  spi->minimum(m);
}
double DLL_EXPORT Fl_SpinnerGetMinimum(Fl_Spinner* spi){
  return spi->minimum();
}
void DLL_EXPORT Fl_SpinnerRange(Fl_Spinner* spi, double a, double b){
  spi->range(a,b);
}
void DLL_EXPORT Fl_SpinnerResize(Fl_Spinner* spi, int x, int y, int w, int h){
  spi->resize(x,y,w,h);
}
void DLL_EXPORT Fl_SpinnerSetStep(Fl_Spinner* spi, double s){
  spi->step(s);
}
double DLL_EXPORT Fl_SpinnerGetStep(Fl_Spinner* spi){
  return spi->step();
}
void DLL_EXPORT Fl_SpinnerSetTextColor(Fl_Spinner* spi, Fl_Color c){
  spi->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_SpinnerGetTextColor(Fl_Spinner* spi){
  return spi->textcolor();
}
void DLL_EXPORT Fl_SpinnerSetTextFont(Fl_Spinner* spi, Fl_Font f){
  spi->textfont(f);
}
Fl_Font DLL_EXPORT Fl_SpinnerGetTextFont(Fl_Spinner* spi){
  return spi->textfont();
}
void DLL_EXPORT Fl_SpinnerSetTextSize(Fl_Spinner* spi, Fl_Fontsize s){
  spi->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_SpinnerGetTextSize(Fl_Spinner* spi){
  return spi->textsize();
}
void DLL_EXPORT Fl_SpinnerSetType(Fl_Spinner* spi, uchar v){
  spi->type(v);
}
uchar DLL_EXPORT Fl_SpinnerGetType(Fl_Spinner* spi){
  return spi->type();
}
void DLL_EXPORT Fl_SpinnerSetValue(Fl_Spinner* spi, double v){
  spi->value(v);
}
double DLL_EXPORT Fl_SpinnerGetValue(Fl_Spinner* spi){
  return spi->value();
}

// class Fl_Table extends Fl_Group
Fl_Table* DLL_EXPORT Fl_TableNew(int x, int y, int w, int h, const char* label){
  return new Fl_Table(x,y,w,h,label);
}
void DLL_EXPORT Fl_TableAdd(Fl_Table* t, Fl_Widget* wgt){
  t->add(wgt);
}
Fl_Widget* const* DLL_EXPORT Fl_TableArray(Fl_Table* t){
  return t->array();
}
void DLL_EXPORT Fl_TableBegin(Fl_Table* t){
  t->begin();
}

int DLL_EXPORT Fl_TableCallbackCol(Fl_Table* t){
  return t->callback_col();
}
Fl_Table::TableContext DLL_EXPORT Fl_TableCallbackContext(Fl_Table* t){
  return t->callback_context();
}
int DLL_EXPORT Fl_TableCallbackRow(Fl_Table* t){
  return t->callback_row();
}
Fl_Widget* DLL_EXPORT Fl_TableChild(Fl_Table* t, int n){
  return t->child(n);
}
int DLL_EXPORT Fl_TableChildren(Fl_Table* t){
  return t->children();
}
void DLL_EXPORT Fl_TableClear(Fl_Table* t){
  t->clear();
}
void DLL_EXPORT Fl_TableSetColHeader(Fl_Table* t, int flag){
  t->col_header(flag);
}
int DLL_EXPORT Fl_TableGetColHeader(Fl_Table* t){
  return t->col_header();
}
void DLL_EXPORT Fl_TableSetColHeaderColor(Fl_Table* t, Fl_Color c){
  t->col_header_color(c);
}
Fl_Color DLL_EXPORT Fl_TableGetColHeaderColor(Fl_Table* t){
  return t->col_header_color();
}
void DLL_EXPORT Fl_TableSetColHeaderHeight(Fl_Table* t, int h){
  t->col_header_height(h);
}
int DLL_EXPORT Fl_TableGetColHeaderHeight(Fl_Table* t){
  return t->col_header_height();
}
void DLL_EXPORT Fl_TableSetColPosition(Fl_Table* t, int c){
  t->col_position(c);
}
int DLL_EXPORT Fl_TableGetColPosition(Fl_Table* t){
  return t->col_position();
}
void DLL_EXPORT Fl_TableSetColResize(Fl_Table* t, int flag){
  t->col_resize(flag);
}
int DLL_EXPORT Fl_TableGetColResize(Fl_Table* t){
  return t->col_resize();
}
void DLL_EXPORT Fl_TableSetColResizeMin(Fl_Table* t,int m){
  t->col_resize_min(m);
}
int DLL_EXPORT Fl_TableGetColResizeMin(Fl_Table* t){
  return t->col_resize_min();
}
void DLL_EXPORT Fl_TableSetColWidth(Fl_Table* t, int c, int w){
  t->col_width(c,w);
}
int DLL_EXPORT Fl_TableGetColWidth(Fl_Table* t,int c){
  return t->col_width(c);
}
void DLL_EXPORT Fl_TableColWidthAll(Fl_Table* t,int w){
  t->col_width_all(w);
}
void DLL_EXPORT Fl_TableSetCols(Fl_Table* t,int c){
  t->cols(c);
}
int DLL_EXPORT Fl_TableGetCols(Fl_Table* t){
  return t->cols();
}
void DLL_EXPORT Fl_TableDoCallback(Fl_Table* t, Fl_Table::TableContext context, int r, int c){
  t->do_callback(context,r,c);
}
void DLL_EXPORT Fl_TableDraw(Fl_Table* t){
  t->draw();
}
void DLL_EXPORT Fl_TableEnd(Fl_Table* t){
  t->end();
}
int DLL_EXPORT Fl_TableFind(Fl_Table* t,const Fl_Widget* wgt){
  return t->find(wgt);
}
void DLL_EXPORT Fl_TableGetSelection(Fl_Table* t, int &row_top, int &col_left, int &row_bot, int &col_right){
  t->get_selection(row_top,col_left,row_bot,col_right);
}
void DLL_EXPORT Fl_TableInitSizes(Fl_Table* t){
  t->init_sizes();
}
void DLL_EXPORT Fl_TableInsert(Fl_Table* t, Fl_Widget& wgt, int n){
  t->insert(wgt,n);
}
void DLL_EXPORT Fl_TableInsert2(Fl_Table* t, Fl_Widget& wgt, Fl_Widget *w2){
  t->insert(wgt,w2);
}
int DLL_EXPORT Fl_TableIsInteractiveResize(Fl_Table* t){
  return t->is_interactive_resize();
}
int DLL_EXPORT Fl_TableIsSelected(Fl_Table* t, int r, int c){
  return t->is_selected(r,c);
}
int DLL_EXPORT Fl_TableMoveCursor(Fl_Table* t, int r, int c){
  return t->move_cursor(r,c);
}
void DLL_EXPORT Fl_TableRemove(Fl_Table* t, Fl_Widget& wgt){
  t->remove(wgt);
}
void DLL_EXPORT Fl_TableResize(Fl_Table* t,int x, int y, int w, int h){
  t->resize(x,y,w,h);
}
void DLL_EXPORT Fl_TableSetRowHeader(Fl_Table* t, int flag){
  t->row_header(flag);
}
int DLL_EXPORT Fl_TableGetRowHeader(Fl_Table* t){
  return t->row_header();
}
void DLL_EXPORT Fl_TableSetRowHeaderColor(Fl_Table* t, Fl_Color c){
  t->row_header_color(c);
}
Fl_Color DLL_EXPORT Fl_TableGetRowHeaderColor(Fl_Table* t){
  return t->row_header_color();
}
void DLL_EXPORT Fl_TableSetRowHeaderWidth(Fl_Table* t,int w){
  t->row_header_width(w);
}
int DLL_EXPORT Fl_TableGetRowHeaderWidth(Fl_Table* t){
  return t->row_header_width();
}
void DLL_EXPORT Fl_TableSetRowHeight(Fl_Table* t,int r, int h){
  t->row_height(r,h);
}
int DLL_EXPORT Fl_TableGetRowHeight(Fl_Table* t,int r){
  return t->row_height(r);
}
void DLL_EXPORT Fl_TableRowHeightAll(Fl_Table* t,int h){
  t->row_height_all(h);
}
void DLL_EXPORT Fl_TableSetRowPosition(Fl_Table* t,int p){
  t->row_position(p);
}
int DLL_EXPORT Fl_TableGetRowPosition(Fl_Table* t){
  return t->row_position();
}
void DLL_EXPORT Fl_TableSetRowResize(Fl_Table* t, int flag){
  t->row_resize(flag);
}
int DLL_EXPORT Fl_TableGetRowResize(Fl_Table* t){
  return t->row_resize();
}
void DLL_EXPORT Fl_TableSetRowResizeMin(Fl_Table* t,int m){
  t->row_resize_min(m);
}
int DLL_EXPORT Fl_TableGetRowResizeMin(Fl_Table* t){
  return t->row_resize_min();
}
void DLL_EXPORT Fl_TableSetRows(Fl_Table* t,int r){
  t->rows(r);
}
int DLL_EXPORT Fl_TableGetRows(Fl_Table* t){
  return t->rows();
}
void DLL_EXPORT Fl_TableSetSelection(Fl_Table* t, int row_top, int col_left, int row_bot, int col_right){
  t->set_selection(row_top, col_left, row_bot, col_right);
}
void DLL_EXPORT Fl_TableSetTableBox(Fl_Table* t, Fl_Boxtype bt){
  t->table_box(bt);
}
Fl_Boxtype DLL_EXPORT Fl_TableGetTableBox(Fl_Table* t){
  return t->table_box();
}
void DLL_EXPORT Fl_TableSetTopRow(Fl_Table* t, int row){
  t->top_row(row);
}
int DLL_EXPORT Fl_TableGetTopRow(Fl_Table* t){
  return t->top_row();
}
void DLL_EXPORT Fl_TableVisibleCells(Fl_Table* t, int &r1, int &r2, int &c1, int &c2){
  t->visible_cells(r1,r2,c1,c2);
}
void DLL_EXPORT Fl_TableWhen(Fl_Table* t, Fl_When flags){
  t->when(flags);
}

// class Fl_TableEx extends Fl_Table
Fl_TableEx* DLL_EXPORT Fl_TableExNew(int x, int y, int w, int h, char* title){
  return new Fl_TableEx(x,y,w,h,title);
}
void DLL_EXPORT Fl_TableExSetDrawCB(Fl_TableEx* ex, Fl_drawEx cb){
  ex->setDrawCB(cb);
}
void DLL_EXPORT Fl_TableExSetDrawCellCB(Fl_TableEx* ex, Fl_drawcellEx cb){
  ex->setDrawCellCB(cb);
}
void DLL_EXPORT Fl_TableExSetHandleCB(Fl_TableEx* ex, Fl_handleEx cb){
  ex->setHandleCB(cb);
}
void DLL_EXPORT Fl_TableExSetResizeCB(Fl_TableEx* ex, Fl_resizeEx cb){
    ex->setResizeCB(cb);
}

// class Fl_Table_Row extends Fl_Table
ImplementEx(Fl_Table_Row);
Fl_Table_Row* DLL_EXPORT Fl_Table_RowNew(int x, int y, int w, int h, const char* label){
  return new Fl_Table_Row(x,y,w,h,label);
}
void DLL_EXPORT Fl_Table_RowClear(Fl_Table_Row* tr){
  tr->clear();
}
int DLL_EXPORT Fl_Table_RowRowSelected(Fl_Table_Row* tr, int r){
  return tr->row_selected(r);
}
void DLL_EXPORT Fl_Table_RowSetRows(Fl_Table_Row* tr, int r){
  tr->rows(r);
}
int DLL_EXPORT Fl_Table_RowGetRows(Fl_Table_Row* tr){
  return tr->rows();
}
void DLL_EXPORT Fl_Table_RowSelectAllRows(Fl_Table_Row* tr, int flag){
  tr->select_all_rows(flag);
}
int DLL_EXPORT Fl_Table_RowSelectRow(Fl_Table_Row* tr, int row, int flag){
  return tr->select_row(row,flag);
}
void DLL_EXPORT Fl_Table_RowSetType(Fl_Table_Row* tr, Fl_Table_Row::TableRowSelectMode t){
  tr->type(t);
}
Fl_Table_Row::TableRowSelectMode DLL_EXPORT Fl_Table_RowGetType(Fl_Table_Row* tr){
  return tr->type();
}

// class Fl_Tabs extends Fl_Group
ImplementEx(Fl_Tabs);
Fl_Tabs* DLL_EXPORT Fl_TabsNew(int x, int y, int w, int h, const char* label){
  return new Fl_Tabs(x,y,w,h,label);
}
void DLL_EXPORT Fl_TabsClientArea(Fl_Tabs* tbs, int &rx, int &ry, int &rw, int &rh, int tabh){
  tbs->client_area(rx,ry,rw,rh,tabh);
}
int DLL_EXPORT Fl_TabsHandle(Fl_Tabs* tbs, int event){
  return tbs->handle(event);
}
int DLL_EXPORT Fl_TabsSetPush(Fl_Tabs* tbs, Fl_Widget* wgt){
  return tbs->push(wgt);
}
Fl_Widget* DLL_EXPORT Fl_TabsGetPush(Fl_Tabs* tbs){
  return tbs->push();
}
int DLL_EXPORT Fl_TabsSetValue(Fl_Tabs* tbs, Fl_Widget* wgt){
  return tbs->value(wgt);
}
Fl_Widget* DLL_EXPORT Fl_TabsGetValue(Fl_Tabs* tbs){
  return tbs->value();
}
Fl_Widget* DLL_EXPORT Fl_TabsWhich(Fl_Tabs* tbs, int event_x, int event_y){
  return tbs->which(event_x, event_y);
}


// class Fl_Text_Selection used by Fl_Text_Buffer
int DLL_EXPORT Fl_Text_SelectionEnd(Fl_Text_Selection* ts){
  return ts->end();
}
int DLL_EXPORT Fl_Text_SelectionIncludes(Fl_Text_Selection* ts, int pos){
  return ts->includes(pos);
}
int DLL_EXPORT Fl_Text_SelectionPosition(Fl_Text_Selection* ts, int* start, int* end){
  return ts->position(start,end);
}
void DLL_EXPORT Fl_Text_SelectionSetSelected(Fl_Text_Selection* ts, int b){
  if (b!=0)
    ts->selected(true);
  else
    ts->selected(false);
}
int DLL_EXPORT Fl_Text_SelectionGetSelected(Fl_Text_Selection* ts){
  if (ts->selected()==true)
    return 1;
  else
    return 0;
}
void DLL_EXPORT Fl_Text_SelectionSet(Fl_Text_Selection* ts,int start, int end){
  ts->set(start,end);
}
int DLL_EXPORT Fl_Text_SelectionStart(Fl_Text_Selection* ts){
  return ts->start();
}
void DLL_EXPORT Fl_Text_SelectionUpdate(Fl_Text_Selection* ts,int pos, int nDeleted, int nInserted){
  ts->update(pos,nDeleted,nInserted);
}

// class Fl_Text_Buffer used by Fl_Text_Display
Fl_Text_Buffer* DLL_EXPORT Fl_Text_BufferNew(int requestedSize, int preferredGapSize){
  return new Fl_Text_Buffer(requestedSize,preferredGapSize);
}
void DLL_EXPORT Fl_Text_BufferAddModifyCallback(Fl_Text_Buffer* tb, Fl_Text_Modify_Cb cb, void* cbArg){
  tb->add_modify_callback(cb,cbArg);
}
void DLL_EXPORT Fl_Text_BufferAddPredeleteCallback(Fl_Text_Buffer* tb, Fl_Text_Predelete_Cb cb, void* cbArg){
  tb->add_predelete_callback(cb,cbArg);
}
char* DLL_EXPORT Fl_Text_BufferAddress(Fl_Text_Buffer* tb, int pos){
  return tb->address(pos);
}
const char* DLL_EXPORT Fl_Text_BufferAddress2(Fl_Text_Buffer* tb, int pos){
  return tb->address(pos);
}
void DLL_EXPORT Fl_Text_BufferAppend(Fl_Text_Buffer* tb, const char* text){
  tb->append(text);
}
int DLL_EXPORT Fl_Text_BufferAppendFile(Fl_Text_Buffer* tb, const char* file, int buflen){
  return tb->appendfile(file,buflen);
}
char DLL_EXPORT Fl_Text_BufferByteAt(Fl_Text_Buffer* tb, int pos){
  return tb->byte_at(pos);
}
void DLL_EXPORT Fl_Text_BufferCallModifyCallbacks(Fl_Text_Buffer* tb){
  tb->call_modify_callbacks();
}
void DLL_EXPORT Fl_Text_BufferCallPredeleteCallbacks(Fl_Text_Buffer* tb){
  tb->call_predelete_callbacks();
}
void DLL_EXPORT Fl_Text_BufferCanUndo(Fl_Text_Buffer* tb, char flag){
  tb->canUndo(flag);
}
unsigned int DLL_EXPORT Fl_Text_BufferCharAt(Fl_Text_Buffer* tb, int pos){
  return tb->char_at(pos);
}
void DLL_EXPORT Fl_Text_BufferCopy(Fl_Text_Buffer* tb, Fl_Text_Buffer* fromBuf, int fromStart, int fromEnd, int toPos){
  tb->copy(fromBuf,fromStart,fromEnd,toPos);
}
int DLL_EXPORT Fl_Text_BufferCountDisplayedCharacters(Fl_Text_Buffer* tb, int lineStartPos, int targetPos){
  return tb->count_displayed_characters(lineStartPos,targetPos);
}
int DLL_EXPORT Fl_Text_BufferCountLines(Fl_Text_Buffer* tb, int startPos, int endPos){
  return tb->count_lines(startPos,endPos);
}
int DLL_EXPORT Fl_Text_BufferFindCharBackward(Fl_Text_Buffer* tb, int startPos, unsigned int searchChar, int* foundPos){
  return tb->findchar_backward(startPos,searchChar,foundPos);
}
int DLL_EXPORT Fl_Text_BufferFindCharForward(Fl_Text_Buffer* tb, int startPos, unsigned searchChar, int* foundPos){
  return tb->findchar_forward(startPos,searchChar,foundPos);
}
void DLL_EXPORT Fl_Text_BufferSetHighlight(Fl_Text_Buffer* tb, int start, int end){
  tb->highlight(start,end);
}
int DLL_EXPORT Fl_Text_BufferGetHighlight(Fl_Text_Buffer* tb){
  return tb->highlight();
}
int DLL_EXPORT Fl_Text_BufferHighlightPosition(Fl_Text_Buffer* tb, int* start, int* end){
  return tb->highlight_position(start,end);
}
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferHighlightSelection(Fl_Text_Buffer* tb){
  return tb->highlight_selection();
}
char* DLL_EXPORT Fl_Text_BufferHighlightText(Fl_Text_Buffer* tb){
  return tb->highlight_text();
}
void DLL_EXPORT Fl_Text_BufferInsert(Fl_Text_Buffer* tb, int pos, const char* text){
  tb->insert(pos,text);
}
int DLL_EXPORT Fl_Text_BufferInsertFile(Fl_Text_Buffer* tb, const char* file, int pos, int buflen){
  return tb->insertfile(file,pos,buflen);
}
int DLL_EXPORT Fl_Text_BufferLength(Fl_Text_Buffer* tb){
  return tb->length();
}
int DLL_EXPORT Fl_Text_BufferLineEnd(Fl_Text_Buffer* tb, int pos){
  return tb->line_end(pos);
}
int DLL_EXPORT Fl_Text_BufferLineStart(Fl_Text_Buffer* tb, int pos){
  return tb->line_start(pos);
}
char* DLL_EXPORT Fl_Text_BufferLineText(Fl_Text_Buffer* tb, int pos){
  return tb->line_text(pos);
}
int DLL_EXPORT Fl_Text_BufferLoadFile(Fl_Text_Buffer* tb, const char* file, int buflen){
  return tb->loadfile(file,buflen);
}
int DLL_EXPORT Fl_Text_BufferNextChar(Fl_Text_Buffer* tb, int ix){
  return tb->next_char(ix);
}
int DLL_EXPORT Fl_Text_BufferNextCharClipped(Fl_Text_Buffer* tb, int ix){
  return tb->next_char_clipped(ix);
}
int DLL_EXPORT Fl_Text_BufferOutputFile(Fl_Text_Buffer* tb, const char* file, int start, int end, int buflen){
  return tb->outputfile(file,start,end,buflen);
}
int DLL_EXPORT Fl_Text_BufferPrevChar(Fl_Text_Buffer* tb, int ix){
  return tb->prev_char(ix);
}
int DLL_EXPORT Fl_Text_BufferPrevCharClipped(Fl_Text_Buffer* tb, int ix){
  return tb->prev_char_clipped(ix);
}
Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferPrimarySelection(Fl_Text_Buffer* tb){
  return tb->primary_selection();
}
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferPrimarySelection2(Fl_Text_Buffer* tb){
  return tb->primary_selection();
}
void DLL_EXPORT Fl_Text_BufferRemove(Fl_Text_Buffer* tb, int start, int end){
  tb->remove(start,end);
}
void DLL_EXPORT Fl_Text_BufferRemoveModifyCallback(Fl_Text_Buffer* tb, Fl_Text_Modify_Cb cb, void* cbArg){
  tb->remove_modify_callback(cb,cbArg);
}
void DLL_EXPORT Fl_Text_BufferRemovePredeleteCallback(Fl_Text_Buffer* tb, Fl_Text_Predelete_Cb cb, void* cbArg){
  tb->remove_predelete_callback(cb,cbArg);
}
void DLL_EXPORT Fl_Text_BufferRemoveSecondarySelection(Fl_Text_Buffer* tb){
  tb->remove_secondary_selection();
}
void DLL_EXPORT Fl_Text_BufferRemoveSelection(Fl_Text_Buffer* tb){
  tb->remove_selection();
}
void DLL_EXPORT Fl_Text_BufferReplace(Fl_Text_Buffer* tb, int start, int end, const char* text){
  tb->replace(start,end,text);
}
void DLL_EXPORT Fl_Text_BufferReplaceSecondarySelection(Fl_Text_Buffer* tb, const char* text){
  tb->replace_secondary_selection(text);
}
void DLL_EXPORT Fl_Text_BufferReplaceSelection(Fl_Text_Buffer* tb, const char* text){
  tb->replace_selection(text);
}
int DLL_EXPORT Fl_Text_BufferRewindLines(Fl_Text_Buffer* tb, int startPos, int nLines){
  return tb->rewind_lines(startPos,nLines);
}
int DLL_EXPORT Fl_Text_BufferSaveFile(Fl_Text_Buffer* tb, const char* file, int buflen){
  return tb->savefile(file,buflen);
}
int DLL_EXPORT Fl_Text_BufferSearchBackward(Fl_Text_Buffer* tb, int startPos, const char* searchString, int* foundPos, int matchCase){
  return tb->search_backward(startPos,searchString,foundPos,matchCase);
}
int DLL_EXPORT Fl_Text_BufferSearchForward(Fl_Text_Buffer* tb, int startPos, const char* searchString, int* foundPos, int matchCase){
  return tb->search_forward(startPos,searchString,foundPos,matchCase);
}
void DLL_EXPORT Fl_Text_BufferSecondarySelect(Fl_Text_Buffer* tb, int start, int end){
  tb->secondary_select(start,end);
}
int DLL_EXPORT Fl_Text_BufferSecondarySelected(Fl_Text_Buffer* tb){
  return tb->secondary_selected();
}
const Fl_Text_Selection* DLL_EXPORT Fl_Text_BufferSecondarySelection(Fl_Text_Buffer* tb){
  return tb->secondary_selection();
}
int DLL_EXPORT Fl_Text_BufferSecondarySelectionPosition(Fl_Text_Buffer* tb, int* start, int* end){
  return tb->secondary_selection_position(start,end);
}
char* DLL_EXPORT Fl_Text_BufferSecondarySelectionText(Fl_Text_Buffer* tb){
  return tb->secondary_selection_text();
}
void DLL_EXPORT Fl_Text_BufferSecondaryUnselect(Fl_Text_Buffer* tb){
  tb->secondary_unselect();
}
void DLL_EXPORT Fl_Text_BufferSelect(Fl_Text_Buffer* tb, int start, int end){
  tb->select(start,end);
}
int DLL_EXPORT Fl_Text_BufferSelected(Fl_Text_Buffer* tb){
  return tb->selected();
}
int DLL_EXPORT Fl_Text_BufferSelectionPosition(Fl_Text_Buffer* tb, int* start, int* end){
  return tb->selection_position(start,end);
}
char* DLL_EXPORT Fl_Text_BufferSelectionText(Fl_Text_Buffer* tb){
  return tb->selection_text();
}
int DLL_EXPORT Fl_Text_BufferSkipDisplayedCharacters(Fl_Text_Buffer* tb, int lineStartPos, int nChars){
  return tb->skip_displayed_characters(lineStartPos,nChars);
}
int DLL_EXPORT Fl_Text_BufferSkipLines(Fl_Text_Buffer* tb, int startPos, int nLines){
  return tb->skip_lines(startPos,nLines);
}
void DLL_EXPORT Fl_Text_BufferSetTabDistance(Fl_Text_Buffer* tb, int tabDist){
  tb->tab_distance(tabDist);
}
int DLL_EXPORT Fl_Text_BufferGetTabDistance(Fl_Text_Buffer* tb){
  return tb->tab_distance();
}
void DLL_EXPORT Fl_Text_BufferSetText(Fl_Text_Buffer* tb, const char* text){
  tb->text(text);
}
char* DLL_EXPORT Fl_Text_BufferGetText(Fl_Text_Buffer* tb){
  return tb->text();
}
char* DLL_EXPORT Fl_Text_BufferTextRange(Fl_Text_Buffer* tb, int start, int end){
  return tb->text_range(start,end);
}
int DLL_EXPORT Fl_Text_BufferUndo(Fl_Text_Buffer* tb, int* cp){
  return tb->undo(cp);
}
void DLL_EXPORT Fl_Text_BufferUnhighlight(Fl_Text_Buffer* tb){
  tb->unhighlight();
}
void DLL_EXPORT Fl_Text_BufferUnselect(Fl_Text_Buffer* tb){
  tb->unselect();
}
int DLL_EXPORT Fl_Text_BufferUtf8Align(Fl_Text_Buffer* tb, int a){
  return tb->utf8_align(a);
}
int DLL_EXPORT Fl_Text_BufferWordEnd(Fl_Text_Buffer* tb, int pos){
  return tb->word_end(pos);
}
int DLL_EXPORT Fl_Text_BufferWordStart(Fl_Text_Buffer* tb, int pos){
  return tb->word_start(pos);
}

// class Fl_Text_Display extends Fl_Group
ImplementEx(Fl_Text_Display);
Fl_Text_Display* DLL_EXPORT Fl_Text_DisplayNew(int x,int y,int w,int h,const char* label){
  return new Fl_Text_Display(x,y,w,h,label);
}
void DLL_EXPORT Fl_Text_DisplaySetBuffer(Fl_Text_Display* td, Fl_Text_Buffer* buf){
  td->buffer(buf);
}
Fl_Text_Buffer* DLL_EXPORT Fl_Text_DisplayGetBuffer(Fl_Text_Display* td){
  return td->buffer();
}
double DLL_EXPORT Fl_Text_DisplayColToX(Fl_Text_Display* td, double col){
  return td->col_to_x(col);
}
int DLL_EXPORT Fl_Text_DisplayCountLines(Fl_Text_Display* td, int start, int end, bool start_pos_is_line_start){
  return td->count_lines(start,end,start_pos_is_line_start);
}
void DLL_EXPORT Fl_Text_DisplaySetCursorColor(Fl_Text_Display* td, Fl_Color c){
  td->cursor_color(c);
}
Fl_Color DLL_EXPORT Fl_Text_DisplayGetCursorColor(Fl_Text_Display* td){
  return td->cursor_color();
}
void DLL_EXPORT Fl_Text_DisplayCursorStyle(Fl_Text_Display* td, int style){
  td->cursor_style(style);
}
int	DLL_EXPORT Fl_Text_DisplayHandle(Fl_Text_Display* td, int e){
  return td->handle(e);
}
void DLL_EXPORT Fl_Text_DisplayHideCursor(Fl_Text_Display* td){
  td->hide_cursor();
}
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){
  td->highlight_data(styleBuffer,styleTable,nStyles,unfinishedStyle,cb,cbArg);
}

int DLL_EXPORT Fl_Text_DisplayInSelection(Fl_Text_Display* td, int x, int y){
  return td->in_selection(x,y);
}
void DLL_EXPORT Fl_Text_DisplayInsert(Fl_Text_Display* td, const char* text){
  td->insert(text);
}
void DLL_EXPORT Fl_Text_DisplaySetInsertPosition(Fl_Text_Display* td, int newPos){
  td->insert_position(newPos);
}
int DLL_EXPORT Fl_Text_DisplayGetInsertPosition(Fl_Text_Display* td){
  return td->insert_position();
}
int DLL_EXPORT Fl_Text_DisplayLineEnd(Fl_Text_Display* td, int startPos, bool startPosIsLineStart){
  return td->line_end(startPos,startPosIsLineStart);
}
int DLL_EXPORT Fl_Text_DisplayLineStart(Fl_Text_Display* td, int pos){
  return td->line_start(pos);
}
int DLL_EXPORT Fl_Text_DisplayMoveDown(Fl_Text_Display* td){
  return td->move_down();
}
int DLL_EXPORT Fl_Text_DisplayMoveLeft(Fl_Text_Display* td){
  return td->move_left();
}
int DLL_EXPORT Fl_Text_DisplayMoveRight(Fl_Text_Display* td){
  return td->move_right();
}
int DLL_EXPORT Fl_Text_DisplayMoveUp(Fl_Text_Display* td){
  return td->move_up();
}
void DLL_EXPORT Fl_Text_DisplayNextWord(Fl_Text_Display* td){
  td->next_word();
}
void DLL_EXPORT Fl_Text_DisplayOverStrike(Fl_Text_Display* td, const char* text){
  td->overstrike(text);
}
int DLL_EXPORT Fl_Text_DisplayPositionStyle(Fl_Text_Display* td, int lineStartPos, int lineLen, int lineIndex){
  return td->position_style(lineStartPos,lineLen,lineIndex);
}
int DLL_EXPORT Fl_Text_DisplayPositionToXY(Fl_Text_Display* td, int pos, int* x, int* y){
  return td->position_to_xy(pos,x,y);
}
void DLL_EXPORT Fl_Text_DisplayPreviousWord(Fl_Text_Display* td){
  td->previous_word();
}
void DLL_EXPORT Fl_Text_DisplayRedisplayRange(Fl_Text_Display* td, int start, int end){
  td->redisplay_range(start,end);
}
void DLL_EXPORT Fl_Text_DisplayResize(Fl_Text_Display* td, int x, int y, int w, int h){
  td->resize(x,y,w,h);
}
int DLL_EXPORT Fl_Text_DisplayRewindLines(Fl_Text_Display* td, int startPos, int nLines){
  return td->rewind_lines(startPos,nLines);
}
void DLL_EXPORT Fl_Text_DisplayScroll(Fl_Text_Display* td, int topLineNum, int horizOffset){
  td->scroll(topLineNum,horizOffset);
}
void DLL_EXPORT Fl_Text_DisplaySetScrollbarAlign(Fl_Text_Display* td, Fl_Align a){
  td->scrollbar_align(a);
}
Fl_Align DLL_EXPORT Fl_Text_DisplayGetScrollbarAlign(Fl_Text_Display* td){
  return td->scrollbar_align();
}
void DLL_EXPORT Fl_Text_DisplaySetScrollbarWidth(Fl_Text_Display* td, int w){
  td->scrollbar_width(w);
}
int DLL_EXPORT Fl_Text_DisplayGetScrollbarWidth(Fl_Text_Display* td){
  return td->scrollbar_width();
}
void DLL_EXPORT Fl_Text_DisplaySetShortcut(Fl_Text_Display* td, int s){
  td->shortcut(s);
}
int DLL_EXPORT Fl_Text_DisplayGetShortcut(Fl_Text_Display* td){
  return td->shortcut();
}
void DLL_EXPORT Fl_Text_DisplayShowCursor(Fl_Text_Display* td, int b){
  td->show_cursor(b);
}
void DLL_EXPORT Fl_Text_DisplayShowInsertPosition(Fl_Text_Display* td){
  td->show_insert_position();
}
int DLL_EXPORT Fl_Text_DisplaySkipLines(Fl_Text_Display* td, int startPos, int nLines, bool startPosIsLineStart){
  return td->skip_lines(startPos,nLines,startPosIsLineStart);
}
void DLL_EXPORT Fl_Text_DisplaySetTextColor(Fl_Text_Display* td, Fl_Color c){
  td->textcolor(c);
}
Fl_Color DLL_EXPORT Fl_Text_DisplayGetTextColor(Fl_Text_Display* td){
  return td->textcolor();
}
void DLL_EXPORT Fl_Text_DisplaySetTextFont(Fl_Text_Display* td, Fl_Font f){
  td->textfont(f);
}
Fl_Font DLL_EXPORT Fl_Text_DisplayGetTextFont(Fl_Text_Display* td){
  return td->textfont();
}
void DLL_EXPORT Fl_Text_DisplaySetTextSize(Fl_Text_Display* td, Fl_Fontsize s){
  td->textsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_Text_DisplayGetTextSize(Fl_Text_Display* td){
  return td->textsize();
}
int DLL_EXPORT Fl_Text_DisplayWordEnd(Fl_Text_Display* td, int pos){
  return td->word_end(pos);
}
int DLL_EXPORT Fl_Text_DisplayWordStart(Fl_Text_Display* td, int pos){
  return td->word_start(pos);
}
void DLL_EXPORT Fl_Text_DisplayWrapMode(Fl_Text_Display* td, int wrap, int wrap_margin){
  td->wrap_mode(wrap,wrap_margin);
}
int DLL_EXPORT Fl_Text_DisplayWrappedColumn(Fl_Text_Display* td, int row, int column){
  return td->wrapped_column(row,column);
}
int DLL_EXPORT Fl_Text_DisplayWrappedRow(Fl_Text_Display* td, int row){
  return td->wrapped_row(row);
}
double DLL_EXPORT Fl_Text_DisplayXToCol(Fl_Text_Display* td, double x){
  return td->x_to_col(x);
}

// class Fl_Text_Editor extends Fl_Text_Display
ImplementEx(Fl_Text_Editor);
Fl_Text_Editor* DLL_EXPORT Fl_Text_EditorNew(int x,int y,int w,int h,const char* label){
  return new Fl_Text_Editor(x,y,w,h,label);
}
void DLL_EXPORT Fl_Text_EditorAddDefaultKeyBindings(Fl_Text_Editor* te, Fl_Text_Editor::Key_Binding** list){
  te->add_default_key_bindings(list);
}
void DLL_EXPORT Fl_Text_EditorAddKeyBinding(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Func f){
  te->add_key_binding(key,state,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){
  te->add_key_binding(key,state,f,list);
}
Fl_Text_Editor::Key_Func DLL_EXPORT Fl_Text_EditorBoundKeyFunction(Fl_Text_Editor* te, int key, int state){
  return te->bound_key_function(key,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){
  return te->bound_key_function(key,state,list);
}
void DLL_EXPORT Fl_Text_EditorDefaultKeyFunction(Fl_Text_Editor* te, Fl_Text_Editor::Key_Func f){
  te->default_key_function(f);
}
int DLL_EXPORT Fl_Text_EditorHandle(Fl_Text_Editor* te, int e){
  return te->handle(e);
}
void DLL_EXPORT Fl_Text_EditorSetInsertMode(Fl_Text_Editor* te, int m){
  te->insert_mode(m);
}
int DLL_EXPORT Fl_Text_EditorGetInsertMode(Fl_Text_Editor* te){
  return te->insert_mode();
}
void DLL_EXPORT Fl_Text_EditorRemoveAllKeyBindings(Fl_Text_Editor* te){
  te->remove_all_key_bindings();
}
void DLL_EXPORT Fl_Text_EditorRemoveAllKeyBindings2(Fl_Text_Editor* te, Fl_Text_Editor::Key_Binding **list){
  te->remove_all_key_bindings(list);
}
void DLL_EXPORT Fl_Text_EditorRemoveKeyBinding(Fl_Text_Editor* te, int key, int state){
  te->remove_key_binding(key,state);
}
void DLL_EXPORT Fl_Text_EditorRemoveKeyBinding2(Fl_Text_Editor* te, int key, int state, Fl_Text_Editor::Key_Binding **list){
  te->remove_key_binding(key,state,list);
}

// class Fl_Tree_Itm is used by Fl_Tree
void DLL_EXPORT Fl_Tree_ItemSetLabel(Fl_Tree_Item* item, const char* newlabel){
  item->label(newlabel);
}
const char* DLL_EXPORT Fl_Tree_ItemGetLabel(Fl_Tree_Item* item){
  return item->label();
}

void DLL_EXPORT Fl_Tree_ItemSetWidget(Fl_Tree_Item* item, Fl_Widget *wgt){
  item->widget(wgt);
}
const Fl_Widget* DLL_EXPORT Fl_Tree_ItemGetWidget(Fl_Tree_Item* item){
  return item->widget();
}

// class Fl_Tree extends Fl_Group
ImplementEx(Fl_Tree);
Fl_Tree* DLL_EXPORT Fl_TreeNew(int x,int y,int w,int h,const char* label){
  return new Fl_Tree(x,y,w,h,label);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeAdd(Fl_Tree* tr, const char* path){
  return tr->add(path);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeAddItem(Fl_Tree* tr, Fl_Tree_Item *item, const char *name){
  return tr->add(item,name);
}
void DLL_EXPORT Fl_TreeSetCallbackItem (Fl_Tree* tr, Fl_Tree_Item *item){
  tr->callback_item(item);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeGetCallbackItem(Fl_Tree* tr){
  return tr->callback_item();
}
void DLL_EXPORT Fl_TreeSetCallbackReason(Fl_Tree* tr, Fl_Tree_Reason reason){
  tr->callback_reason(reason);
}
Fl_Tree_Reason DLL_EXPORT Fl_TreeGetCallbackReason(Fl_Tree* tr){
  return tr->callback_reason();
}
void DLL_EXPORT Fl_TreeClear(Fl_Tree* tr){
  tr->clear();
}
void DLL_EXPORT Fl_TreeClearChildren(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->clear_children(item);
}
int DLL_EXPORT Fl_TreeClose(Fl_Tree* tr, const char* path, int docallback){
  return tr->close(path,docallback);
}
int DLL_EXPORT Fl_TreeCloseItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->close(item,docallback);
}
void DLL_EXPORT Fl_TreeSetCloseIcon(Fl_Tree* tr, Fl_Image* ic){
  tr->closeicon(ic);
}
Fl_Image* DLL_EXPORT Fl_TreeGetCloseIcon(Fl_Tree* tr){
  return tr->closeicon();
}
void DLL_EXPORT Fl_TreeSetConnectorColor(Fl_Tree* tr, Fl_Color c){
  tr->connectorcolor(c);
}
Fl_Color DLL_EXPORT Fl_TreeGetConnectorColor(Fl_Tree* tr){
  return tr->connectorcolor();
}
void DLL_EXPORT Fl_TreeSetConnectorStyle(Fl_Tree* tr, Fl_Tree_Connector s){
  tr->connectorstyle(s);
}
Fl_Tree_Connector DLL_EXPORT Fl_TreeGetConnectorStyle(Fl_Tree* tr){
  return tr->connectorstyle();
}
void DLL_EXPORT Fl_TreeSetConnectorWidth(Fl_Tree* tr, int w){
  tr->connectorwidth(w);
}
int DLL_EXPORT Fl_TreeGetConnectorWidth(Fl_Tree* tr){
  return tr->connectorwidth();
}
int DLL_EXPORT Fl_TreeDeselect(Fl_Tree* tr, const char* path, int docallback){
  return tr->deselect(path,docallback);
}
int DLL_EXPORT Fl_TreeDeselectItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->deselect(item,docallback);
}
int DLL_EXPORT Fl_TreeDeselectAll(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->deselect_all(item,docallback);
}
void DLL_EXPORT Fl_TreeDisplay(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->display(item);
}
int DLL_EXPORT Fl_TreeDisplayed(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->displayed(item);
}
const Fl_Tree_Item* DLL_EXPORT Fl_TreeFindClicked(Fl_Tree* tr){
  return tr->find_clicked();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeFindItem(Fl_Tree* tr, const char* path){
  return tr->find_item(path);
}
const Fl_Tree_Item* DLL_EXPORT Fl_TreeFindItem2(Fl_Tree* tr, const char* path){
  return tr->find_item(path);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeFirst(Fl_Tree* tr){
  return tr->first();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeFirstSelectedItem(Fl_Tree* tr){
  return tr->first_selected_item();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeFirstVisible(Fl_Tree* tr){
  return tr->first_visible();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeGetItemFocus(Fl_Tree* tr){
  return tr->get_item_focus();
}
int DLL_EXPORT Fl_TreeHandle(Fl_Tree* tr, int e){
  return tr->handle(e);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeInsert(Fl_Tree* tr, Fl_Tree_Item* item, const char* name, int pos){
  return tr->insert(item,name,pos);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeInsertAbove(Fl_Tree* tr, Fl_Tree_Item* above, const char* name){
  return tr->insert_above(above,name);
}
int DLL_EXPORT Fl_TreeIsClose(Fl_Tree* tr, const char* path){
  return tr->is_close(path);
}
int DLL_EXPORT Fl_TreeIsCloseItem(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->is_close(item);
}
int DLL_EXPORT Fl_TreeIsOpen(Fl_Tree* tr, const char* path){
  return tr->is_open(path);
}
int DLL_EXPORT Fl_TreeIsOpenItem(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->is_open(item);
}
int DLL_EXPORT Fl_TreeIsScrollbar(Fl_Tree* tr, Fl_Widget* wgt){
  return tr->is_scrollbar(wgt);
}
int DLL_EXPORT Fl_TreeIsSelected(Fl_Tree* tr, const char* path){
  return tr->is_selected(path);
}
int DLL_EXPORT Fl_TreeIsSelectedItem(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->is_selected(item);
}
int DLL_EXPORT Fl_TreeIsVScrollVisible(Fl_Tree* tr){
  return tr->is_vscroll_visible();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeItemClicked(Fl_Tree* tr){
  return tr->item_clicked();
}
void DLL_EXPORT Fl_TreeSetItemLabelBGColor(Fl_Tree* tr, Fl_Color c){
  tr->item_labelbgcolor(c);
}
Fl_Color DLL_EXPORT Fl_TreeGetItemLabelBGClor(Fl_Tree* tr){
  return tr->item_labelbgcolor();
}
void DLL_EXPORT Fl_TreeSetItemLabelFGColor(Fl_Tree* tr, Fl_Color c){
  tr->item_labelfgcolor(c);
}
Fl_Color DLL_EXPORT Fl_TreeGetItemLabelFGColor(Fl_Tree* tr){
  return tr->item_labelfgcolor();
}
void DLL_EXPORT Fl_TreeSetItemLabelFont(Fl_Tree* tr, Fl_Font f){
  tr->item_labelfont(f);
}
Fl_Font DLL_EXPORT Fl_TreeGetItemLabelFont(Fl_Tree* tr){
  return tr->item_labelfont();
}
void DLL_EXPORT Fl_TreeSetItemLabelSize(Fl_Tree* tr, Fl_Fontsize s){
  tr->item_labelsize(s);
}
Fl_Fontsize DLL_EXPORT Fl_TreeGetItemLabelSize(Fl_Tree* tr){
  return tr->item_labelsize();
}
int DLL_EXPORT Fl_TreeItemPathName(Fl_Tree* tr, char* pathname, int pathnamelen, const Fl_Tree_Item* item){
  return tr->item_pathname(pathname,pathnamelen,item);
}
void DLL_EXPORT Fl_TreeSetLabelMarginLeft(Fl_Tree* tr, int m){
  tr->labelmarginleft(m);
}
int DLL_EXPORT Fl_TreeGetLabelMarginLeft(Fl_Tree* tr){
  return tr->labelmarginleft();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeLast(Fl_Tree* tr){
  return tr->last();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeLastVisible(Fl_Tree* tr){
  return tr->last_visible();
}
void DLL_EXPORT Fl_TreeSetLineSpacing(Fl_Tree* tr, int ls){
  tr->linespacing(ls);
}
int DLL_EXPORT Fl_TreeGetLineSpacing(Fl_Tree* tr){
  return tr->linespacing();
}
void DLL_EXPORT Fl_TreeSetMarginLeft(Fl_Tree* tr, int m){
  tr->marginleft(m);
}
int DLL_EXPORT Fl_TreeGetMarginLeft(Fl_Tree* tr){
  return tr->marginleft();
}
void DLL_EXPORT Fl_TreeSetMarginTop(Fl_Tree* tr, int m){
  tr->margintop(m);
}
int DLL_EXPORT Fl_TreeGetMarginTop(Fl_Tree* tr){
  return tr->margintop();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeNext(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->next(item);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeNextSelectedItem(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->next_selected_item(item);
}
int DLL_EXPORT Fl_TreeOpen(Fl_Tree* tr, const char* path, int docallback){
  return tr->open(path,docallback);
}
int DLL_EXPORT Fl_TreeOpenItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->open(item,docallback);
}
void DLL_EXPORT Fl_TreeOpenToggle(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  tr->open_toggle(item,docallback);
}
void DLL_EXPORT Fl_TreeSetOpenchildMarginBottom(Fl_Tree* tr, int m){
  tr->openchild_marginbottom(m);
}
int DLL_EXPORT Fl_TreeGetOpenchildMarginBottom(Fl_Tree* tr){
  return tr->openchild_marginbottom();
}
void DLL_EXPORT Fl_TreeSetOpenIcon(Fl_Tree* tr, Fl_Image* ic){
  tr->openicon(ic);
}
Fl_Image* DLL_EXPORT Fl_TreeGetOpenIcon(Fl_Tree* tr){
  return tr->openicon();
}
Fl_Tree_Item* DLL_EXPORT Fl_TreePrev(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->prev(item);
}
int DLL_EXPORT Fl_TreeRemove(Fl_Tree* tr, Fl_Tree_Item* item){
  return tr->remove(item);
}
Fl_Tree_Item* DLL_EXPORT Fl_TreeRoot(Fl_Tree* tr){
  return tr->root();
}
void DLL_EXPORT Fl_TreeRootLabel(Fl_Tree* tr, const char* new_label){
  tr->root_label(new_label);
}
void DLL_EXPORT Fl_TreeSetScrollbarSize(Fl_Tree* tr, int s){
  tr->scrollbar_size(s);
}
int DLL_EXPORT Fl_TreeGetScrollbarSize(Fl_Tree* tr){
  return tr->scrollbar_size();
}
int DLL_EXPORT Fl_TreeSelect(Fl_Tree* tr, const char* path, int docallback){
  return tr->select(path,docallback);
}
int DLL_EXPORT Fl_TreeSelectItem(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->select(item,docallback);
}
int DLL_EXPORT Fl_TreeSelectAll(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->select_all(item,docallback);
}
int DLL_EXPORT Fl_TreeSelectOnly(Fl_Tree* tr, Fl_Tree_Item* selitem, int docallback){
  return tr->select_only(selitem,docallback);
}
void DLL_EXPORT Fl_TreeSelectToggle(Fl_Tree* tr, Fl_Tree_Item* item, int docallback){
  return tr->select_toggle(item,docallback);
}
void DLL_EXPORT Fl_TreeSetSelectBox(Fl_Tree* tr, Fl_Boxtype bt){
  tr->selectbox(bt);
}
Fl_Boxtype DLL_EXPORT Fl_TreeGetSelectBox(Fl_Tree* tr){
  return tr->selectbox();
}
void DLL_EXPORT Fl_TreeSetSelectMode(Fl_Tree* tr, Fl_Tree_Select m){
  tr->selectmode(m);
}
Fl_Tree_Select DLL_EXPORT Fl_TreeGetSelectMode(Fl_Tree* tr){
  return tr->selectmode();
}
void DLL_EXPORT Fl_TreeSetItemFocus(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->set_item_focus(item);
}
void DLL_EXPORT Fl_TreeShowItem(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->show_item(item);
}
void DLL_EXPORT Fl_TreeShowItem2(Fl_Tree* tr, Fl_Tree_Item* item, int yoff){
  tr->show_item(item,yoff);
}
void DLL_EXPORT Fl_TreeShowItemBottom(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->show_item_bottom(item);
}
void DLL_EXPORT Fl_TreeShowItemMiddle(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->show_item_middle(item);
}
void DLL_EXPORT Fl_TreeShowItemTop(Fl_Tree* tr, Fl_Tree_Item* item){
  tr->show_item_top(item);
}
void DLL_EXPORT Fl_TreeShowSelf(Fl_Tree* tr){
  tr->show_self();
}
void DLL_EXPORT Fl_TreeSetShowCollapse(Fl_Tree* tr, int c){
  tr->showcollapse(c);
}
int DLL_EXPORT Fl_TreeGetShowCollapse(Fl_Tree* tr){
  return tr->showcollapse();
}
void DLL_EXPORT Fl_TreeSetShowRoot(Fl_Tree* tr, int r){
  tr->showroot(r);
}
int DLL_EXPORT Fl_TreeGetShowRoot(Fl_Tree* tr){
  return tr->showroot();
}
void DLL_EXPORT Fl_TreeSetSortOrder(Fl_Tree* tr, Fl_Tree_Sort s){
  tr->sortorder(s);
}
Fl_Tree_Sort DLL_EXPORT Fl_TreeGetSortorder(Fl_Tree* tr){
  return tr->sortorder();
}
void DLL_EXPORT Fl_TreeSetUserIcon(Fl_Tree* tr, Fl_Image* i){
  tr->usericon(i);
}
Fl_Image* DLL_EXPORT Fl_TreeGetUserIcon(Fl_Tree* tr){
  return tr->usericon();
}
void DLL_EXPORT Fl_TreeSetUserIconMarginLeft(Fl_Tree* tr, int m){
  tr->usericonmarginleft(m);
}
int DLL_EXPORT Fl_TreeGetUserIconMarginLeft(Fl_Tree* tr){
  return tr->usericonmarginleft();
}
void DLL_EXPORT Fl_TreeSetVPosition(Fl_Tree* tr, int p){
  tr->vposition(p);
}
int DLL_EXPORT Fl_TreeGetVPosition(Fl_Tree* tr){
  return tr->vposition();
}

// class Fl_Wizard extends Fl_Group
Fl_Wizard* DLL_EXPORT Fl_WizardNew(int x,int y,int w,int h,const char* title){
  return new Fl_Wizard(x,y,w,h,title);
}
void DLL_EXPORT Fl_WizardNext(Fl_Wizard* wi){
  wi->next();
}
void DLL_EXPORT Fl_WizardPrev(Fl_Wizard* wi){
  wi->prev();
}
void DLL_EXPORT Fl_WizardSetValue(Fl_Wizard* wi, Fl_Widget* wgt){
  wi->value(wgt);
}
Fl_Widget* DLL_EXPORT Fl_WizardGetValue(Fl_Wizard* wi){
  return wi->value();
}

// class Fl_Window extends Fl_Group
ImplementWindow(Fl_Window);
Fl_Window* DLL_EXPORT Fl_WindowNew(int w,int h,const char* title){
  return new Fl_Window(w,h,title);
}
Fl_Window* DLL_EXPORT Fl_WindowNew2(int x,int y,int w,int h,const char* title){
  return new Fl_Window(x,y,w,h,title);
}
void DLL_EXPORT Fl_WindowBegin(Fl_Window* w){
  w->begin();
}
void DLL_EXPORT Fl_WindowEnd(Fl_Window* w){
  w->end();
}
void DLL_EXPORT Fl_WindowSetBorder(Fl_Window* w,int b){
  w->border(b);
}
int DLL_EXPORT Fl_WindowGetBorder(Fl_Window* w){
  return w->border();
}
void DLL_EXPORT Fl_WindowClearBorder(Fl_Window* w){
  w->clear_border();
}
void DLL_EXPORT Fl_WindowCopyLabel(Fl_Window* w, const char* new_label){
  w->copy_label(new_label);
}
Fl_Window* DLL_EXPORT Fl_WindowCurrent(Fl_Window* w){
  return w->current();
}
void DLL_EXPORT Fl_WindowCursor(Fl_Window* w, Fl_Cursor c, Fl_Color fg, Fl_Color bg){
  w->cursor(c,fg,bg);
}
int DLL_EXPORT Fl_WindowDecorated_h(Fl_Window* w){
  return w->decorated_h();
}
int DLL_EXPORT Fl_WindowDecorated_w(Fl_Window* w){
  return w->decorated_w();
}
void DLL_EXPORT Fl_WindowFreePosition(Fl_Window* w){
  w->free_position();
}
void DLL_EXPORT Fl_WindowFullscreen(Fl_Window* w){
  w->fullscreen();
}
int DLL_EXPORT Fl_WindowFullscreenActive(Fl_Window* w){
  return w->fullscreen_active();
}
void DLL_EXPORT Fl_WindowFullscreenOff(Fl_Window* w){
  w->fullscreen_off();
}
void DLL_EXPORT Fl_WindowFullscreenOffResize(Fl_Window* w,int x,int y,int width,int height){
  w->fullscreen_off(x,y,width,height);
}
int DLL_EXPORT Fl_WindowHandle(Fl_Window* w,int event){
  return w->handle(event);
}
void DLL_EXPORT Fl_WindowHide(Fl_Window* w){
  w->hide();
}
void DLL_EXPORT Fl_WindowHotspot(Fl_Window* w, int x, int y, int offscreen){
 w->hotspot(x,y,offscreen);
}
void DLL_EXPORT Fl_WindowHotspotWidget(Fl_Window* w, const Fl_Widget* wgt,int offscreen){
 w->hotspot(wgt,offscreen);
}
void DLL_EXPORT Fl_WindowSetIcon(Fl_Window* w, const void* ic){
  w->icon(ic);
}
const void* DLL_EXPORT Fl_WindowGetIcon(Fl_Window* w){
  return w->icon();
}
void DLL_EXPORT Fl_WindowIconize(Fl_Window* w){
  w->iconize();
}
void DLL_EXPORT Fl_WindowSetIconLabel(Fl_Window* w, const char* il){
  w->iconlabel(il);
}
const char* DLL_EXPORT Fl_WindowGetIconLabel(Fl_Window* w){
  return w->iconlabel();
}
void DLL_EXPORT Fl_WindowSetLabel(Fl_Window* w, const char* wl){
  w->label(wl);
}
void DLL_EXPORT Fl_WindowSetLabels(Fl_Window* w, const char* wl, const char* il){
  w->label(wl,il);
}
const char* DLL_EXPORT Fl_WindowGetLabel(Fl_Window* w){
  return w->label();
}
void DLL_EXPORT Fl_WindowMakeCurrent(Fl_Window* w){
  w->make_current();
}

void DLL_EXPORT Fl_WindowSetModal(Fl_Window* w){
  w->set_modal();
}
int DLL_EXPORT Fl_WindowGetModal(Fl_Window* w){
  return w->modal();
}

void DLL_EXPORT Fl_WindowSetNonModal(Fl_Window* w){
  w->set_non_modal();
}
int DLL_EXPORT Fl_WindowGetNonModal(Fl_Window* w){
  return w->non_modal();
}

void DLL_EXPORT Fl_WindowSetOverride(Fl_Window* w){
  w->set_override();
}
int DLL_EXPORT Fl_WindowGetOverride(Fl_Window* w){
  return w->override();
}

void DLL_EXPORT Fl_WindowResize(Fl_Window* w, int x, int y, int width, int height){
  w->resize(x,y,width,height);
}

void DLL_EXPORT Fl_WindowShow(Fl_Window* w){
  w->show(0,0);
}
void DLL_EXPORT Fl_WindowShowArgs(Fl_Window* w, int argc, char** argv){
  w->show(argc,argv);
}

int DLL_EXPORT Fl_WindowShown(Fl_Window* w){
  return w->shown();
}
void DLL_EXPORT Fl_WindowSizeRange(Fl_Window* w, int minw, int minh, int maxw, int maxh, int dw, int dh, int aspect){
  w->size_range(minw, minh, maxw, maxh, dw, dh, aspect);
}

void DLL_EXPORT Fl_WindowSetTooltipWindow(Fl_Window* w){
  w->set_tooltip_window();
}
int DLL_EXPORT Fl_WindowGetTooltipWindow(Fl_Window* w){
  return w->tooltip_window();
}

void DLL_EXPORT Fl_WindowSetXClass(Fl_Window* w, const char* xc){
  w->xclass(xc);
}
const char* DLL_EXPORT Fl_WindowGetXClass(Fl_Window* w){
  return w->xclass();
}

int DLL_EXPORT Fl_WindowXRoot(Fl_Window* w){
  return w->x_root();
}
int DLL_EXPORT Fl_WindowYRoot(Fl_Window* w){
  return w->y_root();
}


// class Fl_Single_Window
ImplementWindow(Fl_Single_Window);
Fl_Single_Window* DLL_EXPORT Fl_Single_WindowNew(int w, int h, const char *label){
  return new Fl_Single_Window(w,h,label);
}
Fl_Single_Window* DLL_EXPORT Fl_Single_WindowNew2(int x, int y, int w, int h, const char *label){
  return new Fl_Single_Window(x,y,w,h,label);
}
void DLL_EXPORT Fl_Single_WindowFlush(Fl_Single_Window* sngwin){
  sngwin->flush();
}
void DLL_EXPORT Fl_Single_WindowShow(Fl_Single_Window* sngwin){
  sngwin->show();
}
void DLL_EXPORT Fl_Single_WindowShowArgs(Fl_Single_Window* sngwin, int argc, char **argv){
  sngwin->show(argc,argv);
}

// class Fl_Menu_Window extends Fl_Single_Window
ImplementWindow(Fl_Menu_Window);
Fl_Menu_Window* DLL_EXPORT Fl_Menu_WindowNew(int w, int h, const char *label){
  return new Fl_Menu_Window(w,h,label);
}
Fl_Menu_Window* DLL_EXPORT Fl_Menu_WindowNew2(int x, int y, int w, int h, const char *label){
  return new Fl_Menu_Window(x,y,w,h,label);
}
void DLL_EXPORT Fl_Menu_WindowClearOverlay(Fl_Menu_Window* mwin){
  mwin->clear_overlay();
}
void DLL_EXPORT Fl_Menu_WindowErase(Fl_Menu_Window* mwin){
  mwin->erase();
}
void DLL_EXPORT Fl_Menu_WindowFlush(Fl_Menu_Window* mwin){
  mwin->flush();
}
void DLL_EXPORT Fl_Menu_WindowHide(Fl_Menu_Window* mwin){
  mwin->hide();
}
unsigned int DLL_EXPORT Fl_Menu_WindowOverlay(Fl_Menu_Window* mwin){
  return mwin->overlay();
}
void DLL_EXPORT Fl_Menu_WindowSetOverlay(Fl_Menu_Window* mwin){
  mwin->set_overlay();
}
void DLL_EXPORT Fl_Menu_WindowShow(Fl_Menu_Window* mwin){
  mwin->show();
}

// class Fl_Double_Window
ImplementWindow(Fl_Double_Window);
Fl_Double_Window* DLL_EXPORT Fl_Double_WindowNew(int w, int h, const char *label){
  return new Fl_Double_Window(w,h,label);
}
Fl_Double_Window* DLL_EXPORT Fl_Double_WindowNew2(int x, int y, int w, int h, const char *label){
  return new Fl_Double_Window(x,y,w,h,label);
}
void DLL_EXPORT Fl_Double_WindowFlush(Fl_Double_Window* dblwin){
  dblwin->flush();
}
void DLL_EXPORT Fl_Double_WindowHide(Fl_Double_Window* dblwin){
  dblwin->hide();
}
void DLL_EXPORT Fl_Double_WindowResize(Fl_Double_Window* dblwin, int x, int y, int w, int h){
  dblwin->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Double_WindowShow(Fl_Double_Window* dblwin){
  dblwin->show();
}
void DLL_EXPORT Fl_Double_WindowShowArgs(Fl_Double_Window* dblwin, int argc, char **argv){
  dblwin->show(argc,argv);
}

// class Fl_Gl_Window
ImplementWindow(Fl_Gl_Window);
Fl_Gl_Window* DLL_EXPORT Fl_Gl_WindowNew(int w,int h,const char* title){
  return new Fl_Gl_Window(w,h,title);
}
Fl_Gl_Window* DLL_EXPORT Fl_Gl_WindowNew2(int x,int y,int w,int h,const char* title){
  return new Fl_Gl_Window(x,y,w,h,title);
}
int DLL_EXPORT Fl_Gl_WindowCanDo(Fl_Gl_Window* win){
  return win->can_do();
}
int DLL_EXPORT Fl_Gl_WindowCanDoOverlay(Fl_Gl_Window* win){
  return win->can_do_overlay();
}
void DLL_EXPORT Fl_Gl_WindowSetContext(Fl_Gl_Window* win, void* ctx, int destroy_flag){
  win->context(ctx,destroy_flag);
}
void* DLL_EXPORT Fl_Gl_WindowGetContext(Fl_Gl_Window* win){
  return win->context();
}
void DLL_EXPORT Fl_Gl_WindowSetContextValid(Fl_Gl_Window* win, int v){
  win->context_valid(v);
}
int DLL_EXPORT Fl_Gl_WindowGetContextValid(Fl_Gl_Window* win){
  return win->context_valid();
}
void DLL_EXPORT Fl_Gl_WindowFlush(Fl_Gl_Window* win){
  win->flush();
}
int DLL_EXPORT Fl_Gl_WindowHandle(Fl_Gl_Window* win, int event){
  return win->handle(event);
}
void DLL_EXPORT Fl_Gl_WindowHide(Fl_Gl_Window* win){
  win->hide();
}
void DLL_EXPORT Fl_Gl_WindowHideOverlay(Fl_Gl_Window* win){
  win->hide_overlay();
}
void DLL_EXPORT Fl_Gl_WindowInvalidate(Fl_Gl_Window* win){
  win->invalidate();
}
void DLL_EXPORT Fl_Gl_WindowMakeCurrent(Fl_Gl_Window* win){
  win->make_current();
}
void DLL_EXPORT Fl_Gl_WindowMakeOverlayCurrent(Fl_Gl_Window* win){
  win->make_overlay_current();
}
int DLL_EXPORT Fl_Gl_WindowSetMode(Fl_Gl_Window* win, Fl_Mode m){
  return win->mode(m);
}
Fl_Mode DLL_EXPORT Fl_Gl_WindowGetMode(Fl_Gl_Window* win){
  return win->mode();
}
void DLL_EXPORT Fl_Gl_WindowOrtho(Fl_Gl_Window* win){
  win->ortho();
}
void DLL_EXPORT Fl_Gl_WindowRedrawOverlay(Fl_Gl_Window* win){
  win->redraw_overlay();
}
void DLL_EXPORT Fl_Gl_WindowResize(Fl_Gl_Window* win, int x, int y, int w, int h){
  win->resize(x,y,w,h);
}
void DLL_EXPORT Fl_Gl_WindowShowArgs(Fl_Gl_Window* win, int argc, char** argv){
  win->show(argc,argv);
}
void DLL_EXPORT Fl_Gl_WindowShow(Fl_Gl_Window* win){
  win->show();
}
void DLL_EXPORT Fl_Gl_WindowSwapBuffers(Fl_Gl_Window* win){
  win->swap_buffers();
}
void DLL_EXPORT Fl_Gl_WindowSetValid(Fl_Gl_Window* win, int v){
  win->valid(v);
}
int DLL_EXPORT Fl_Gl_WindowGetValid(Fl_Gl_Window* win){
  return win->valid();
}

// class Fl_Printer
Fl_Printer* DLL_EXPORT Fl_PrinterNew(void){
  return new Fl_Printer();
}
void DLL_EXPORT Fl_PrinterDelete(Fl_Printer* & p) {
  if (p){
    delete p; p=0;
  }
}

const char* DLL_EXPORT Fl_PrinterGetClassName(Fl_Printer* p){
   return p->class_name();
}
Fl_Graphics_Driver* DLL_EXPORT Fl_PrinterGetDriver(Fl_Printer* p){
  return p->driver();
}
int DLL_EXPORT Fl_PrinterStartJob(Fl_Printer* p,int pagecount, int * frompage, int * topage){
  return p->start_job(pagecount, frompage, topage);
}
void DLL_EXPORT Fl_PrinterEndJob(Fl_Printer* p){
  p->end_job();
}
int DLL_EXPORT Fl_PrinterStartPage(Fl_Printer* p){
  return p->start_page();
}
int  DLL_EXPORT Fl_PrinterEndPage(Fl_Printer* p){
  return p->end_page();
}

void DLL_EXPORT Fl_PrinterGetMargins(Fl_Printer* p,int & left, int & top, int & right, int & bottom){
  p->margins(&left,&top,&right,&bottom);
}
void DLL_EXPORT Fl_PrinterSetOrigin(Fl_Printer* p,int x, int y){
  p->origin(x,y);
}
void DLL_EXPORT Fl_PrinterGetOrigin(Fl_Printer* p,int & x, int & y){
  p->origin(&x,&y);
}
void DLL_EXPORT Fl_PrinterPrintWidget(Fl_Printer* p,Fl_Widget *widget, int delta_x, int delta_y){
  p->print_widget(widget,delta_x,delta_y);
}
void DLL_EXPORT Fl_PrinterPrintWindow(Fl_Printer* p,Fl_Window *win, int x_offset, int y_offset){
  p->print_window(win,x_offset,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){
  p->print_window_part(win,x,y,w,h,delta_x,delta_y) ;
}
int DLL_EXPORT Fl_PrinterGetPrintableRect(Fl_Printer* p,int &w, int &h){
  return p->printable_rect(&w,&h);
}
void DLL_EXPORT Fl_PrinterRotate(Fl_Printer* p,float angle){
  p->rotate(angle);
}
void DLL_EXPORT Fl_PrinterScale(Fl_Printer* p,float scale_x, float scale_y){
  p->scale(scale_x,scale_y);
}
void DLL_EXPORT Fl_PrinterSetCurrent(Fl_Printer* p){
   p->set_current();
}
void DLL_EXPORT Fl_PrinterTranslate(Fl_Printer* p,int x, int y){
  p->translate(x,y);
}
void DLL_EXPORT Fl_PrinterUntranslate(Fl_Printer* p){
  p->untranslate();
}
