class Fox::FXFrame

The Frame widget provides borders around some contents. Borders may be raised, sunken, thick, ridged or etched. They can also be turned off completely. In addition, a certain amount of padding may be specified between the contents of the widget and the borders. The contents may be justified inside the widget using the justification options. The Frame widget is sometimes used by itself as a place holder, but most often is used as a convenient base class for simple controls.

Constants¶ ↑

DEFAULT_PAD: Default padding

Attributes

baseColor [RW]

Base GUI color {FXColor}

borderColor [RW]

Border color {FXColor}

borderWidth [R]

Border width, in pixels [Integer]

frameStyle [RW]

Frame style [Integer]

hiliteColor [RW]

Highlight color {FXColor}

padBottom [RW]

Bottom interior padding, in pixels [Integer]

padLeft [RW]

Left interior padding, in pixels [Integer]

padRight [RW]

Right interior padding, in pixels [Integer]

padTop [RW]

Top interior padding, in pixels [Integer]

shadowColor [RW]

Shadow color {FXColor}

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXFrame(int argc, VALUE *argv, VALUE self) {
  FXComposite *arg1 = (FXComposite *) 0 ;
  FXuint arg2 = (FXuint) FRAME_NORMAL ;
  FXint arg3 = (FXint) 0 ;
  FXint arg4 = (FXint) 0 ;
  FXint arg5 = (FXint) 0 ;
  FXint arg6 = (FXint) 0 ;
  FXint arg7 = (FXint) DEFAULT_PAD ;
  FXint arg8 = (FXint) DEFAULT_PAD ;
  FXint arg9 = (FXint) DEFAULT_PAD ;
  FXint arg10 = (FXint) DEFAULT_PAD ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFrame *result = 0 ;
  
  if ((argc < 1) || (argc > 10)) {
    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 *","FXFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXComposite * >(argp1);
  if (argc > 1) {
    arg2 = NUM2UINT(argv[1]);
  }
  if (argc > 2) {
    arg3 = NUM2INT(argv[2]);
  }
  if (argc > 3) {
    arg4 = NUM2INT(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 (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXFrame *)new_FXFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (parent, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 921
def initialize(parent, *args, &blk)
  argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
  default_params = { :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
  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(parent, 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

canFocus (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_canFocus(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","canFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (bool)FXFrame_canFocus((FXFrame const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

changeFocus (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","changeFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(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);
  FXFrame_changeFocus(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

clearShape (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_clearShape(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","clearShape", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_clearShape(arg1);
  return Qnil;
fail:
  return Qnil;
}

contains (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_contains(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (bool)FXFrame_contains((FXFrame const *)arg1,arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

create (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_create(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_create(arg1);
  return Qnil;
fail:
  return Qnil;
}

destroy (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_destroy(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_destroy(arg1);
  return Qnil;
fail:
  return Qnil;
}

detach (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_detach(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","detach", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_detach(arg1);
  return Qnil;
fail:
  return Qnil;
}

disable (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_disable(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","disable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_disable(arg1);
  return Qnil;
fail:
  return Qnil;
}

doesSaveUnder (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","doesSaveUnder", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (bool)FXFrame_doesSaveUnder((FXFrame const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

dropDisable (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","dropDisable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_dropDisable(arg1);
  return Qnil;
fail:
  return Qnil;
}

dropEnable (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","dropEnable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_dropEnable(arg1);
  return Qnil;
fail:
  return Qnil;
}

enable (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_enable(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","enable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_enable(arg1);
  return Qnil;
fail:
  return Qnil;
}

getBaseColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getBaseColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBaseColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXColor)((FXFrame const *)arg1)->getBaseColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getBorderColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getBorderColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXColor)((FXFrame const *)arg1)->getBorderColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getBorderWidth (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getBorderWidth(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBorderWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)((FXFrame const *)arg1)->getBorderWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getDefaultHeight (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)FXFrame_getDefaultHeight(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getDefaultWidth (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)FXFrame_getDefaultWidth(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getFrameStyle (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getFrameStyle(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getFrameStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXuint)((FXFrame const *)arg1)->getFrameStyle();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getHeightForWidth (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getHeightForWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXFrame_getHeightForWidth(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getHiliteColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getHiliteColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXColor)((FXFrame const *)arg1)->getHiliteColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getPadBottom (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getPadBottom(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)((FXFrame const *)arg1)->getPadBottom();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getPadLeft (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getPadLeft(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)((FXFrame const *)arg1)->getPadLeft();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getPadRight (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getPadRight(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadRight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)((FXFrame const *)arg1)->getPadRight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getPadTop (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getPadTop(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadTop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXint)((FXFrame const *)arg1)->getPadTop();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getShadowColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getShadowColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getShadowColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (FXColor)((FXFrame const *)arg1)->getShadowColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getWidthForHeight (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getWidthForHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXint)FXFrame_getWidthForHeight(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

hide (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_hide(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","hide", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_hide(arg1);
  return Qnil;
fail:
  return Qnil;
}

isComposite (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_isComposite(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","isComposite", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  result = (bool)FXFrame_isComposite((FXFrame const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

killFocus (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_killFocus(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","killFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_killFocus(arg1);
  return Qnil;
fail:
  return Qnil;
}

layout (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_layout(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","layout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_layout(arg1);
  return Qnil;
fail:
  return Qnil;
}

load (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_load(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(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);
  FXFrame_load(arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}

lower (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_lower(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","lower", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_lower(arg1);
  return Qnil;
fail:
  return Qnil;
}

move (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_move(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","move", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXFrame_move(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

old_initialize (parent, *args, &blk)

Alias for: new

onPaint (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_onPaint(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","onPaint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(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;
}

position (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_position(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXFrame_position(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}

raiseWindow (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","raise", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_raise(arg1);
  return Qnil;
fail:
  return Qnil;
}

recalc (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_recalc(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","recalc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_recalc(arg1);
  return Qnil;
fail:
  return Qnil;
}

reparent (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_reparent(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","reparent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(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);
  FXFrame_reparent(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

resize (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_resize(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXFrame_resize(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

save (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_save(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(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);
  FXFrame_save((FXFrame const *)arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}

setBackColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = to_FXColor(argv[0]);
  FXFrame_setBackColor(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

setBaseColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setBaseColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBaseColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setBaseColor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setBorderColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setBorderColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setBorderColor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setDefault (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setDefault(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setDefault", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  FXFrame_setDefault(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

setFocus (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setFocus(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_setFocus(arg1);
  return Qnil;
fail:
  return Qnil;
}

setFrameStyle (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setFrameStyle(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setFrameStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  (arg1)->setFrameStyle(arg2);
  return Qnil;
fail:
  return Qnil;
}

setHiliteColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setHiliteColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setHiliteColor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setPadBottom (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setPadBottom(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setPadBottom(arg2);
  return Qnil;
fail:
  return Qnil;
}

setPadLeft (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setPadLeft(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setPadLeft(arg2);
  return Qnil;
fail:
  return Qnil;
}

setPadRight (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setPadRight(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadRight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setPadRight(arg2);
  return Qnil;
fail:
  return Qnil;
}

setPadTop (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setPadTop(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadTop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NUM2INT(argv[0]);
  (arg1)->setPadTop(arg2);
  return Qnil;
fail:
  return Qnil;
}

setShadowColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_setShadowColor(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setShadowColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setShadowColor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXFrame_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 = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXFrame_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 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_FXFrame_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 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_FXFrame_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;
}

show (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_show(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","show", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  FXFrame_show(arg1);
  return Qnil;
fail:
  return Qnil;
}

tr (*args)

Source

SWIGINTERN VALUE
_wrap_FXFrame_tr(int argc, VALUE *argv, VALUE self) {
  FXFrame *arg1 = (FXFrame *) 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_FXFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","tr", 1, self )); 
  }
  arg1 = reinterpret_cast< FXFrame * >(argp1);
  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  if (argc > 1) {
    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
  }
  result = (FXchar *)FXFrame_tr((FXFrame const *)arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}