class Fox::FXColorDialog

FXColorDialog is a standard dialog panel used to edit colors. Colors can be edited via RGB (Red, Green, Blue additive color model), via HSV (Hue, Saturation, Value color modal), via CMY (Cyan, Magenta, Yellow subtractive color model), or by name. Commonly used colors can be dragged into a number of small color wells to be used repeatedly; colors dropped into the small color wells are automatically saved into the registry for future use.

Events¶ ↑

The following messages are sent by FXColorDialog to its target:

SEL_CHANGED: sent continuously, while the color selector’s color is changing
SEL_COMMAND: sent when the new color is set

Message identifiers¶ ↑

ID_COLORSELECTOR: used internally to identify messages from the FXColorSelector

Attributes

opaqueOnly [W]

Only opaque colors allowed [Boolean]

rgba [RW]

The color {FXColor}

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXColorDialog(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXString *arg2 = 0 ;
  FXuint arg3 = (FXuint) 0 ;
  FXint arg4 = (FXint) 0 ;
  FXint arg5 = (FXint) 0 ;
  FXint arg6 = (FXint) 0 ;
  FXint arg7 = (FXint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  FXColorDialog *result = 0 ;
  
  if ((argc < 2) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXColorDialog", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  p2 = to_FXString(argv[1]); arg2 = &p2;
  if (argc > 2) {
    arg3 = NUM2UINT(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 (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXColorDialog *)new_FXColorDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (owner, title, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 447
def initialize(owner, title, *args, &blk)
  argument_names = %w{opts x y width height}
  default_params = { :opts => 0, :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(owner, title, 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_FXColorDialog_canFocus(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","canFocus", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  result = (bool)FXColorDialog_canFocus((FXColorDialog const *)arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

changeFocus (*args)

Source

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

clearShape (*args)

Source

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

close (*args)

Source

SWIGINTERN VALUE
_wrap_FXColorDialog_close(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXbool)FXColorDialog_close(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

contains (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disable (*args)

Source

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

doesSaveUnder (*args)

Source

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

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

enable (*args)

Source

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

execute (*args)

Source

SWIGINTERN VALUE
_wrap_FXColorDialog_execute(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  if (argc > 0) {
    arg2 = NUM2UINT(argv[0]);
  }
  result = (FXuint)FXColorDialog_execute(arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getHeightForWidth (*args)

Source

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

getRGBA (*args)

Source

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

getWidthForHeight (*args)

Source

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

hide (*args)

Source

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

isComposite (*args)

Source

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

isOpaqueOnly (*args)

Source

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

killFocus (*args)

Source

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

layout (*args)

Source

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

load (*args)

Source

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

lower (*args)

Source

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

maximize (*args)

Source

SWIGINTERN VALUE
_wrap_FXColorDialog_maximize(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","maximize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXbool)FXColorDialog_maximize(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

minimize (*args)

Source

SWIGINTERN VALUE
_wrap_FXColorDialog_minimize(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","minimize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXbool)FXColorDialog_minimize(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

move (*args)

Source

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

old_initialize (owner, title, *args, &blk)

Alias for: new

onChgColor (*args)

Source

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

onCmdColor (*args)

Source

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

opaqueOnly? ()

Source

# File rdoc-sources/FXColorDialog.rb, line 35
def opaqueOnly?() ; end

Return true if only opaque colors allowed

position (*args)

Source

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

raiseWindow (*args)

Source

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

recalc (*args)

Source

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

reparent (*args)

Source

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

resize (*args)

Source

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

restore (*args)

Source

SWIGINTERN VALUE
_wrap_FXColorDialog_restore(int argc, VALUE *argv, VALUE self) {
  FXColorDialog *arg1 = (FXColorDialog *) 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_FXColorDialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","restore", 1, self )); 
  }
  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXbool)FXColorDialog_restore(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

save (*args)

Source

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

setBackColor (*args)

Source

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

setDefault (*args)

Source

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

setFocus (*args)

Source

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

setOpaqueOnly (*args)

Source

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

setRGBA (*args)

Source

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

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXColorDialog_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_FXColorDialog, 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_FXColorDialog_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 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_FXColorDialog_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 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_FXColorDialog_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_FXColorDialog_show(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 == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FXColorDialog_show__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        return _wrap_FXColorDialog_show__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "show", 
    "    void show()\n"
    "    void show(FXuint placement)\n");
  
  return Qnil;
}

tr (*args)

Source

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