class Fox::FXToolBarGrip

A tool bar grip is used to move its container, a dock bar. The grip draws either a single or double bar; it is customary to use the single bar grip for toolbar-rearrangements only, and use the double-bar when the toolbar needs to be floated or docked. The tool bar grip is automatically oriented properly by the the toolbar widget, similar to the FXSeparator widget. Holding the Control Key while dragging the grip will prevent the toolbar from docking when it is near a dock site.

TOOLBARGRIP_SINGLE: Single bar mode for movable tool bars
TOOLBARGRIP_DOUBLE: Double bar mode for dockable tool bars

Attributes

activeColor [RW]

Active color {FXColor}

doubleBar [W]

Indicates whether the grip is displayed as a double-bar [Boolean]

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXToolBarGrip(int argc, VALUE *argv, VALUE self) {
  FXToolBar *arg1 = (FXToolBar *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 = (FXSelector) 0 ;
  FXuint arg4 = (FXuint) TOOLBARGRIP_SINGLE ;
  FXint arg5 = (FXint) 0 ;
  FXint arg6 = (FXint) 0 ;
  FXint arg7 = (FXint) 0 ;
  FXint arg8 = (FXint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXToolBarGrip *result = 0 ;
  
  if ((argc < 1) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","FXToolBarGrip", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXToolBar * >(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 *","FXToolBarGrip", 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]);
  }
  {
    result = (FXToolBarGrip *)new_FXToolBarGrip(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (p, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 2512
def initialize(p, *args, &blk)
  argument_names = %w{target selector opts x y width height}
  default_params = { :target => nil, :selector => 0, :opts => TOOLBARGRIP_SINGLE, :x => 0, :y => 0, :width => 0, :height => 0 }
  params = {}
  params = args.pop if args.last.is_a? Hash
  args.each_with_index { |e, i| params[argument_names[i].intern] = e }
  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], &blk)
end

Also aliased as: old_initialize

Public Instance Methods

canFocus (*args)

Source

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

changeFocus (*args)

Source

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

clearShape (*args)

Source

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

contains (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disable (*args)

Source

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

doesSaveUnder (*args)

Source

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

doubleBar? ()

Source

# File rdoc-sources/FXToolBarGrip.rb, line 47
def doubleBar? ; end

Return true if this tool bar grip is displayed as a double bar (i.e. as opposed to a single bar).

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

enable (*args)

Source

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

getActiveColor (*args)

Source

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

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getHeightForWidth (*args)

Source

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

getWidthForHeight (*args)

Source

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

hide (*args)

Source

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

isComposite (*args)

Source

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

isDoubleBar (*args)

Source

SWIGINTERN VALUE
_wrap_FXToolBarGrip_isDoubleBar(int argc, VALUE *argv, VALUE self) {
  FXToolBarGrip *arg1 = (FXToolBarGrip *) 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_FXToolBarGrip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","isDoubleBar", 1, self )); 
  }
  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
  result = (FXbool)((FXToolBarGrip const *)arg1)->isDoubleBar();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

killFocus (*args)

Source

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

layout (*args)

Source

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

load (*args)

Source

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

lower (*args)

Source

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

move (*args)

Source

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

old_initialize (p, *args, &blk)

Alias for: new

onEnter (*args)

Source

SWIGINTERN VALUE
_wrap_FXToolBarGrip_onEnter(int argc, VALUE *argv, VALUE self) {
  FXToolBarGrip *arg1 = (FXToolBarGrip *) 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_FXToolBarGrip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","onEnter", 1, self )); 
  }
  arg1 = reinterpret_cast< FXToolBarGrip * >(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 *","onEnter", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onLeave (*args)

Source

SWIGINTERN VALUE
_wrap_FXToolBarGrip_onLeave(int argc, VALUE *argv, VALUE self) {
  FXToolBarGrip *arg1 = (FXToolBarGrip *) 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_FXToolBarGrip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","onLeave", 1, self )); 
  }
  arg1 = reinterpret_cast< FXToolBarGrip * >(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 *","onLeave", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  arg4 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onPaint (*args)

Source

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

raiseWindow (*args)

Source

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

recalc (*args)

Source

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

reparent (*args)

Source

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

resize (*args)

Source

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

save (*args)

Source

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

setActiveColor (*args)

Source

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

setBackColor (*args)

Source

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

setDefault (*args)

Source

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

setDoubleBar (*args)

Source

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

setFocus (*args)

Source

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

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXToolBarGrip_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_FXToolBarGrip, 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_FXToolBarGrip_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarGrip, 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_FXToolBarGrip_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarGrip, 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_FXToolBarGrip_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_FXToolBarGrip_show(int argc, VALUE *argv, VALUE self) {
  FXToolBarGrip *arg1 = (FXToolBarGrip *) 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_FXToolBarGrip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","show", 1, self )); 
  }
  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
  FXToolBarGrip_show(arg1);
  return Qnil;
fail:
  return Qnil;
}

tr (*args)

Source

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

class Fox::FXToolBarGrip

Toolbar Grip styles¶ ↑