class Fox::FXTable

Public Class Methods

csvType() click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_csvType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXTable::csvType));
  return _val;
}
csvType=(p1) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_csvType_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 '""FXTable::csvType""' of type '""FXDragType""'");
    }
    FXTable::csvType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}
csvTypeName() click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_csvTypeName_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FXTable::csvTypeName);
  return _val;
}
new(*args) click to toggle source
SWIGINTERN VALUE
_wrap_new_FXTable(int argc, VALUE *argv, VALUE self) {
  FXComposite *arg1 = (FXComposite *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 = (FXSelector) 0 ;
  FXuint arg4 = (FXuint) 0 ;
  FXint arg5 = (FXint) 0 ;
  FXint arg6 = (FXint) 0 ;
  FXint arg7 = (FXint) 0 ;
  FXint arg8 = (FXint) 0 ;
  FXint arg9 = (FXint) DEFAULT_MARGIN ;
  FXint arg10 = (FXint) DEFAULT_MARGIN ;
  FXint arg11 = (FXint) DEFAULT_MARGIN ;
  FXint arg12 = (FXint) DEFAULT_MARGIN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXTable *result = 0 ;
  
  if ((argc < 1) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTable", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXComposite * >(argp1);
  if (argc > 1) {
    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTable", 2, argv[1] )); 
    }
    arg2 = reinterpret_cast< FXObject * >(argp2);
  }
  if (argc > 2) {
    arg3 = NUM2UINT(argv[2]);
  }
  if (argc > 3) {
    arg4 = NUM2UINT(argv[3]);
  }
  if (argc > 4) {
    arg5 = NUM2INT(argv[4]);
  }
  if (argc > 5) {
    arg6 = NUM2INT(argv[5]);
  }
  if (argc > 6) {
    arg7 = NUM2INT(argv[6]);
  }
  if (argc > 7) {
    arg8 = NUM2INT(argv[7]);
  }
  if (argc > 8) {
    arg9 = NUM2INT(argv[8]);
  }
  if (argc > 9) {
    arg10 = NUM2INT(argv[9]);
  }
  if (argc > 10) {
    arg11 = NUM2INT(argv[10]);
  }
  if (argc > 11) {
    arg12 = NUM2INT(argv[11]);
  }
  {
    if (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXTable *)new_FXTable(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}
new(p, *args, &blk) click to toggle source
# File lib/fox16/kwargs.rb, line 457
def initialize(p, *args, &blk)
  argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
  default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_MARGIN, :padRight => DEFAULT_MARGIN, :padTop => DEFAULT_MARGIN, :padBottom => DEFAULT_MARGIN }
  params = {}
  params = args.pop if args.last.is_a? Hash
  args.each_with_index { |e, i| params[argument_names[i].intern] = e }
  if params.key? :padding
    value = params.delete(:padding)
    [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
  end
  params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
  params = default_params.merge(params)
  old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
end
Also aliased as: old_initialize

Public Instance Methods

acceptInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_acceptInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","acceptInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  FXTable_acceptInput(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
appendColumns(numColumns=1, notify=false) click to toggle source

Append numColumns columns to the right of the table.. If notify is true, a SEL_INSERTED message is sent to the table�s message target for each cell that is inserted.

# File lib/fox16/core.rb, line 634
def appendColumns(numColumns=1, notify=false)
  insertColumns(self.numColumns, numColumns, notify)
end
appendRows(numRows=1, notify=false) click to toggle source

Append numRows rows to the bottom of the table.. If notify is true, a SEL_INSERTED message is sent to the table�s message target for each cell that is inserted.

# File lib/fox16/core.rb, line 643
def appendRows(numRows=1, notify=false)
  insertRows(self.numRows, numRows, notify)
end
canFocus(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_canFocus(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","canFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (bool)FXTable_canFocus((FXTable const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}
cancelInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_cancelInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","cancelInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_cancelInput(arg1);
  return Qnil;
fail:
  return Qnil;
}
changeFocus(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_changeFocus(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXWindow *arg2 = (FXWindow *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","changeFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  FXTable_changeFocus(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
clearItems(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_clearItems(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","clearItems", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  FXTable_clearItems(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
clearShape(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_clearShape(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","clearShape", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_clearShape(arg1);
  return Qnil;
fail:
  return Qnil;
}
colAtX(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_colAtX(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","colAtX", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)((FXTable const *)arg1)->colAtX(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
columnRenumbering=(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_columnRenumberinge___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnRenumbering", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXbool(argv[0]);
  (arg1)->setColumnRenumbering(arg2);
  return Qnil;
fail:
  return Qnil;
}
columnRenumbering?(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_columnRenumberingq___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnRenumbering", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->getColumnRenumbering();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
contains(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_contains(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (bool)FXTable_contains((FXTable const *)arg1,arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}
cornerButton(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_cornerButton(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXButton *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCornerButton", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXButton *)((FXTable const *)arg1)->getCornerButton();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
countText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_countText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXString *arg2 = 0 ;
  FXchar *arg3 = (FXchar *) "\t," ;
  FXchar *arg4 = (FXchar *) "\n" ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","countText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  if (argc > 1) {
    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
  }
  if (argc > 2) {
    arg4 = NIL_P(argv[2]) ? 0 : StringValuePtr(argv[2]);
  }
  result = (VALUE)FXTable_countText((FXTable const *)arg1,(FXString const &)*arg2,(char const *)arg3,(char const *)arg4);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}
create(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_create(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_create(arg1);
  return Qnil;
fail:
  return Qnil;
}
createItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_createItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXString *arg2 = 0 ;
  FXIcon *arg3 = (FXIcon *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  FXTableItem *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","createItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","createItem", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXIcon * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createItem", 4, argv[2] )); 
  }
  result = (FXTableItem *)FXTable_createItem(arg1,(FXString const &)*arg2,arg3,arg4);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
destroy(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_destroy(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_destroy(arg1);
  return Qnil;
fail:
  return Qnil;
}
detach(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_detach(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","detach", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_detach(arg1);
  return Qnil;
fail:
  return Qnil;
}
disable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_disable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","disable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_disable(arg1);
  return Qnil;
fail:
  return Qnil;
}
disableItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_disableItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","disableItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)FXTable_disableItem(arg1,arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
doesSaveUnder(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","doesSaveUnder", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (bool)FXTable_doesSaveUnder((FXTable const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}
drawCell(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_drawCell(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXDC *arg2 = 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawCell", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawCell", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawCell", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXDC * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  FXTable_drawCell(arg1,*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
drawContents(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_drawContents(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXDC *arg2 = 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawContents", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawContents", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawContents", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXDC * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  FXTable_drawContents(arg1,*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
drawHGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_drawHGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXDC *arg2 = 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawHGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawHGrid", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawHGrid", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXDC * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  FXTable_drawHGrid(arg1,*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
drawRange(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_drawRange(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXDC *arg2 = 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawRange", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawRange", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawRange", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXDC * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  FXTable_drawRange(arg1,*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
drawVGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_drawVGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXDC *arg2 = 0 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawVGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawVGrid", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawVGrid", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXDC * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  FXTable_drawVGrid(arg1,*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
dropDisable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_dropDisable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","dropDisable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_dropDisable(arg1);
  return Qnil;
fail:
  return Qnil;
}
dropEnable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_dropEnable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","dropEnable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_dropEnable(arg1);
  return Qnil;
fail:
  return Qnil;
}
each()
Alias for: each_row
each_column() { |itemArray| ... } click to toggle source

Calls block once for each column in the table, passing an array of references (one element per row) as a parameter.

# File lib/fox16/iterators.rb, line 179
def each_column # :yields: itemArray
  0.upto(numColumns - 1) do |j|
    tableCol = []
    0.upto(numRows - 1) do |i|
      tableCol << getItem(i, j)
    end
    yield tableCol
  end
  self
end
each_row() { |itemArray| ... } click to toggle source

Calls block once for each row in the table, passing an array of references (one element per column) as a parameter.

# File lib/fox16/iterators.rb, line 164
def each_row # :yields: itemArray
  0.upto(numRows - 1) do |i|
    tableRow = []
    0.upto(numColumns - 1) do |j|
      tableRow << getItem(i, j)
    end
    yield tableRow
  end
  self
end
Also aliased as: each
editable=(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_editablee___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setEditable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  (arg1)->setEditable(arg2);
  return Qnil;
fail:
  return Qnil;
}
editable?(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_editableq___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isEditable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->isEditable();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
enable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_enable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","enable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_enable(arg1);
  return Qnil;
fail:
  return Qnil;
}
enableItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_enableItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","enableItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)FXTable_enableItem(arg1,arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
extendSelection(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_extendSelection(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","extendSelection", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  result = (FXbool)FXTable_extendSelection(arg1,arg2,arg3,arg4);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
extractItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_extractItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXTableItem *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","extractItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXTableItem *)FXTable_extractItem(arg1,arg2,arg3,arg4);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
extractText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_extractText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXchar *arg6 = (FXchar *) "\t" ;
  FXchar *arg7 = (FXchar *) "\n" ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","extractText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg6 = NIL_P(argv[4]) ? 0 : StringValuePtr(argv[4]);
  }
  if (argc > 5) {
    arg7 = NIL_P(argv[5]) ? 0 : StringValuePtr(argv[5]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  {
    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (VALUE)FXTable_extractText((FXTable const *)arg1,arg2,arg3,arg4,arg5,(char const *)arg6,(char const *)arg7);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}
first() click to toggle source

Override Enumerable#first with FXWindow#first for backwards compatibility.

# File lib/fox16/iterators.rb, line 156
def first
  getFirst
end
fitColumnsToContents(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_fitColumnsToContents(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","fitColumnsToContents", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 + arg3 > arg1->getNumColumns()) {
      rb_raise(rb_eIndexError,"table column out of bounds");
    }
  }
  (arg1)->fitColumnsToContents(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
fitRowsToContents(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_fitRowsToContents(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","fitRowsToContents", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 + arg3 > arg1->getNumRows()) {
      rb_raise(rb_eIndexError,"table row out of bounds");
    }
  }
  (arg1)->fitRowsToContents(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
getAnchorColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getAnchorColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getAnchorColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getAnchorColumn();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getAnchorRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getAnchorRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getAnchorRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getAnchorRow();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getBaseColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getBaseColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getBaseColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getBaseColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getBorderColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getBorderColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getBorderColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getCellBorderColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getCellBorderColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getCellBorderColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getCellBorderWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getCellBorderWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellBorderWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getCellBorderWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getCellColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getCellColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 != 0 && arg2 != 1) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 != 0 && arg3 != 1) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXColor)((FXTable const *)arg1)->getCellColor(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnHeader(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnHeader(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXHeader *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeader", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXHeader *)((FXTable const *)arg1)->getColumnHeader();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getColumnHeaderFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnHeaderFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFont *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXFont *)((FXTable const *)arg1)->getColumnHeaderFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getColumnHeaderHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnHeaderHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getColumnHeaderHeight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnHeaderMode(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnHeaderMode(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderMode", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXuint)((FXTable const *)arg1)->getColumnHeaderMode();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXIcon *result = 0 ;
  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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXIcon *)((FXTable const *)arg1)->getColumnIcon(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getColumnIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getColumnIconPosition(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getColumnJustify(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = ((FXTable const *)arg1)->getColumnText(arg2);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
getColumnWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXint)((FXTable const *)arg1)->getColumnWidth(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getColumnX(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getColumnX(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnX", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXTable_getColumnX((FXTable const *)arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getContentHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getContentHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getContentHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getContentHeight(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getContentWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getContentWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getContentWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getContentWidth(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getCurrentColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getCurrentColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCurrentColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getCurrentColumn();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getCurrentRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getCurrentRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCurrentRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getCurrentRow();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getDefColumnWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getDefColumnWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getDefColumnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getDefColumnWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getDefRowHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getDefRowHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getDefRowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getDefRowHeight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getDefaultHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getDefaultHeight(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getDefaultWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getDefaultWidth(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFont *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXFont *)((FXTable const *)arg1)->getFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getGridColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getGridColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getGridColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getGridColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getHeightForWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getHeightForWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXTable_getHeightForWidth(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getHelpText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getHelpText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXString *) &((FXTable const *)arg1)->getHelpText();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}
getHiliteColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getHiliteColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getHiliteColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXTableItem *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXTableItem *)((FXTable const *)arg1)->getItem(arg2,arg3);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getItemBorders(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemBorders(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemBorders", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getItemBorders(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getItemData(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemData(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (VALUE)FXTable_getItemData((FXTable const *)arg1,arg2,arg3);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}
getItemIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXIcon *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXIcon *)((FXTable const *)arg1)->getItemIcon(arg2,arg3);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getItemIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getItemIconPosition(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getItemJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getItemJustify(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getItemStipple(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemStipple(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXStipplePattern result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemStipple", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXStipplePattern)((FXTable const *)arg1)->getItemStipple(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getItemText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getItemText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = ((FXTable const *)arg1)->getItemText(arg2,arg3);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
getMarginBottom(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMarginBottom(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getMarginBottom();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getMarginLeft(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMarginLeft(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getMarginLeft();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getMarginRight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMarginRight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginRight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getMarginRight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getMarginTop(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMarginTop(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginTop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getMarginTop();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getMinColumnWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMinColumnWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMinColumnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXint)((FXTable const *)arg1)->getMinColumnWidth(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getMinRowHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getMinRowHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMinRowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXint)((FXTable const *)arg1)->getMinRowHeight(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getNumColumns(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getNumColumns(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getNumColumns", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getNumColumns();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getNumRows(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getNumRows(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getNumRows", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getNumRows();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowHeader(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowHeader(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXHeader *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeader", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXHeader *)((FXTable const *)arg1)->getRowHeader();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getRowHeaderFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowHeaderFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFont *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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXFont *)((FXTable const *)arg1)->getRowHeaderFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getRowHeaderMode(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowHeaderMode(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderMode", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXuint)((FXTable const *)arg1)->getRowHeaderMode();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowHeaderWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowHeaderWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getRowHeaderWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXint)((FXTable const *)arg1)->getRowHeight(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXIcon *result = 0 ;
  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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXIcon *)((FXTable const *)arg1)->getRowIcon(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getRowIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getRowIconPosition(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXuint)((FXTable const *)arg1)->getRowJustify(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getRowText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = ((FXTable const *)arg1)->getRowText(arg2);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}
getRowY(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getRowY(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowY", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXTable_getRowY((FXTable const *)arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelBackColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelBackColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getSelBackColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelEndColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelEndColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelEndColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getSelEndColumn();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelEndRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelEndRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelEndRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getSelEndRow();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelStartColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelStartColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelStartColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getSelStartColumn();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelStartRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelStartRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelStartRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getSelStartRow();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getSelTextColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getSelTextColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getSelTextColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getShadowColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getShadowColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getShadowColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getShadowColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getStippleColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getStippleColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getStippleColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getStippleColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getTableStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getTableStyle(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getTableStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXuint)((FXTable const *)arg1)->getTableStyle();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getTextColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getTextColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXColor)((FXTable const *)arg1)->getTextColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getViewportHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getViewportHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getViewportHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getViewportHeight(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getViewportWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getViewportWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getViewportWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)FXTable_getViewportWidth(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getVisibleColumns(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getVisibleColumns(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getVisibleColumns", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getVisibleColumns();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getVisibleRows(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getVisibleRows(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getVisibleRows", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXint)((FXTable const *)arg1)->getVisibleRows();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getWidthForHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getWidthForHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXTable_getWidthForHeight(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
hide(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_hide(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","hide", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_hide(arg1);
  return Qnil;
fail:
  return Qnil;
}
insertColumns(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_insertColumns(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","insertColumns", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 > arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_insertColumns(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
insertRows(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_insertRows(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","insertRows", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 > arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  FXTable_insertRows(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
isAnythingSelected(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isAnythingSelected(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isAnythingSelected", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->isAnythingSelected();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isColumnSelected(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isColumnSelected(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isColumnSelected", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isColumnSelected(arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isComposite(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isComposite(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isComposite", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (bool)FXTable_isComposite((FXTable const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}
isHorzGridShown(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isHorzGridShown(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isHorzGridShown", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->isHorzGridShown();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isItemCurrent(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isItemCurrent(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemCurrent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isItemCurrent(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isItemEnabled(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isItemEnabled(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isItemEnabled(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isItemSelected(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isItemSelected(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemSelected", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isItemSelected(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isItemSpanning(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isItemSpanning(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemSpanning", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isItemSpanning(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isItemVisible(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isItemVisible(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isItemVisible(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isRowSelected(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isRowSelected(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isRowSelected", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXbool)((FXTable const *)arg1)->isRowSelected(arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
isVertGridShown(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_isVertGridShown(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isVertGridShown", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->isVertGridShown();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
killFocus(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_killFocus(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","killFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_killFocus(arg1);
  return Qnil;
fail:
  return Qnil;
}
killSelection(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_killSelection(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","killSelection", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXbool)FXTable_killSelection(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
layout(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_layout(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","layout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_layout(arg1);
  return Qnil;
fail:
  return Qnil;
}
load(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_load(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(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);
  FXTable_load(arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}
lower(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_lower(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","lower", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_lower(arg1);
  return Qnil;
fail:
  return Qnil;
}
makePositionVisible(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_makePositionVisible(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","makePositionVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXTable_makePositionVisible(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
move(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_move(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","move", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXTable_move(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
old_initialize(p, *args, &blk)
Alias for: new
onAutoScroll(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onAutoScroll(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onAutoScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onClicked(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onClicked(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClicked", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onClipboardGained(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onClipboardGained(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardGained", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onClipboardLost(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onClipboardLost(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardLost", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onClipboardRequest(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdAcceptInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdAcceptInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdAcceptInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAcceptInput", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdAcceptInput(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdCancelInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdCancelInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCancelInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancelInput", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdCancelInput(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdCopySel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdCopySel(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCopySel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopySel", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdCopySel(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdCutSel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdCutSel(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCutSel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCutSel", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdCutSel(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdDeleteColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdDeleteColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdDeleteColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdDeleteRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdDeleteRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdDeleteRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdDeleteSel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdDeleteSel(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteSel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteSel", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdDeleteSel(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdDeselectAll(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdDeselectAll(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeselectAll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeselectAll", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdDeselectAll(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdExtend(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdExtend(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdExtend", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdExtend", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdExtend(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdHorzGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdHorzGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdHorzGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHorzGrid", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdHorzGrid(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdInsertColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdInsertColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdInsertColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdInsertColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdInsertRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdInsertRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdInsertRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdInsertRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMark(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMark(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMark", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMark", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMark(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveBottom(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveBottom(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveBottom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveBottom(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveDown(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveDown(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveDown", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveDown", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveDown(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveEnd(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveEnd(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveEnd", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveEnd(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveHome(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveHome(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveHome", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveHome", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveHome(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveLeft(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveLeft(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveLeft", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveLeft(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMovePageDown(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMovePageDown(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMovePageDown", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMovePageDown", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMovePageDown(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMovePageUp(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMovePageUp(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMovePageUp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMovePageUp", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMovePageUp(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveRight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveRight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveRight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveRight", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveRight(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveTop(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveTop(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveTop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveTop", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveTop(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdMoveUp(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdMoveUp(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveUp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveUp", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdMoveUp(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdPasteSel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdPasteSel(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdPasteSel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteSel", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdPasteSel(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectAll(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectAll(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectAll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectAll", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectAll(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectCell(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectCell(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectCell", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectCell", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectCell(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectColumnIndex(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectColumnIndex(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectColumnIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectColumnIndex", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectColumnIndex(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdSelectRowIndex(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdSelectRowIndex(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectRowIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectRowIndex", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdSelectRowIndex(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdStartInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdStartInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdStartInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdStartInput", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdStartInput(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdToggleEditable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdToggleEditable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdToggleEditable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleEditable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdToggleEditable(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCmdVertGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCmdVertGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdVertGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdVertGrid", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCmdVertGrid(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onCommand(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onCommand(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCommand", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onDoubleClicked(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onDoubleClicked", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onFocusIn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onFocusIn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onFocusIn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onFocusOut(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onFocusOut(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onFocusOut", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onKeyPress(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onKeyPress(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onKeyPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onKeyRelease(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onKeyRelease(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onKeyRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onLeftBtnPress(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onLeftBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onLeftBtnRelease(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onLeftBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onMotion(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onMotion(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onMotion", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onPaint(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onPaint(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onPaint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onRightBtnPress(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onRightBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onRightBtnRelease(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onRightBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onSelectionGained(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onSelectionGained(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionGained", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onSelectionLost(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onSelectionLost(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionLost", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onSelectionRequest(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onTripleClicked(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onTripleClicked(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onTripleClicked", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUngrabbed(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUngrabbed(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUngrabbed", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdAcceptInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdAcceptInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdAcceptInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAcceptInput", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdAcceptInput(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdDeleteColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdDeleteColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeleteColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeleteColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdDeleteColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdDeleteRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdDeleteRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeleteRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeleteRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdDeleteRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdDeselectAll(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdDeselectAll(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeselectAll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeselectAll", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdDeselectAll(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdHaveSelection(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdHaveSelection(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdHaveSelection", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHaveSelection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdHaveSelection(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdHorzGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdHorzGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdHorzGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHorzGrid", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdHorzGrid(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdInsertColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdInsertColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdInsertColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdInsertColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdInsertColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdInsertRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdInsertRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdInsertRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdInsertRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdInsertRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdSelectAll(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdSelectAll(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectAll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectAll", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdSelectAll(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdSelectCell(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdSelectCell(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res4 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectCell", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectCell", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdSelectCell", 4, argv[2] )); 
  }
  result = (long)(arg1)->onUpdSelectCell(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdSelectColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdSelectColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectColumn", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdSelectColumn(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdSelectRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdSelectRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res4 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectRow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdSelectRow", 4, argv[2] )); 
  }
  result = (long)(arg1)->onUpdSelectRow(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdStartInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdStartInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdStartInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdStartInput", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdStartInput(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdToggleEditable(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdToggleEditable(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdToggleEditable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleEditable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdToggleEditable(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
onUpdVertGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_onUpdVertGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdVertGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdVertGrid", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = 0;
  result = (long)(arg1)->onUpdVertGrid(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}
overlayText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_overlayText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  VALUE arg6 = (VALUE) 0 ;
  FXchar *arg7 = (FXchar *) "\t" ;
  FXchar *arg8 = (FXchar *) "\n" ;
  FXbool arg9 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 5) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","overlayText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = argv[4];
  if (argc > 5) {
    arg7 = NIL_P(argv[5]) ? 0 : StringValuePtr(argv[5]);
  }
  if (argc > 6) {
    arg8 = NIL_P(argv[6]) ? 0 : StringValuePtr(argv[6]);
  }
  if (argc > 7) {
    arg9 = to_FXbool(argv[7]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  {
    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_overlayText(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,(char const *)arg8,arg9);
  return Qnil;
fail:
  return Qnil;
}
position(*args) click to toggle source
SWIGINTERN VALUE _wrap_FXTable_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FXTable_position__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              return _wrap_FXTable_position__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "position", 
    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
    "    VALUE position()\n");
  
  return Qnil;
}
raiseWindow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_raiseWindow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","raise", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_raise(arg1);
  return Qnil;
fail:
  return Qnil;
}
recalc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_recalc(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","recalc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_recalc(arg1);
  return Qnil;
fail:
  return Qnil;
}
removeColumns(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_removeColumns(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeColumns", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 + arg3 > arg1->getNumColumns()) {
      rb_raise(rb_eIndexError,"table column out of bounds");
    }
  }
  FXTable_removeColumns(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
removeItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_removeItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_removeItem(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
removeRange(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_removeRange(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXbool arg6 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeRange", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg6 = to_FXbool(argv[4]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  {
    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_removeRange(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
removeRows(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_removeRows(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 = (FXint) 1 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeRows", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  {
    if (arg2 < 0 || arg2 + arg3 > arg1->getNumRows()) {
      rb_raise(rb_eIndexError,"table row out of bounds");
    }
  }
  FXTable_removeRows(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
reparent(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_reparent(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  FXWindow *arg3 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","reparent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXWindow * >(argp3);
  FXTable_reparent(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
resize(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_resize(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXTable_resize(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
rowAtY(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_rowAtY(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","rowAtY", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)((FXTable const *)arg1)->rowAtY(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
rowRenumbering=(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_rowRenumberinge___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowRenumbering", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXbool(argv[0]);
  (arg1)->setRowRenumbering(arg2);
  return Qnil;
fail:
  return Qnil;
}
rowRenumbering?(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_rowRenumberingq___(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowRenumbering", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  result = (FXbool)((FXTable const *)arg1)->getRowRenumbering();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
save(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_save(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(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);
  FXTable_save((FXTable const *)arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}
selectColumn(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_selectColumn(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)FXTable_selectColumn(arg1,arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
selectItem(row, col, notify=false) click to toggle source

Select cell at (row, col). If notify is true, a SEL_SELECTED message is sent to the table's message target after the item is selected. Raises IndexError if either row or col is out of bounds.

# File lib/fox16/core.rb, line 652
def selectItem(row, col, notify=false)
  selectRange(row, row, col, col, notify)
end
selectRange(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_selectRange(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXbool arg6 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool 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(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectRange", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg6 = to_FXbool(argv[4]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  {
    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  result = (FXbool)FXTable_selectRange(arg1,arg2,arg3,arg4,arg5,arg6);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
selectRow(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_selectRow(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectRow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  result = (FXbool)FXTable_selectRow(arg1,arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}
setAnchorItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setAnchorItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setAnchorItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setAnchorItem(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setBackColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setBackColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  FXTable_setBackColor(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setBaseColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setBaseColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBaseColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setBaseColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setBorderColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setBorderColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setBorderColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setCellBorderColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setCellBorderColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setCellBorderColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setCellBorderWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setCellBorderWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellBorderWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setCellBorderWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}
setCellColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setCellColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXColor arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = to_FXColor(argv[2]);
  {
    if (arg2 != 0 && arg2 != 1) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 != 0 && arg3 != 1) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setCellColor(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setColumnHeaderFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnHeaderFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXFont *arg2 = (FXFont *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setColumnHeaderFont", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXFont * >(argp2);
  (arg1)->setColumnHeaderFont(arg2);
  return Qnil;
fail:
  return Qnil;
}
setColumnHeaderHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnHeaderHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setColumnHeaderHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}
setColumnHeaderMode(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnHeaderMode(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXuint arg2 = (FXuint) LAYOUT_FIX_HEIGHT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderMode", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = NUM2UINT(argv[0]);
  }
  (arg1)->setColumnHeaderMode(arg2);
  return Qnil;
fail:
  return Qnil;
}
setColumnIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXIcon *arg3 = (FXIcon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setColumnIcon", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXIcon * >(argp3);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setColumnIcon(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setColumnIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setColumnIconPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setColumnJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setColumnJustify(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setColumnText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p3 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  p3 = to_FXString(argv[1]); arg3 = &p3;
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setColumnText(arg2,(FXString const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}
setColumnWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setColumnWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_setColumnWidth(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setCurrentItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setCurrentItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCurrentItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  FXTable_setCurrentItem(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setDefColumnWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setDefColumnWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefColumnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setDefColumnWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}
setDefRowHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setDefRowHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefRowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setDefRowHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}
setDefault(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setDefault(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefault", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  FXTable_setDefault(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setFocus(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setFocus(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_setFocus(arg1);
  return Qnil;
fail:
  return Qnil;
}
setFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXFont *arg2 = (FXFont *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXFont * >(argp2);
  (arg1)->setFont(arg2);
  return Qnil;
fail:
  return Qnil;
}
setGridColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setGridColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setGridColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setGridColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setHelpText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setHelpText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  (arg1)->setHelpText((FXString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}
setHiliteColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setHiliteColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setHiliteColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXTableItem *arg4 = (FXTableItem *) 0 ;
  FXbool arg5 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTableItem, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTableItem *","setItem", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FXTableItem * >(argp4);
  if (argc > 3) {
    arg5 = to_FXbool(argv[3]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_setItem(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
setItemBorders(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemBorders(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXuint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemBorders", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2UINT(argv[2]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setItemBorders(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setItemData(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemData(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  VALUE arg4 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = argv[2];
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_setItemData(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setItemIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXIcon *arg4 = (FXIcon *) 0 ;
  FXbool arg5 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FXIcon * >(argp4);
  if (argc > 3) {
    arg5 = to_FXbool(argv[3]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_setItemIcon(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
setItemIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXuint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2UINT(argv[2]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setItemIconPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setItemJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXuint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2UINT(argv[2]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setItemJustify(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setItemStipple(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemStipple(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXStipplePattern arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemStipple", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXStipplePattern","setItemStipple", 4, argv[2] ));
  } 
  arg4 = static_cast< FXStipplePattern >(val4);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  (arg1)->setItemStipple(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setItemText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setItemText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXString *arg4 = 0 ;
  FXbool arg5 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p4 ;
  
  if ((argc < 3) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  p4 = to_FXString(argv[2]); arg4 = &p4;
  if (argc > 3) {
    arg5 = to_FXbool(argv[3]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  FXTable_setItemText(arg1,arg2,arg3,(FXString const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
setMarginBottom(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setMarginBottom(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setMarginBottom(arg2);
  return Qnil;
fail:
  return Qnil;
}
setMarginLeft(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setMarginLeft(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setMarginLeft(arg2);
  return Qnil;
fail:
  return Qnil;
}
setMarginRight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setMarginRight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginRight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setMarginRight(arg2);
  return Qnil;
fail:
  return Qnil;
}
setMarginTop(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setMarginTop(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginTop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setMarginTop(arg2);
  return Qnil;
fail:
  return Qnil;
}
setRowHeaderFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowHeaderFont(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXFont *arg2 = (FXFont *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setRowHeaderFont", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXFont * >(argp2);
  (arg1)->setRowHeaderFont(arg2);
  return Qnil;
fail:
  return Qnil;
}
setRowHeaderMode(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowHeaderMode(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXuint arg2 = (FXuint) LAYOUT_FIX_WIDTH ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderMode", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = NUM2UINT(argv[0]);
  }
  (arg1)->setRowHeaderMode(arg2);
  return Qnil;
fail:
  return Qnil;
}
setRowHeaderWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowHeaderWidth(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setRowHeaderWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}
setRowHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowHeight(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  FXTable_setRowHeight(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setRowIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowIcon(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXIcon *arg3 = (FXIcon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setRowIcon", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXIcon * >(argp3);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  (arg1)->setRowIcon(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setRowIconPosition(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowIconPosition(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  (arg1)->setRowIconPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setRowJustify(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowJustify(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  (arg1)->setRowJustify(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
setRowText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setRowText(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p3 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  p3 = to_FXString(argv[1]); arg3 = &p3;
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  (arg1)->setRowText(arg2,(FXString const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}
setSelBackColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setSelBackColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setSelBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setSelBackColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setSelTextColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setSelTextColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setSelTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setSelTextColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setShadowColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setShadowColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setShadowColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setShadowColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setShape(*args) click to toggle source
SWIGINTERN VALUE _wrap_FXTable_setShape(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXTable_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXTable_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXTable_setShape__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "setShape", 
    "    void setShape(FXRegion const &region)\n"
    "    void setShape(FXBitmap *bitmap)\n"
    "    void setShape(FXIcon *icon)\n");
  
  return Qnil;
}
setStippleColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setStippleColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setStippleColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setStippleColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setTableSize(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setTableSize(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTableSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    arg4 = to_FXbool(argv[2]);
  }
  FXTable_setTableSize(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setTableStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setTableStyle(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXuint 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTableStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  (arg1)->setTableStyle(arg2);
  return Qnil;
fail:
  return Qnil;
}
setTextColor(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setTextColor(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXColor 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setTextColor(arg2);
  return Qnil;
fail:
  return Qnil;
}
setVisibleColumns(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setVisibleColumns(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setVisibleColumns", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setVisibleColumns(arg2);
  return Qnil;
fail:
  return Qnil;
}
setVisibleRows(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_setVisibleRows(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setVisibleRows", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setVisibleRows(arg2);
  return Qnil;
fail:
  return Qnil;
}
show(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_show(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 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_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","show", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  FXTable_show(arg1);
  return Qnil;
fail:
  return Qnil;
}
showHorzGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_showHorzGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","showHorzGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  (arg1)->showHorzGrid(arg2);
  return Qnil;
fail:
  return Qnil;
}
showVertGrid(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_showVertGrid(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXbool arg2 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","showVertGrid", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  (arg1)->showVertGrid(arg2);
  return Qnil;
fail:
  return Qnil;
}
startInput(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_startInput(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","startInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXTable_startInput(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
tr(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_tr(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXchar *arg2 = (FXchar *) 0 ;
  FXchar *arg3 = (FXchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXchar *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","tr", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  if (argc > 1) {
    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
  }
  result = (FXchar *)FXTable_tr((FXTable const *)arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
updateItem(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_updateItem(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","updateItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
      rb_raise(rb_eIndexError, "table row out of bounds");
    }
  }
  {
    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
      rb_raise(rb_eIndexError, "table column out of bounds");
    }
  }
  ((FXTable const *)arg1)->updateItem(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
updateRange(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXTable_updateRange(int argc, VALUE *argv, VALUE self) {
  FXTable *arg1 = (FXTable *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","updateRange", 1, self )); 
  }
  arg1 = reinterpret_cast< FXTable * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXTable_updateRange((FXTable const *)arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}