class Fox::FXFont

Public Class Methods

listFonts(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_listFonts(int argc, VALUE *argv, VALUE self) {
  FXString *arg1 = 0 ;
  FXuint arg2 = (FXuint) 0 ;
  FXuint arg3 = (FXuint) 0 ;
  FXuint arg4 = (FXuint) 0 ;
  FXuint arg5 = (FXuint) 0 ;
  FXuint arg6 = (FXuint) 0 ;
  SwigValueWrapper< FXString > p1 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  p1 = to_FXString(argv[0]); arg1 = &p1;
  if (argc > 1) {
    arg2 = NUM2UINT(argv[1]);
  }
  if (argc > 2) {
    arg3 = NUM2UINT(argv[2]);
  }
  if (argc > 3) {
    arg4 = NUM2UINT(argv[3]);
  }
  if (argc > 4) {
    arg5 = NUM2UINT(argv[4]);
  }
  if (argc > 5) {
    arg6 = NUM2UINT(argv[5]);
  }
  result = (VALUE)FXFont_listFonts((FXString const &)*arg1,arg2,arg3,arg4,arg5,arg6);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}
Also aliased as: old_listFonts
new(*args) click to toggle source
SWIGINTERN VALUE _wrap_new_FXFont(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs;
  if (argc > 8) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFontDesc, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FXFont__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_FXFont__SWIG_0(nargs, args, self);
      }
    }
  }
  if ((argc >= 3) && (argc <= 8)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_FXFont__SWIG_1(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_FXFont__SWIG_1(nargs, args, self);
            }
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_FXFont__SWIG_1(nargs, args, self);
              }
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_new_FXFont__SWIG_1(nargs, args, self);
                }
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  if (argc <= 7) {
                    return _wrap_new_FXFont__SWIG_1(nargs, args, self);
                  }
                  {
                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_new_FXFont__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "FXFont.new", 
    "    FXFont.new(FXApp *a, FXString const &string)\n"
    "    FXFont.new(FXApp *a, FXString const &face, FXuint sz, FXuint wt, FXuint slant, FXuint encoding, FXuint setwidth, FXuint h)\n"
    "    FXFont.new(FXApp *a, FXFontDesc const &fontdesc)\n");
  
  return Qnil;
}
new(a, arg1, *args, &blk) click to toggle source
# File lib/fox16/kwargs.rb, line 62
def initialize(a, arg1, *args, &blk)
  if args.length > 0
    face, size = arg1, args[0]
    argument_names = %w{weight slant encoding setWidth hints}
    default_params = { :weight => FXFont::Normal, :slant => FXFont::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }
    params = {}
    params = args.pop if args.last.is_a? Hash
    args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
    params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
    params = default_params.merge(params)
    old_initialize(a, face, size, params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints], &blk)
  else
    old_initialize(a, arg1, &blk)
  end
end
Also aliased as: old_initialize
old_listFonts(*args)
Alias for: listFonts

Public Instance Methods

angle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_angle(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)((FXFont const *)arg1)->getAngle();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
create(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_create(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  FXFont_create(arg1);
  return Qnil;
fail:
  return Qnil;
}
destroy(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_destroy(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  FXFont_destroy(arg1);
  return Qnil;
fail:
  return Qnil;
}
detach(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_detach(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","detach", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  FXFont_detach(arg1);
  return Qnil;
fail:
  return Qnil;
}
family(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_family(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFamily", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = ((FXFont const *)arg1)->getFamily();
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
flags(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_flags(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
font(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_font(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = ((FXFont const *)arg1)->getFont();
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
foundry(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_foundry(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFoundry", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = ((FXFont const *)arg1)->getFoundry();
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
getActualEncoding(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualEncoding(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualEncoding", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getActualEncoding();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getActualName(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualName(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualName", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXString *) &((FXFont const *)arg1)->getActualName();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}
getActualSetWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualSetWidth(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSetWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getActualSetWidth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getActualSize(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualSize(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getActualSize();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getActualSlant(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualSlant(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSlant", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getActualSlant();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getActualWeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getActualWeight(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getActualWeight();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getCharWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getCharWidth(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXwchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FXint 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getCharWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","getCharWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< FXwchar >(val2);
  result = (FXint)FXFont_getCharWidth((FXFont const *)arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getEncoding(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getEncoding(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getEncoding", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getEncoding();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontAscent(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontAscent(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontAscent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontAscent((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontDesc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontDesc(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFontDesc result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontDesc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = FXFont_getFontDesc((FXFont const *)arg1);
  {
    FXFontDesc* resultptr = new FXFontDesc(result);
    vresult = FXRbGetRubyObj(resultptr, "FXFontDesc *");
  }
  return vresult;
fail:
  return Qnil;
}
getFontDescent(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontDescent(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontDescent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontDescent((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontHeight(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontHeight((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontLeading(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontLeading(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontLeading", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontLeading((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontSpacing(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontSpacing(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontSpacing", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontSpacing((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFontWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getFontWidth(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXint)FXFont_getFontWidth((FXFont const *)arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getHints(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getHints(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getHints", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getHints();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getMaxChar(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getMaxChar(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXwchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getMaxChar", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXwchar)FXFont_getMaxChar((FXFont const *)arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getMinChar(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getMinChar(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXwchar result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getMinChar", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXwchar)FXFont_getMinChar((FXFont const *)arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getName(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getName(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXString *) &((FXFont const *)arg1)->getName();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}
getSetWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getSetWidth(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSetWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getSetWidth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getSize(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getSize(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getSize();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getSlant(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getSlant(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSlant", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getSlant();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getTextHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getTextHeight(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  FXint 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getTextHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  result = (FXint)FXFont_getTextHeight((FXFont const *)arg1,(FXString const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getTextWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getTextWidth(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  FXint 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getTextWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  result = (FXint)FXFont_getTextWidth((FXFont const *)arg1,(FXString const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getWeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_getWeight(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXuint)((FXFont const *)arg1)->getWeight();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
hasChar(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_hasChar(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","hasChar", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  arg2 = argv[0];
  result = (FXbool)FXFont_hasChar((FXFont const *)arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
Also aliased as: hasChar?
hasChar?(*args)
Alias for: hasChar
isFontMono(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_isFontMono(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","isFontMono", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  result = (FXbool)FXFont_isFontMono((FXFont const *)arg1);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
leftBearing(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_leftBearing(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXwchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FXint 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","leftBearing", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","leftBearing", 2, argv[0] ));
  } 
  arg2 = static_cast< FXwchar >(val2);
  result = (FXint)FXFont_leftBearing((FXFont const *)arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
load(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_load(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  FXFont_load(arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}
old_initialize(a, arg1, *args, &blk)
Alias for: new
rightBearing(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_rightBearing(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXwchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FXint 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(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","rightBearing", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","rightBearing", 2, argv[0] ));
  } 
  arg2 = static_cast< FXwchar >(val2);
  result = (FXint)FXFont_rightBearing((FXFont const *)arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
save(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_save(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  FXFont_save((FXFont const *)arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}
setAngle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_setAngle(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  arg2 = NUM2INT(argv[0]);
  FXFont_setAngle(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_setFont(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  FXFont_setFont(arg1,(FXString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}
setFontDesc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXFont_setFontDesc(int argc, VALUE *argv, VALUE self) {
  FXFont *arg1 = (FXFont *) 0 ;
  FXFontDesc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setFontDesc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFont * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXFontDesc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFontDesc const &","setFontDesc", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFontDesc const &","setFontDesc", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXFontDesc * >(argp2);
  FXFont_setFontDesc(arg1,(FXFontDesc const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}