module Fox

SWIGINTERN VALUE
_wrap_FXALPHAVAL(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXuchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXuchar)_FXALPHAVAL(arg1);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXBLUEVAL(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXuchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXuchar)_FXBLUEVAL(arg1);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXGREENVAL(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXuchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXuchar)_FXGREENVAL(arg1);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXREDVAL(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXuchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXuchar)_FXREDVAL(arg1);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXRGB(int argc, VALUE *argv, VALUE self) {
  FXuchar arg1 ;
  FXuchar arg2 ;
  FXuchar arg3 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  arg2 = NUM2UINT(argv[1]);
  arg3 = NUM2UINT(argv[2]);
  result = (FXuint)_FXRGB(arg1,arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXRGBA(int argc, VALUE *argv, VALUE self) {
  FXuchar arg1 ;
  FXuchar arg2 ;
  FXuchar arg3 ;
  FXuchar arg4 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  arg2 = NUM2UINT(argv[1]);
  arg3 = NUM2UINT(argv[2]);
  arg4 = NUM2UINT(argv[3]);
  result = (FXuint)_FXRGBA(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXRGBACOMPVAL(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXuchar arg2 ;
  FXuchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  arg2 = NUM2UINT(argv[1]);
  result = (FXuchar)_FXRGBACOMPVAL(arg1,arg2);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXSEL(int argc, VALUE *argv, VALUE self) {
  FXushort arg1 ;
  FXushort arg2 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  arg2 = NUM2UINT(argv[1]);
  result = (FXuint)_FXSEL(arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXSELID(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXushort result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXushort)_FXSELID(arg1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_FXSELTYPE(int argc, VALUE *argv, VALUE self) {
  FXuint arg1 ;
  FXushort result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = (FXushort)_FXSELTYPE(arg1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_MKUINT(int argc, VALUE *argv, VALUE self) {
  FXushort arg1 ;
  FXushort arg2 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  arg2 = NUM2UINT(argv[1]);
  result = (FXuint)_MKUINT(arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_findHotKey(int argc, VALUE *argv, VALUE self) {
  FXString *arg1 = 0 ;
  SwigValueWrapper< FXString > p1 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  p1 = to_FXString(argv[0]); arg1 = &p1;
  result = (FXint)findHotKey((FXString const &)*arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_fxTraceLevel_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(fxTraceLevel));
  return _val;
}

SWIGINTERN VALUE
_wrap_fxTraceLevel_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""fxTraceLevel""' of type '""unsigned int""'");
    }
    fxTraceLevel = static_cast< unsigned int >(val);
  }
  return _val;
fail:
  return Qnil;
}

# File rdoc-sources/FXBMPIcon.rb, line 66
def Fox.fxcheckBMP(store); end

SWIGINTERN VALUE
_wrap_fxcheckGIF(int argc, VALUE *argv, VALUE self) {
  FXStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckGIF", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckGIF", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FXStream * >(argp1);
  result = (bool)fxcheckGIF(*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

# File rdoc-sources/FXICOIcon.rb, line 63
def Fox.fxcheckICO(store); end

# File rdoc-sources/FXJPGIcon.rb, line 69
def Fox.fxcheckJPG(store); end

# File rdoc-sources/FXPCXIcon.rb, line 61
def Fox.fxcheckPCX(store); end

# File rdoc-sources/FXPNGIcon.rb, line 64
def Fox.fxcheckPNG(store); end

# File rdoc-sources/FXPPMIcon.rb, line 35
def Fox.fxcheckPPM(store); end

# File rdoc-sources/FXRGBIcon.rb, line 62
def Fox.fxcheckRGB(store); end

# File rdoc-sources/FXTGAIcon.rb, line 61
def Fox.fxcheckTGA(store); end

# File rdoc-sources/FXTIFIcon.rb, line 68
def Fox.fxcheckTIF(store); end

# File rdoc-sources/FXXBMIcon.rb, line 36
def Fox.fxcheckXBM(store); end

# File rdoc-sources/FXXPMIcon.rb, line 63
def Fox.fxcheckXPM(store); end

SWIGINTERN VALUE
_wrap_fxcolorfromname(int argc, VALUE *argv, VALUE self) {
  FXchar *arg1 = (FXchar *) 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  result = (FXColor)fxcolorfromname((char const *)arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

# File lib/fox16/core.rb, line 367
def Fox.fxdecodeColorData(data)
  clr = data.unpack('S4')
  Fox.FXRGBA((clr[0]+128)/257, (clr[1]+128)/257, (clr[2]+128)/257, (clr[3]+128)/257)
end

# File lib/fox16/core.rb, line 390
def Fox.fxdecodeStringData(data)
  if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
    data.chop
  else
    data
  end
end

# File lib/fox16/core.rb, line 378
def Fox.fxencodeColorData(rgba)
  clr = [ 257*Fox.FXREDVAL(rgba), 257*Fox.FXGREENVAL(rgba), 257*Fox.FXBLUEVAL(rgba), 257*Fox.FXALPHAVAL(rgba) ]
  clr.pack('S4')
end

# File lib/fox16/core.rb, line 405
def Fox.fxencodeStringData(str)
  if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
    str + "\0"
  else
    str
  end
end

SWIGINTERN VALUE
_wrap_fxfilematch(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  FXuint arg3 = (FXuint) (FILEMATCH_NOESCAPE|FILEMATCH_FILE_NAME) ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","fxfilematch", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","fxfilematch", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (argc > 2) {
    arg3 = NUM2UINT(argv[2]);
  }
  result = (FXint)fxfilematch((char const *)arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

# File rdoc-sources/fxdefs.rb, line 60
def Fox.fxfindhotkeyoffset(s); end

SWIGINTERN VALUE
_wrap_fxhsv_to_rgb(int argc, VALUE *argv, VALUE self) {
  FXfloat arg1 ;
  FXfloat arg2 ;
  FXfloat arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 1, argv[0] ));
  } 
  arg1 = static_cast< FXfloat >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 2, argv[1] ));
  } 
  arg2 = static_cast< FXfloat >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 3, argv[2] ));
  } 
  arg3 = static_cast< FXfloat >(val3);
  result = (VALUE)fxhsv_to_rgb(arg1,arg2,arg3);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_fxisconsole(int argc, VALUE *argv, VALUE self) {
  FXchar *arg1 = (FXchar *) 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  result = (FXbool)fxisconsole((char const *)arg1);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

# File rdoc-sources/FXBMPIcon.rb, line 47
def Fox.fxloadBMP(store); end

SWIGINTERN VALUE
_wrap_fxloadGIF(int argc, VALUE *argv, VALUE self) {
  FXStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadGIF", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadGIF", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FXStream * >(argp1);
  result = (VALUE)fxloadGIF(*arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

# File rdoc-sources/FXICOIcon.rb, line 42
def Fox.fxloadICO(store); end

# File rdoc-sources/FXJPGIcon.rb, line 49
def Fox.fxloadJPG(store); end

# File rdoc-sources/FXPCXIcon.rb, line 42
def Fox.fxloadPCX(store); end

# File rdoc-sources/FXPNGIcon.rb, line 45
def Fox.fxloadPNG(store); end

# File rdoc-sources/FXRGBIcon.rb, line 42
def Fox.fxloadRGB(store); end

# File rdoc-sources/FXTGAIcon.rb, line 42
def Fox.fxloadTGA(store); end

# File rdoc-sources/FXTIFIcon.rb, line 48
def Fox.fxloadTIF(store); end

# File rdoc-sources/FXXPMIcon.rb, line 43
def Fox.fxloadXPM(store); end

SWIGINTERN VALUE
_wrap_fxnamefromcolor(int argc, VALUE *argv, VALUE self) {
  FXColor arg1 ;
  FXchar *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = to_FXColor(argv[0]);
  result = (FXchar *)fxnamefromcolor(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

# File rdoc-sources/fxdefs.rb, line 43
def Fox.fxparseAccel(str); end

# File rdoc-sources/fxdefs.rb, line 57
def Fox.fxparseHotKey(s); end

SWIGINTERN VALUE
_wrap_fxrgb_to_hsv(int argc, VALUE *argv, VALUE self) {
  FXfloat arg1 ;
  FXfloat arg2 ;
  FXfloat arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 1, argv[0] ));
  } 
  arg1 = static_cast< FXfloat >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 2, argv[1] ));
  } 
  arg2 = static_cast< FXfloat >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 3, argv[2] ));
  } 
  arg3 = static_cast< FXfloat >(val3);
  result = (VALUE)fxrgb_to_hsv(arg1,arg2,arg3);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

# File lib/fox16/version.rb, line 2
def Fox.fxrubyversion
  "1.6.49"
end

# File rdoc-sources/FXBMPIcon.rb, line 61
def Fox.fxsaveBMP(store, data, transp, width, height); end

SWIGINTERN VALUE
_wrap_fxsaveGIF(int argc, VALUE *argv, VALUE self) {
  FXStream *arg1 = 0 ;
  FXColor *arg2 = (FXColor *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXbool arg5 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveGIF", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveGIF", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FXStream * >(argp1);
  {
    arg2=NULL;
    if(argv[1]!=Qnil){
      Check_Type(argv[1],T_ARRAY);
      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
        }
      }
    }
  }
  arg3 = NUM2INT(argv[2]);
  arg4 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg5 = to_FXbool(argv[4]);
  }
  result = (bool)fxsaveGIF(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  FXFREE(&arg2);
  return vresult;
fail:
  FXFREE(&arg2);
  return Qnil;
}

# File rdoc-sources/FXICOIcon.rb, line 58
def Fox.fxsaveICO(store, pixels, transp, width, height, xspot=-1, yspot=-1); end

# File rdoc-sources/FXJPGIcon.rb, line 64
def Fox.fxsaveJPG(store, data, transp, width, height, quality); end

# File rdoc-sources/FXPCXIcon.rb, line 56
def Fox.fxsavePCX(store, data, transp, width, height); end

# File rdoc-sources/FXPNGIcon.rb, line 59
def Fox.fxsavePNG(store, data, transp, width, height); end

# File rdoc-sources/FXRGBIcon.rb, line 57
def Fox.fxsaveRGB(store, data, transp, width, height); end

# File rdoc-sources/FXTGAIcon.rb, line 56
def Fox.fxsaveTGA(store, data, channels, width, height); end

# File rdoc-sources/FXTIFIcon.rb, line 63
def Fox.fxsaveTIF(store, data, transp, width, height, codec); end

SWIGINTERN VALUE
_wrap_fxsleep(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","fxsleep", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  fxsleep(arg1);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_fxversion(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)_fxversion();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_makeHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXColor arg1 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = to_FXColor(argv[0]);
  result = (FXColor)makeHiliteColor(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_makeShadowColor(int argc, VALUE *argv, VALUE self) {
  FXColor arg1 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = to_FXColor(argv[0]);
  result = (FXColor)makeShadowColor(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_parseAccel(int argc, VALUE *argv, VALUE self) {
  FXString *arg1 = 0 ;
  SwigValueWrapper< FXString > p1 ;
  FXHotKey result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  p1 = to_FXString(argv[0]); arg1 = &p1;
  result = (FXHotKey)parseAccel((FXString const &)*arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_parseHotKey(int argc, VALUE *argv, VALUE self) {
  FXString *arg1 = 0 ;
  SwigValueWrapper< FXString > p1 ;
  FXHotKey result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  p1 = to_FXString(argv[0]); arg1 = &p1;
  result = (FXHotKey)parseHotKey((FXString const &)*arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_setIgnoreExceptions(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  setIgnoreExceptions(arg1);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_stripHotKey(int argc, VALUE *argv, VALUE self) {
  FXString *arg1 = 0 ;
  SwigValueWrapper< FXString > p1 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  p1 = to_FXString(argv[0]); arg1 = &p1;
  result = stripHotKey((FXString const &)*arg1);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_unparseAccel(int argc, VALUE *argv, VALUE self) {
  FXHotKey arg1 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = NUM2UINT(argv[0]);
  result = unparseAccel(arg1);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}

# File rdoc-sources/FXAccelTable.rb, line 76
def findHotKey(string); end

# File rdoc-sources/FXXPMIcon.rb, line 58
def fxsaveXPM(store, data, transp, width, height, fast=true); end

# File rdoc-sources/FXAccelTable.rb, line 55
def parseAccel(string); end

# File rdoc-sources/FXAccelTable.rb, line 68
def parseHotKey(string); end

# File rdoc-sources/FXAccelTable.rb, line 83
def stripHotKey(string); end

# File rdoc-sources/FXAccelTable.rb, line 61
def unparseAccel(key); end