class Fox::FXRuler

The ruler widget is placed alongside a document to measure position and size of entities within the document, such as margins, paragraph indents, and tickmarks. The ruler widget sends a SEL_CHANGED message when the indentation or margins are interactively changed by the user. If the document size exceeds the available space, it is possible to scroll the document using setPosition(). When the document size is less than the available space, the alignment options can be used to center, left-adjust, or right-adjust the document. Finally, a special option exists to stretch the document to the available space, that is to say, the document will always be fitten with given left and right edges substracted from the available space.

Events¶ ↑

The following messages are sent by FXRuler to its target:

SEL_LEFTBUTTONPRESS: sent when the left mouse button goes down; the message data is an FXEvent instance.
SEL_LEFTBUTTONRELEASE: sent when the left mouse button goes up; the message data is an FXEvent instance.
SEL_CHANGED: sent whenever something about the ruler changes

Ruler options¶ ↑

RULER_NORMAL: Default appearance (default)
RULER_HORIZONTAL: Ruler is horizontal (default)
RULER_VERTICAL: Ruler is vertical
RULER_TICKS_OFF: Tick marks off (default)
RULER_TICKS_TOP: Ticks on the top (if horizontal)
RULER_TICKS_BOTTOM: Ticks on the bottom (if horizontal)
RULER_TICKS_LEFT: Ticks on the left (if vertical)
RULER_TICKS_RIGHT: Ticks on the right (if vertical)
RULER_TICKS_CENTER: Tickmarks centered
RULER_NUMBERS: Show numbers
RULER_ARROW: Draw small arrow for cursor position
RULER_MARKERS: Draw markers for indentation settings
RULER_METRIC: Metric subdivision (default)
RULER_ENGLISH: English subdivision
RULER_MARGIN_ADJUST: Allow margin adjustment
RULER_ALIGN_CENTER: Center document horizontally
RULER_ALIGN_LEFT: Align document to the left
RULER_ALIGN_RIGHT: Align document to the right
RULER_ALIGN_TOP: Align document to the top
RULER_ALIGN_BOTTOM: Align document to the bottom
RULER_ALIGN_STRETCH: Stretch document to fit horizontally
RULER_ALIGN_NORMAL: Normally, document is centered both ways

Message identifiers:¶ ↑

ID_ARROW: write me

Attributes

contentSize [RW]

Content size [Integer]

documentSize [RW]

Document size [Integer]

edgeSpacing [RW]

Document size [Integer]

font [RW]

The text font {FXFont}

helpText [RW]

The status line help text for this ruler [String]

indentFirst [RW]

First line indent [Integer]

indentLower [RW]

Lower indent [Integer]

indentUpper [RW]

Upper indent [Integer]

majorTicks [RW]

Document major ticks [Integer]

marginLower [RW]

Lower document margin [Integer]

marginUpper [RW]

Upper document margin [Integer]

minorTicks [RW]

Document minor ticks [Integer]

numberTicks [RW]

Document number placement [Integer]

pixelsPerTick [RW]

Pixels per tick spacing [Float]

position [RW]

Current position [Integer]

rulerAlignment [RW]

Ruler alignment [Integer]

rulerStyle [RW]

The ruler style [Integer]

textColor [RW]

The current text color {FXColor}

tinyTicks [RW]

Document tiny ticks [Integer]

tipText [RW]

The tool tip message for this ruler [String]

value [RW]

The slider value [Integer]

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXRuler(int argc, VALUE *argv, VALUE self) {
  FXComposite *arg1 = (FXComposite *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 = (FXSelector) 0 ;
  FXuint arg4 = (FXuint) RULER_NORMAL ;
  FXint arg5 = (FXint) 0 ;
  FXint arg6 = (FXint) 0 ;
  FXint arg7 = (FXint) 0 ;
  FXint arg8 = (FXint) 0 ;
  FXint arg9 = (FXint) DEFAULT_PAD ;
  FXint arg10 = (FXint) DEFAULT_PAD ;
  FXint arg11 = (FXint) DEFAULT_PAD ;
  FXint arg12 = (FXint) DEFAULT_PAD ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXRuler *result = 0 ;
  
  if ((argc < 1) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRuler", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXComposite * >(argp1);
  if (argc > 1) {
    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXRuler", 2, argv[1] )); 
    }
    arg2 = reinterpret_cast< FXObject * >(argp2);
  }
  if (argc > 2) {
    arg3 = NUM2UINT(argv[2]);
  }
  if (argc > 3) {
    arg4 = NUM2UINT(argv[3]);
  }
  if (argc > 4) {
    arg5 = NUM2INT(argv[4]);
  }
  if (argc > 5) {
    arg6 = NUM2INT(argv[5]);
  }
  if (argc > 6) {
    arg7 = NUM2INT(argv[6]);
  }
  if (argc > 7) {
    arg8 = NUM2INT(argv[7]);
  }
  if (argc > 8) {
    arg9 = NUM2INT(argv[8]);
  }
  if (argc > 9) {
    arg10 = NUM2INT(argv[9]);
  }
  if (argc > 10) {
    arg11 = NUM2INT(argv[10]);
  }
  if (argc > 11) {
    arg12 = NUM2INT(argv[11]);
  }
  {
    if (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXRuler *)new_FXRuler(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (p, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 1967
def initialize(p, *args, &blk)
  argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
  default_params = { :target => nil, :selector => 0, :opts => RULER_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(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
end

Also aliased as: old_initialize

Public Instance Methods

canFocus (*args)

Source

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

changeFocus (*args)

Source

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

clearShape (*args)

Source

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

contains (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disable (*args)

Source

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

documentLower (*args)

Source

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

documentUpper (*args)

Source

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

doesSaveUnder (*args)

Source

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

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

enable (*args)

Source

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

getContentSize (*args)

Source

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

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getDocumentSize (*args)

Source

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

getEdgeSpacing (*args)

Source

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

getFont (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_getFont(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFont *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  result = (FXFont *)((FXRuler const *)arg1)->getFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getHeightForWidth (*args)

Source

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

getHelpText (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_getHelpText(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  result = (FXString *) &((FXRuler const *)arg1)->getHelpText();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}

getIndentFirst (*args)

Source

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

getIndentLower (*args)

Source

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

getIndentUpper (*args)

Source

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

getMajorTicks (*args)

Source

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

getMarginLower (*args)

Source

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

getMarginUpper (*args)

Source

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

getMediumTicks (*args)

Source

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

getNumberTicks (*args)

Source

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

getPixelPerTick (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_getPixelPerTick(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble 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_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getPixelPerTick", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  result = (FXdouble)((FXRuler const *)arg1)->getPixelPerTick();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

getPosition (*args)

Source

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

getRulerAlignment (*args)

Source

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

getRulerStyle (*args)

Source

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

getTextColor (*args)

Source

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

getTinyTicks (*args)

Source

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

getTipText (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_getTipText(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getTipText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  result = (FXString *) &((FXRuler const *)arg1)->getTipText();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}

getValue (*args)

Source

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

getWidthForHeight (*args)

Source

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

hide (*args)

Source

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

isComposite (*args)

Source

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

killFocus (*args)

Source

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

layout (*args)

Source

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

load (*args)

Source

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

lower (*args)

Source

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

move (*args)

Source

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

old_initialize (p, *args, &blk)

Alias for: new

onCmdGetHelp (*args)

Source

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

onCmdGetIntValue (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res4 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdGetIntValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(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 *","onCmdGetIntValue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntValue", 4, argv[2] )); 
  }
  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onCmdGetTip (*args)

Source

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

onCmdSetHelp (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXString value4 ;
  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_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetHelp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(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 *","onCmdSetHelp", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  {
    value4 = FXString(StringValuePtr(argv[2]));
    arg4 = (void *) &value4;
  }
  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onCmdSetIntValue (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res4 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetIntValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(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 *","onCmdSetIntValue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetIntValue", 4, argv[2] )); 
  }
  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onCmdSetTip (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXString value4 ;
  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_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetTip", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(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 *","onCmdSetTip", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  {
    value4 = FXString(StringValuePtr(argv[2]));
    arg4 = (void *) &value4;
  }
  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onCmdSetValue (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res4 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetValue", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(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 *","onCmdSetValue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetValue", 4, argv[2] )); 
  }
  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onLeftBtnPress (*args)

Source

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

onLeftBtnRelease (*args)

Source

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

onMotion (*args)

Source

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

onPaint (*args)

Source

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

onQueryHelp (*args)

Source

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

onQueryTip (*args)

Source

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

position (*args)

Source

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

Current position [Integer]

raiseWindow (*args)

Source

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

recalc (*args)

Source

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

reparent (*args)

Source

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

resize (*args)

Source

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

save (*args)

Source

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

setBackColor (*args)

Source

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

setContentSize (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setContentSize(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setContentSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setContentSize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setDefault (*args)

Source

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

setDocumentSize (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setDocumentSize(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setDocumentSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setDocumentSize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setEdgeSpacing (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setEdgeSpacing(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setEdgeSpacing", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setEdgeSpacing(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setFocus (*args)

Source

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

setFont (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setFont(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXFont *arg2 = (FXFont *) 0 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXFont * >(argp2);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setFont(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setHelpText (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setHelpText(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  (arg1)->setHelpText((FXString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

setIndentFirst (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setIndentFirst(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setIndentFirst(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setIndentLower (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setIndentLower(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentLower", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setIndentLower(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setIndentUpper (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setIndentUpper(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentUpper", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setIndentUpper(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setMajorTicks (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setMajorTicks(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMajorTicks", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setMajorTicks(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setMarginLower (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setMarginLower(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMarginLower", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setMarginLower(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setMarginUpper (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setMarginUpper(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMarginUpper", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setMarginUpper(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setMediumTicks (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setMediumTicks(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMediumTicks", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setMediumTicks(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setNumberTicks (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setNumberTicks(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setNumberTicks", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setNumberTicks(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setPixelPerTick (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setPixelPerTick(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXdouble arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setPixelPerTick", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setPixelPerTick", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setPixelPerTick(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setPosition (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setPosition(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setRulerAlignment (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setRulerAlignment(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXuint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setRulerAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setRulerAlignment(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setRulerStyle (*args)

Source

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

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXRuler_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_FXRuler, 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_FXRuler_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRuler, 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_FXRuler_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRuler, 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_FXRuler_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;
}

setTextColor (*args)

Source

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

setTinyTicks (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setTinyTicks(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setTinyTicks", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setTinyTicks(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setTipText (*args)

Source

SWIGINTERN VALUE
_wrap_FXRuler_setTipText(int argc, VALUE *argv, VALUE self) {
  FXRuler *arg1 = (FXRuler *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setTipText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXRuler * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  (arg1)->setTipText((FXString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

setValue (*args)

Source

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

show (*args)

Source

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

tr (*args)

Source

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