class Fox::FXFont

Font class

Font pitch hints¶ ↑

Fixed: Fixed pitch, mono-spaced
Variable: Variable pitch, proportional spacing

Font style hints¶ ↑

Decorative: Fancy fonts
Modern: Monospace typewriter font
Roman: Variable width times-like font, serif
Script: Script or cursive
Swiss: Helvetica/swiss type font, sans-serif
System: System font
X11: Raw X11 font string
Scalable: Scalable fonts
Polymorphic: Polymorphic fonts, e.g. parametric weight, slant, etc.
Rotatable: Rotatable fonts

Font slant options¶ ↑

ReverseOblique: Reversed oblique
ReverseItalic: Reversed italic
Straight: Straight, not slanted
Italic: Italics
Oblique: Oblique slant

Font weight options¶ ↑

Thin: Thin
ExtraLight: Extra light
Light: Light
Normal: Normal or regular weight
Medium: Medium bold face
DemiBold: Demi bold face
Bold: Bold face
ExtraBold: Extra
Black: Black

Condensed or expanded options¶ ↑

UltraCondensed: Ultra condensed printing
ExtraCondensed: Extra condensed
Condensed: Condensed
SemiCondensed: Semi-condensed
NonExpanded: Regular printing
SemiExpanded: Semi expanded

Expanded:; Expanded

ExtraExpanded: Extra expanded
UltraExpanded: Ultra expanded

Font character set encoding¶ ↑

FONTENCODING_DEFAULT: Don’t care character encoding
FONTENCODING_ISO_8859_1: West European (Latin1)
FONTENCODING_ISO_8859_2: Central and East European (Latin2)
FONTENCODING_ISO_8859_3: Esperanto (Latin3)
FONTENCODING_ISO_8859_4: ISO-8859-4 character encoding
FONTENCODING_ISO_8859_5: Cyrillic (almost obsolete)
FONTENCODING_ISO_8859_6: Arabic
FONTENCODING_ISO_8859_7: Greek
FONTENCODING_ISO_8859_8: Hebrew
FONTENCODING_ISO_8859_9: Turkish (Latin5)
FONTENCODING_ISO_8859_10: ISO-8859-10 character encoding
FONTENCODING_ISO_8859_11: Thai
FONTENCODING_ISO_8859_13: Baltic
FONTENCODING_ISO_8859_14: ISO-8859-14 character encoding
FONTENCODING_ISO_8859_15: ISO-8859-15 character encoding
FONTENCODING_ISO_8859_16: ISO-8859-16 character encoding
FONTENCODING_KOI8: KOI-8 character encoding
FONTENCODING_KOI8_R: Russian
FONTENCODING_KOI8_U: Ukrainian
FONTENCODING_KOI8_UNIFIED: x
FONTENCODING_CP437: IBM-PC code page
FONTENCODING_CP850: IBM-PC Multilingual
FONTENCODING_CP851: IBM-PC Greek
FONTENCODING_CP852: IBM-PC Latin2
FONTENCODING_CP855: IBM-PC Cyrillic
FONTENCODING_CP856: IBM-PC Hebrew
FONTENCODING_CP857: IBM-PC Turkish
FONTENCODING_CP860: IBM-PC Portugese
FONTENCODING_CP861: IBM-PC Iceland
FONTENCODING_CP862: IBM-PC Israel
FONTENCODING_CP863: IBM-PC Canadian/French
FONTENCODING_CP864: IBM-PC Arabic
FONTENCODING_CP865: IBM-PC Nordic
FONTENCODING_CP866: IBM-PC Cyrillic #2
FONTENCODING_CP869: IBM-PC Greek #2
FONTENCODING_CP870: Latin-2 Multilingual
FONTENCODING_CP1250: Windows Central European
FONTENCODING_CP1251: Windows Russian
FONTENCODING_CP1252: Windows Latin1
FONTENCODING_CP1253: Windows Greek
FONTENCODING_CP1254: Windows Turkish
FONTENCODING_CP1255: Windows Hebrew
FONTENCODING_CP1256: Windows Arabic
FONTENCODING_CP1257: Windows Baltic
FONTENCODING_CP1258: Windows Vietnam
FONTENCODING_CP874: Windows Thai
FONTENCODING_UNICODE: Unicode
FONTENCODING_LATIN1: same as FONTENCODING_ISO_8859_1, Latin 1 (West European)
FONTENCODING_LATIN2: same as FONTENCODING_ISO_8859_2, Latin 2 (East European)
FONTENCODING_LATIN3: same as FONTENCODING_ISO_8859_3, Latin 3 (South European)
FONTENCODING_LATIN4: same as FONTENCODING_ISO_8859_4, Latin 4 (North European)
FONTENCODING_LATIN5: same as FONTENCODING_ISO_8859_9, Latin 5 (Turkish)
FONTENCODING_LATIN6: same as FONTENCODING_ISO_8859_10, Latin 6 (Nordic)
FONTENCODING_LATIN7: same as FONTENCODING_ISO_8859_13, Latin 7 (Baltic Rim)
FONTENCODING_LATIN8: same as FONTENCODING_ISO_8859_14, Latin 8 (Celtic)
FONTENCODING_LATIN9: same as FONTENCODING_ISO_8859_15, Latin 9 (a.k.a. Latin 0)
FONTENCODING_LATIN10: same as FONTENCODING_ISO_8859_16, Latin 10
FONTENCODING_USASCII: same as FONTENCODING_ISO_8859_1, Latin 1
FONTENCODING_WESTEUROPE: same as FONTENCODING_ISO_8859_1, Latin 1 (West European)
FONTENCODING_EASTEUROPE: same as FONTENCODING_ISO_8859_2, Latin 2 (East European)
FONTENCODING_SOUTHEUROPE: same as FONTENCODING_ISO_8859_3, Latin 3 (South European)
FONTENCODING_NORTHEUROPE: same as FONTENCODING_ISO_8859_4, Latin 4 (North European)
FONTENCODING_CYRILLIC: same as FONTENCODING_ISO_8859_5, Cyrillic
FONTENCODING_RUSSIAN: same as FONTENCODING_KOI8, Cyrillic
FONTENCODING_ARABIC: same as FONTENCODING_ISO_8859_6, Arabic
FONTENCODING_GREEK: same as FONTENCODING_ISO_8859_7, Greek
FONTENCODING_HEBREW: same as FONTENCODING_ISO_8859_8, Hebrew
FONTENCODING_TURKISH: same as FONTENCODING_ISO_8859_9, Latin 5 (Turkish)
FONTENCODING_NORDIC: same as FONTENCODING_ISO_8859_10, Latin 6 (Nordic)
FONTENCODING_THAI: same as FONTENCODING_ISO_8859_11, Thai
FONTENCODING_BALTIC: same as FONTENCODING_ISO_8859_13, Latin 7 (Baltic Rim)
FONTENCODING_CELTIC: same as <tt>FONTENCODING_ISO_8859_14, Latin 8 (Celtic)

Attributes

actualEncoding [R]

Actual encoding [Integer]

actualName [R]

Actual font family name [String]

actualSetWidth [R]

Actual set width [Integer]

actualSize [R]

Actual size in deci-points [Integer]

actualSlant [R]

Actual slant [Integer]

actualWeight [R]

Actual font weight [Integer]

angle [RW]

Font angle [Integer]

encoding [R]

Encoding [Integer]

font [RW]

Font description as a string [String]

fontAscent [R]

Ascent from baseline [Integer]

fontDesc [RW]

Font description {FXFontDesc}

fontDescent [R]

Descent from baseline [Integer]

fontHeight [R]

Height of tallest character in font [Integer]

fontLeading [R]

Font leading [Integer]

fontSpacing [R]

Font line spacing [Integer]

fontWidth [R]

Width of widest character in font [Integer]

hints [R]

Hints [Integer]

maxChar [R]

Last character glyph in font [Integer]

minChar [R]

First character glyph in font [Integer]

name [R]

Font family name [String]

setWidth [R]

Set width [Integer]

size [R]

Size in decipoints [Integer]

slant [R]

Slant [Integer]

weight [R]

Font weight [Integer]

Public Class Methods

listFonts (*args)

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)

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 = 0;
    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 = 0;
    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 = 0;
    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)

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)

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;
}

Font angle [Integer]

create (*args)

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)

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)

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)

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;
}

Family part of name [String]

flags (*args)

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)

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;
}

Font description as a string [String]

fontMono? ()

Source

# File rdoc-sources/FXFont.rb, line 315
def fontMono? ; end

Return true if font is monospaced.

foundry (*args)

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;
}

Foundry part of name [String]

getActualEncoding (*args)

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)

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)

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)

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)

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)

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)

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)

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;
}

getFont ()

Source

# File rdoc-sources/FXFont.rb, line 310
def getFont(); end

Return the font description as a string suitable for parsing with {#setFont}, see above.

getFontAscent (*args)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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 = 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 *","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;
}