class Fox::FXHeader

Header control may be placed over a table or list to provide a resizable captions above a number of columns. Each caption comprises a label and an optional icon; in addition, an arrow may be shown to indicate whether the items in that column are sorted, and if so, whether they are sorted in increasing or decreasing order. Each caption can be interactively resized. During the resizing, if the HEADER_TRACKING was specified, the header control sends a SEL_CHANGED message to its target, with the message data set to the caption number being resized, of the type FXint. If the HEADER_TRACKING was not specified the SEL_CHANGED message is sent at the end of the resizing operation. Clicking on a caption causes a message of type SEL_COMMAND to be sent to the target, with the message data set to the caption number being clicked. A single click on a split causes a message of type SEL_CLICKED to be sent to the target; a typical response to this message would be to adjust the size of the split to fit the contents displayed underneath it. The contents may be scrolled by calling setPosition().

Events¶ ↑

The following messages are sent by FXHeader to its target:

SEL_CHANGED: sent continuously while a header item is being resized, if the HEADER_TRACKING option was specified, or at the end of the resize if HEADER_TRACKING was not specfied. The message data is an integer indicating the index of the item being resized.
SEL_COMMAND: sent when a header item is clicked; the message data is an integer indicating the index of the current item.
SEL_CLICKED: sent when a header item is clicked; the message data is an integer indicating the index of the current item.
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_REPLACED: sent when a header item is about to be replaced; the message data is an Integer indicating the index of the item to be replaced.
SEL_INSERTED: sent after a header item is inserted; the message data is an Integer indicating the index of the item that was inserted.
SEL_DELETED: sent when a header item is about to be removed; the message data is an Integer indicating the index of the item to be removed.

Header style options¶ ↑

HEADER_BUTTON: Button style can be clicked
HEADER_HORIZONTAL: Horizontal header control (default)
HEADER_VERTICAL: Vertical header control
HEADER_TRACKING: Tracks continuously while moving
HEADER_RESIZE: Allow resizing sections
HEADER_NORMAL: Normal options, same as HEADER_HORIZONTAL|FRAME_NORMAL

Message identifiers¶ ↑

ID_TIPTIMER: x

Attributes

font [RW]

Text font {FXFont}

headerStyle [RW]

Header style options [Integer]

helpText [RW]

Status line help text for this header

numItems [R]

Number of items [Integer]

position [RW]

Current position [Integer]

textColor [RW]

Text color {FXColor}

totalSize [R]

Total size of all items [Integer]

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXHeader(int argc, VALUE *argv, VALUE self) {
  FXComposite *arg1 = (FXComposite *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 = (FXSelector) 0 ;
  FXuint arg4 = (FXuint) HEADER_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 ;
  FXHeader *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 *","FXHeader", 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 *","FXHeader", 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 = (FXHeader *)new_FXHeader(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 1045
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 => HEADER_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

appendItem (*args)

Source

SWIGINTERN VALUE _wrap_FXHeader_appendItem(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXHeader_appendItem__SWIG_0(nargs, args, self);
        }
        {
          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
        }
        if (_v) {
          return _wrap_FXHeader_appendItem__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
        }
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
            }
            {
              _v = 1;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
              }
              {
                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
              }
              if (_v) {
                return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "appendItem", 
    "    FXint appendItem(FXHeaderItem *item, FXbool notify)\n"
    "    FXint appendItem(FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
  
  return Qnil;
}

arrowDown? (index)

Source

# File lib/fox16/core.rb, line 165
def arrowDown?(index)
  if index < 0 || index >= numItems
    raise IndexError, "header item index out of bounds"
  else
    getArrowDir(index) == Fox::FALSE
  end
end

Returns true if the specified header item’s arrow points down. Raises IndexError if index is out of bounds.

arrowMaybe? (index)

Source

# File lib/fox16/core.rb, line 177
def arrowMaybe?(index)
  if index < 0 || index >= numItems
    raise IndexError, "header item index out of bounds"
  else
    getArrowDir(index) == Fox::MAYBE
  end
end

Returns true if the specified header item does not display any arrow. Raises IndexError if index is out of bounds.

arrowUp? (index)

Source

# File lib/fox16/core.rb, line 153
def arrowUp?(index)
  if index < 0 || index >= numItems
    raise IndexError, "header item index out of bounds"
  else
    getArrowDir(index) == Fox::TRUE
  end
end

Returns true if the specified header item’s arrow points up. Raises IndexError if index is out of bounds.

canFocus (*args)

Source

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

changeFocus (*args)

Source

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

clearItems (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_clearItems(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXbool arg2 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","clearItems", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  FXHeader_clearItems(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

clearShape (*args)

Source

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

contains (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disable (*args)

Source

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

doesSaveUnder (*args)

Source

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

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

each () { |aHeaderItem| ... }

Source

# File lib/fox16/iterators.rb, line 79
def each # :yields: aHeaderItem
  0.upto(numItems - 1) do |i|
    yield getItem(i)
  end
  self
end

Calls block once for each item in the list, passing a reference to that item as a parameter.

enable (*args)

Source

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

extractItem (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_extractItem(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXHeaderItem *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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","extractItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXHeaderItem *)(arg1)->extractItem(arg2,arg3);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeaderItem, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

fillItems (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_fillItems(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXchar **arg2 = (FXchar **) 0 ;
  FXIcon *arg3 = (FXIcon *) 0 ;
  FXint arg4 = (FXint) 0 ;
  void *arg5 = (void *) 0 ;
  FXbool arg6 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","fillItems", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  {
    arg2 = NULL;
    if(!NIL_P(argv[0])){
      Check_Type(argv[0], T_ARRAY);
      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
          VALUE e = rb_ary_entry(argv[0], i);
          arg2[i] = (FXchar *) StringValuePtr(e);
        }
        arg2[RARRAY_LEN(argv[0])] = 0;
      }
    }
  }
  if (argc > 1) {
    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 3, argv[1] )); 
    }
    arg3 = reinterpret_cast< FXIcon * >(argp3);
  }
  if (argc > 2) {
    arg4 = NUM2INT(argv[2]);
  }
  if (argc > 3) {
    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
  }
  if (argc > 4) {
    arg6 = to_FXbool(argv[4]);
  }
  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_From_int(static_cast< int >(result));
  FXFREE(&arg2);
  return vresult;
fail:
  FXFREE(&arg2);
  return Qnil;
}

first ()

Source

# File lib/fox16/iterators.rb, line 71
def first
  getFirst
end

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

getArrowDir (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getArrowDir(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getArrowDir", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXuint)((FXHeader const *)arg1)->getArrowDir(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getFont (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getFont(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  result = (FXFont *)((FXHeader const *)arg1)->getFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getHeaderStyle (*args)

Source

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

getHeightForWidth (*args)

Source

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

getHelpText (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getHelpText(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  result = (FXString *) &((FXHeader const *)arg1)->getHelpText();
  vresult = to_ruby(result->text());
  return vresult;
fail:
  return Qnil;
}

getItem (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItem(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXHeaderItem *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXHeaderItem *)((FXHeader const *)arg1)->getItem(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeaderItem, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getItemAt (*args)

Source

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

getItemData (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemData(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (VALUE)FXHeader_getItemData((FXHeader const *)arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

getItemIcon (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemIcon(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXIcon *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXIcon *)((FXHeader const *)arg1)->getItemIcon(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getItemIconPosition (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemIconPosition(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXuint)((FXHeader const *)arg1)->getItemIconPosition(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getItemJustify (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemJustify(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXuint)((FXHeader const *)arg1)->getItemJustify(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getItemOffset (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemOffset(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXint)((FXHeader const *)arg1)->getItemOffset(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getItemSize (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemSize(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXint)((FXHeader const *)arg1)->getItemSize(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

getItemText (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_getItemText(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = ((FXHeader const *)arg1)->getItemText(arg2);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}

getNumItems (*args)

Source

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

getPosition (*args)

Source

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

getTextColor (*args)

Source

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

getTotalSize (*args)

Source

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

getWidthForHeight (*args)

Source

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

hide (*args)

Source

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

insertItem (*args)

Source

SWIGINTERN VALUE _wrap_FXHeader_insertItem(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_insertItem__SWIG_0(nargs, args, self);
          }
          {
            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
          }
          if (_v) {
            return _wrap_FXHeader_insertItem__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 7)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
            }
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
              }
              {
                _v = 1;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
                }
                {
                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "insertItem", 
    "    FXint insertItem(FXint index, FXHeaderItem *item, FXbool notify)\n"
    "    FXint insertItem(FXint index, FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
  
  return Qnil;
}

isComposite (*args)

Source

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

isItemPressed (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_isItemPressed(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","isItemPressed", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  result = (FXbool)((FXHeader const *)arg1)->isItemPressed(arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

killFocus (*args)

Source

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

layout (*args)

Source

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

load (*args)

Source

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

lower (*args)

Source

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

makeItemVisible (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_makeItemVisible(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","makeItemVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->makeItemVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}

move (*args)

Source

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

old_initialize (p, *args, &blk)

Alias for: new

onLeftBtnPress (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onLeftBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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_FXHeader_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onLeftBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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_FXHeader_onMotion(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onMotion", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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_FXHeader_onPaint(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onPaint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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_FXHeader_onQueryHelp(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onQueryHelp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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_FXHeader_onQueryTip(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onQueryTip", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(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;
}

onTipTimer (*args)

Source

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

onUngrabbed (*args)

Source

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

position (*args)

Source

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

Current position [Integer]

prependItem (*args)

Source

SWIGINTERN VALUE _wrap_FXHeader_prependItem(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXHeader_prependItem__SWIG_0(nargs, args, self);
        }
        {
          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
        }
        if (_v) {
          return _wrap_FXHeader_prependItem__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
        }
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
            }
            {
              _v = 1;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
              }
              {
                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
              }
              if (_v) {
                return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "prependItem", 
    "    FXint prependItem(FXHeaderItem *item, FXbool notify)\n"
    "    FXint prependItem(FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
  
  return Qnil;
}

raiseWindow (*args)

Source

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

recalc (*args)

Source

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

removeItem (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_removeItem(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","removeItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  FXHeader_removeItem(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

reparent (*args)

Source

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

resize (*args)

Source

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

save (*args)

Source

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

setArrowDir (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setArrowDir(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 2 ;
  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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setArrowDir", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setArrowDir(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setBackColor (*args)

Source

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

setDefault (*args)

Source

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

setFocus (*args)

Source

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

setFont (*args)

Source

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

setHeaderStyle (*args)

Source

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

setHelpText (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setHelpText(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setHelpText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  (arg1)->setHelpText((FXString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

setItem (*args)

Source

SWIGINTERN VALUE _wrap_FXHeader_setItem(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_setItem__SWIG_0(nargs, args, self);
          }
          {
            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
          }
          if (_v) {
            return _wrap_FXHeader_setItem__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 7)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
            }
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
              }
              {
                _v = 1;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
                }
                {
                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "setItem", 
    "    FXint setItem(FXint index, FXHeaderItem *item, FXbool notify)\n"
    "    FXint setItem(FXint index, FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
  
  return Qnil;
}

setItemData (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemData(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  VALUE arg3 = (VALUE) 0 ;
  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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = argv[1];
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  FXHeader_setItemData(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemIcon (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemIcon(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXIcon *arg3 = (FXIcon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXIcon * >(argp3);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemIcon(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemIconPosition (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemIconPosition(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemIconPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemIconPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemJustify (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemJustify(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemJustify", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2UINT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemJustify(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemPressed (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemPressed(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXbool arg3 = (FXbool) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemPressed", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemPressed(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemSize (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemSize(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemSize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemSize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setItemText (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_setItemText(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 0 ;
  FXint arg2 ;
  FXString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p3 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  p3 = to_FXString(argv[1]); arg3 = &p3;
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  (arg1)->setItemText(arg2,(FXString const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}

setPosition (*args)

Source

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

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXHeader_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_FXHeader, 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_FXHeader_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 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_FXHeader_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 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_FXHeader_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_FXHeader_setTextColor(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = to_FXColor(argv[0]);
  (arg1)->setTextColor(arg2);
  return Qnil;
fail:
  return Qnil;
}

show (*args)

Source

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

tr (*args)

Source

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

updateItem (*args)

Source

SWIGINTERN VALUE
_wrap_FXHeader_updateItem(int argc, VALUE *argv, VALUE self) {
  FXHeader *arg1 = (FXHeader *) 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_FXHeader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","updateItem", 1, self )); 
  }
  arg1 = reinterpret_cast< FXHeader * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
      rb_raise(rb_eIndexError, "header item index out of bounds");
    }
  }
  ((FXHeader const *)arg1)->updateItem(arg2);
  return Qnil;
fail:
  return Qnil;
}