class Fox::FXWindow

Base class for all windows

Events¶ ↑

The following messages are sent by FXWindow to its target:

SEL_MAP: sent when the window is mapped to the screen; the message data is an FXEvent instance.
SEL_UNMAP: sent when the window is unmapped; the message data is an FXEvent instance.
SEL_CONFIGURE: sent when the window’s size changes; the message data is an FXEvent instance.
SEL_ENTER: sent when the mouse cursor enters this window
SEL_LEAVE: sent when the mouse cursor leaves this window
SEL_FOCUSIN: sent when this window gains the focus
SEL_FOCUSOUT: sent when this window loses the focus
SEL_UPDATE: sent when this window needs an update
SEL_UNGRABBED: sent when this window loses the mouse grab (or capture)

For each of the following keyboard-related events, the message data is an FXEvent instance:

SEL_KEYPRESS: sent when a key is pressed
SEL_KEYRELEASE: sent when a key is released

For each of the following mouse-related events, the message data is an FXEvent instance:

SEL_MOTION: sent when the mouse moves
SEL_LEFTBUTTONPRESS: sent when the left mouse button goes down
SEL_LEFTBUTTONRELEASE: sent when the left mouse button goes up
SEL_MIDDLEBUTTONPRESS: sent when the middle mouse button goes down
SEL_MIDDLEBUTTONRELEASE: sent when the middle mouse button goes up
SEL_RIGHTBUTTONPRESS: sent when the right mouse button goes down
SEL_RIGHTBUTTONRELEASE: sent when the right mouse button goes up
SEL_MOUSEWHEEL: sent when the mouse wheel is scrolled

For each of the following selection-related events, the message data is an FXEvent instance:

SEL_SELECTION_GAINED: sent when this window acquires the selection
SEL_SELECTION_LOST: sent when this window loses the selection
SEL_SELECTION_REQUEST: sent when this window’s selection is requested

For each of the following clipboard-related events, the message data is an FXEvent instance:

SEL_CLIPBOARD_GAINED: sent when this window acquires the clipboard
SEL_CLIPBOARD_LOST: sent when this window loses the clipboard
SEL_CLIPBOARD_REQUEST: sent when this window’s clipboard data is requested

For each of the following drag-and-drop events, the message data is an FXEvent instance:

SEL_BEGINDRAG: sent at the beginning of a drag operation
SEL_DRAGGED: sent while stuff is being dragged around
SEL_ENDDRAG: sent at the end of a drag operation
SEL_DND_ENTER: drag-and-drop enter
SEL_DND_LEAVE: drag-and-drop leave
SEL_DND_MOTION: drag-and-drop motion
SEL_DND_DROP: drag-and-drop motion
SEL_DND_REQUEST: drag-and-drop request

Layout hints for child widgets¶ ↑

LAYOUT_NORMAL: Default layout mode
LAYOUT_SIDE_TOP: Pack on top side (default)
LAYOUT_SIDE_BOTTOM: Pack on bottom side
LAYOUT_SIDE_LEFT: Pack on left side
LAYOUT_SIDE_RIGHT: Pack on right side
LAYOUT_FILL_COLUMN: Matrix column is stretchable
LAYOUT_FILL_ROW: Matrix row is stretchable
LAYOUT_LEFT: Stick on left (default)
LAYOUT_RIGHT: Stick on right
LAYOUT_CENTER_X: Center horizontally
LAYOUT_FIX_X: X fixed
LAYOUT_TOP: Stick on top (default)
LAYOUT_BOTTOM: Stick on bottom
LAYOUT_CENTER_Y: Center vertically
LAYOUT_FIX_Y: Y fixed
LAYOUT_FIX_WIDTH: Width fixed
LAYOUT_FIX_HEIGHT: Height fixed
LAYOUT_MIN_WIDTH: Minimum width is the default
LAYOUT_MIN_HEIGHT: Minimum height is the default
LAYOUT_FILL_X: Stretch or shrink horizontally
LAYOUT_FILL_Y: Stretch or shrink vertically
LAYOUT_FILL: Stretch or shrink in both directions
LAYOUT_EXPLICIT: Explicit placement
LAYOUT_DOCK_SAME: Dock on same galley, if it fits
LAYOUT_DOCK_NEXT: Dock on next galley

Frame border appearance styles (for subclasses)¶ ↑

FRAME_NONE: Default is no frame
FRAME_SUNKEN: Sunken border
FRAME_RAISED: Raised border
FRAME_THICK: Thick border
FRAME_GROOVE: A groove or etched-in border
FRAME_RIDGE: A ridge or embossed border
FRAME_LINE: Simple line border
FRAME_NORMAL: Regular raised/thick border

Packing style (for packers)¶ ↑

PACK_NORMAL: Default is each its own size
PACK_UNIFORM_HEIGHT: Uniform height
PACK_UNIFORM_WIDTH: Uniform width

Message IDs common to most windows¶ ↑

ID_NONE: x
ID_HIDE: x
ID_SHOW: x
ID_TOGGLESHOWN: x
ID_LOWER: x
ID_RAISE: x
ID_DELETE: x
ID_DISABLE: x
ID_ENABLE: x
ID_TOGGLEENABLED: x
ID_UNCHECK: x
ID_CHECK: x
ID_UNKNOWN: x
ID_UPDATE: x
ID_AUTOSCROLL: x
ID_HSCROLLED: x
ID_VSCROLLED: x
ID_SETVALUE: x
ID_SETINTVALUE: x
ID_SETREALVALUE: x
ID_SETSTRINGVALUE: x
ID_SETINTRANGE: x
ID_SETREALRANGE: x
ID_GETINTVALUE: x
ID_GETREALVALUE: x
ID_GETSTRINGVALUE: x
ID_GETINTRANGE: x
ID_GETREALRANGE: x
ID_QUERY_MENU: x
ID_HOTKEY: x
ID_ACCEL: x
ID_UNPOST: x
ID_POST: x
ID_MDI_TILEHORIZONTAL: x
ID_MDI_TILEVERTICAL: x
ID_MDI_CASCADE: x
ID_MDI_MAXIMIZE: x
ID_MDI_MINIMIZE: x
ID_MDI_RESTORE: x
ID_MDI_CLOSE: x
ID_MDI_WINDOW: x
ID_MDI_MENUWINDOW: x
ID_MDI_MENUMINIMIZE: x
ID_MDI_MENURESTORE: x
ID_MDI_MENUCLOSE: x
ID_MDI_NEXT: x
ID_MDI_PREV: x

Attributes

accelTable [RW]

The accelerator table for this window {FXAccelTable}

backColor [RW]

Window background color {FXColor}

defaultCursor [RW]

Default cursor for this window {FXCursor}

dragCursor [RW]

Drag cursor for this window {FXCursor}

first [R]

This window’s first child window, if any {FXWindow}

focus [R]

Currently focused child window, if any {FXWindow}

key [RW]

Window key [Integer]

last [R]

This window’s last child window, if any {FXWindow}

layoutHints [RW]

Layout hints for this window [Integer]

next [R]

Next (sibling) window, if any {FXWindow}

owner [R]

This window’s owner window {FXWindow}

parent [R]

This window’s parent window {FXWindow}

prev [R]

Previous (sibling) window, if any {FXWindow}

root [R]

Root window {FXWindow}

selector [RW]

Message identifier for this window [Integer]

shell [R]

The shell window for this window {FXWindow}

target [RW]

Message target object for this window {FXObject}

x [RW]

This window’s x-coordinate, in the parent’s coordinate system [Integer]

y [RW]

This window’s y-coordinate, in the parent’s coordinate system [Integer]

Public Class Methods

after? (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_afterq___(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::after", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::after", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)FXWindow::after((FXWindow const *)arg1,(FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

before? (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_beforeq___(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::before", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::before", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)FXWindow::before((FXWindow const *)arg1,(FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

colorType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_colorType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::colorType));
  return _val;
}

colorType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_colorType_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::colorType""' of type '""FXDragType""'");
    }
    FXWindow::colorType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

colorTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_colorTypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_colorTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

commonAncestor (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_commonAncestor(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXWindow *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXWindow::commonAncestor", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXWindow::commonAncestor", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (FXWindow *)FXWindow::commonAncestor(arg1,arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

deleteType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_deleteType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::deleteType));
  return _val;
}

deleteType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_deleteType_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::deleteType""' of type '""FXDragType""'");
    }
    FXWindow::deleteType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

deleteTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_deleteTypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_deleteTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

imageType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_imageType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::imageType));
  return _val;
}

new (*args)

Source

SWIGINTERN VALUE _wrap_new_FXWindow(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs;
  if (argc > 7) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if ((argc >= 1) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
      }
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
        }
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
            }
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
              }
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVisual, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FXWindow__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_new_FXWindow__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "FXWindow.new", 
    "    FXWindow.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
    "    FXWindow.new(FXApp *a, FXVisual *vis)\n"
    "    FXWindow.new(FXApp *a, FXWindow *own, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
  
  return Qnil;
}

new (p, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 223
def initialize(p, *args, &blk)
  if p.is_a? FXApp
    old_initialize(p, *args, &blk)
  else
    argument_names = %w{opts x y width height}
    default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
    params = {}
    params = args.pop if args.last.is_a? Hash
    args.each_with_index { |e, i| params[argument_names[i].intern] = e }
    params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
    params = default_params.merge(params)
    old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
  end
end

Also aliased as: old_initialize

octetType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_octetType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::octetType));
  return _val;
}

octetType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_octetType_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::octetType""' of type '""FXDragType""'");
    }
    FXWindow::octetType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

octetTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_octetTypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_octetTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

stringType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_stringType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::stringType));
  return _val;
}

textType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_textType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::textType));
  return _val;
}

textType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_textType_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::textType""' of type '""FXDragType""'");
    }
    FXWindow::textType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

textTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_textTypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_textTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

urilistType ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_urilistType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::urilistType));
  return _val;
}

urilistType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_urilistType_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::urilistType""' of type '""FXDragType""'");
    }
    FXWindow::urilistType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

urilistTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_urilistTypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_urilistTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

utf16Type ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf16Type_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::utf16Type));
  return _val;
}

utf16Type= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf16Type_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::utf16Type""' of type '""FXDragType""'");
    }
    FXWindow::utf16Type = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

utf16TypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf16TypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_utf16TypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

utf8Type ()

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf8Type_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::utf8Type));
  return _val;
}

utf8Type= (p1)

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf8Type_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::utf8Type""' of type '""FXDragType""'");
    }
    FXWindow::utf8Type = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

utf8TypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_utf8TypeName(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)FXWindow_utf8TypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

Public Instance Methods

acceptDrop (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_acceptDrop(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDragAction arg2 = (FXDragAction) DRAG_ACCEPT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","acceptDrop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragAction","acceptDrop", 2, argv[0] ));
    } 
    arg2 = static_cast< FXDragAction >(val2);
  }
  ((FXWindow const *)arg1)->acceptDrop(arg2);
  return Qnil;
fail:
  return Qnil;
}

acquireClipboard (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_acquireClipboard(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","acquireClipboard", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = argv[0];
  result = (bool)FXWindow_acquireClipboard(arg1,arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

acquireSelection (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_acquireSelection(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","acquireSelection", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = argv[0];
  result = (bool)FXWindow_acquireSelection(arg1,arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

active? ()

Source

# File rdoc-sources/FXWindow.rb, line 420
def active?() ; end

Return true if this window is active.

addHotKey (*args)

Source

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

after (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_after(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","after", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","after", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)FXWindow_after((FXWindow const *)arg1,(FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

after? (other)

Source

# File lib/fox16/core.rb, line 337
def after?(other)
  FXWindow.after?(other)
end

Return true if this window (self) comes after sibling window other,

before (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_before(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","before", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","before", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)FXWindow_before((FXWindow const *)arg1,(FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

before? (other)

Source

# File lib/fox16/core.rb, line 332
def before?(other)
  FXWindow.before?(other)
end

Return true if this window (self) comes before sibling window other.

beginDrag (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_beginDrag(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","beginDrag", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = argv[0];
  result = (bool)FXWindow_beginDrag(arg1,arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

canFocus (*args)

Source

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

canFocus? ()

Source

# File rdoc-sources/FXWindow.rb, line 423
def canFocus?() ; end

Return true if this window is a control capable of receiving the focus.

changeFocus (*args)

Source

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

childAtIndex (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_childAtIndex(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXWindow *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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","childAtIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = NUM2INT(argv[0]);
  {
    if (arg2 < 0 || arg2 >= arg1->numChildren()) {
      rb_raise(rb_eIndexError, "child window index out of bounds");
    }
  }
  result = (FXWindow *)((FXWindow const *)arg1)->childAtIndex(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

childOf? (window)

Source

# File rdoc-sources/FXWindow.rb, line 372
def childOf?(window) ; end

Return true if specified window is ancestor of this window.

children ()

Source

# File lib/fox16/core.rb, line 325
def children
  kids = []
  each_child { |kid| kids << kid }
  kids
end

Returns an array containing all child windows of this window

clearDragRectangle (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_clearDragRectangle(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","clearDragRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  ((FXWindow const *)arg1)->clearDragRectangle();
  return Qnil;
fail:
  return Qnil;
}

clearShape (*args)

Source

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

composeContext (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_composeContext(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXComposeContext *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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getComposeContext", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  result = (FXComposeContext *)((FXWindow const *)arg1)->getComposeContext();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXComposeContext, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

composite? ()

Source

# File rdoc-sources/FXWindow.rb, line 565
def composite?() ; end

Return true if this window is a composite.

contains (*args)

Source

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

contains? (parentX, parentY)

Source

# File rdoc-sources/FXWindow.rb, line 700
def contains?(parentX, parentY) ; end

Return true if this window logically contains the given point (parentX, parentY).

containsChild (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_containsChild(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","containsChild", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","containsChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)((FXWindow const *)arg1)->containsChild((FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

containsChild? (child)

Source

# File rdoc-sources/FXWindow.rb, line 377
def containsChild?(child) ; end

Return true if this window contains child in its subtree.

create (*args)

Source

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

createComposeContext (*args)

Source

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

cursorPosition ()

Source

# File rdoc-sources/FXWindow.rb, line 411
def cursorPosition() ; end

Return the cursor position and mouse button-state as a three-element array.

default? ()

Source

# File rdoc-sources/FXWindow.rb, line 448
def default?() ; end

Return true if this is the default window.

defaultHeight ()

Source

# File rdoc-sources/FXWindow.rb, line 329
def defaultHeight(); end

Return the default height of this window

defaultWidth ()

Source

# File rdoc-sources/FXWindow.rb, line 326
def defaultWidth(); end

Return the default width of this window

destroy (*args)

Source

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

destroyComposeContext (*args)

Source

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

detach (*args)

Source

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

didAccept (*args)

Source

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

disable (*args)

Source

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

doesSaveUnder (*args)

Source

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

doesSaveUnder? ()

Source

# File rdoc-sources/FXWindow.rb, line 713
def doesSaveUnder?() ; end

Return true if this window does save-unders.

dragging? ()

Source

# File rdoc-sources/FXWindow.rb, line 608
def dragging?() ; end

Return true if a drag operation has been initiated from this window

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

dropEnabled? ()

Source

# File rdoc-sources/FXWindow.rb, line 605
def dropEnabled?() ; end

Return true if this window is able to receive drops

dropFinished (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_dropFinished(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDragAction arg2 = (FXDragAction) DRAG_REJECT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","dropFinished", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragAction","dropFinished", 2, argv[0] ));
    } 
    arg2 = static_cast< FXDragAction >(val2);
  }
  ((FXWindow const *)arg1)->dropFinished(arg2);
  return Qnil;
fail:
  return Qnil;
}

dropTarget? ()

Source

# File rdoc-sources/FXWindow.rb, line 632
def dropTarget?() ; end

Return true if this window is the target of a drop

each_child () { |child| ... }

Source

# File lib/fox16/core.rb, line 301
def each_child # :yields: child
  child = self.first
  while child
    next_child = child.next
    yield child
    child = next_child
  end
end

Iterate over the child windows for this window. Note that this only reaches the direct child windows for this window and no deeper descendants. To traverse the entire widget tree, use each_child_recursive.

each_child_recursive () { |child| ... }

Source

# File lib/fox16/core.rb, line 314
def each_child_recursive # :yields: child
  each_child do |child|
    yield child
    child.each_child_recursive do |subchild|
      yield subchild
    end
  end
end

Traverse the widget tree starting from this window using depth-first traversal.

enable (*args)

Source

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

enabled ()

Alias for: enabled?

enabled? ()

Source

# File rdoc-sources/FXWindow.rb, line 417
def enabled?() ; end

Return true if this window is able to receive mouse and keyboard events.

Also aliased as: enabled

endDrag (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_endDrag(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  FXDragAction result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","endDrag", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","endDrag", 2, argv[0] ));
    } 
    arg2 = static_cast< bool >(val2);
  }
  result = (FXDragAction)(arg1)->endDrag(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

forceRefresh (*args)

Source

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

getAccelTable (*args)

Source

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

getBackColor (*args)

Source

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

getChildAt (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_getChildAt(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXWindow *result = 0 ;
  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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getChildAt", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (FXWindow *)((FXWindow const *)arg1)->getChildAt(arg2,arg3);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getCursorPosition (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_getCursorPosition(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getCursorPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  result = (VALUE)FXWindow_getCursorPosition((FXWindow const *)arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

getDNDData (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_getDNDData(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDNDOrigin arg2 ;
  FXDragType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  VALUE 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getDNDData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","getDNDData", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDNDOrigin >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","getDNDData", 3, argv[1] ));
  } 
  arg3 = static_cast< FXDragType >(val3);
  result = (VALUE)FXWindow_getDNDData((FXWindow const *)arg1,arg2,arg3);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

getDefaultCursor (*args)

Source

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

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getDragCursor (*args)

Source

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

getFirst (*args)

Source

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

getFocus (*args)

Source

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

getHeightForWidth (*args)

Source

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

getHelpTag (*args)

Source

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

getKey (*args)

Source

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

getLast (*args)

Source

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

getLayoutHints (*args)

Source

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

getNext (*args)

Source

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

getOwner (*args)

Source

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

getParent (*args)

Source

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

getPrev (*args)

Source

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

getRoot (*args)

Source

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

getSelector (*args)

Source

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

getShell (*args)

Source

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

getTarget (*args)

Source

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

getWidthForHeight (*args)

Source

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

getX (*args)

Source

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

getY (*args)

Source

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

grab (*args)

Source

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

grabKeyboard (*args)

Source

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

grabbed (*args)

Source

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

grabbed? ()

Source

# File rdoc-sources/FXWindow.rb, line 542
def grabbed?() ; end

Return true if the window has been grabbed

grabbedKeyboard (*args)

Source

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

grabbedKeyboard? ()

Source

# File rdoc-sources/FXWindow.rb, line 551
def grabbedKeyboard?() ; end

Return true if active grab is in effect

handleDrag (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_handleDrag(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXDragAction arg4 = (FXDragAction) DRAG_COPY ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","handleDrag", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    ecode4 = SWIG_AsVal_int(argv[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXDragAction","handleDrag", 4, argv[2] ));
    } 
    arg4 = static_cast< FXDragAction >(val4);
  }
  result = (bool)(arg1)->handleDrag(arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

hasClipboard (*args)

Source

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

hasClipboard? ()

Source

# File rdoc-sources/FXWindow.rb, line 585
def hasClipboard?() ; end

Return true if this window owns the clipboard

hasFocus (*args)

Source

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

hasFocus? ()

Source

# File rdoc-sources/FXWindow.rb, line 426
def hasFocus?() ; end

Return true if this window has the focus.

hasSelection (*args)

Source

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

hasSelection? ()

Source

# File rdoc-sources/FXWindow.rb, line 571
def hasSelection?() ; end

Return true if this window owns the primary selection

height ()

Source

# File rdoc-sources/FXWindow.rb, line 316
def height; end

Return the window height (in pixels).

height= (h)

Source

# File rdoc-sources/FXWindow.rb, line 323
def height=(h); end

Set the window height; and flag the widget as being in need of layout by its parent. This does not immediately update the server- side representation of the widget.

hide (*args)

Source

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

inFocusChain? (*args)

Source

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

indexOfChild (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_indexOfChild(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","indexOfChild", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","indexOfChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (FXint)((FXWindow const *)arg1)->indexOfChild((FXWindow const *)arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

initial? ()

Source

# File rdoc-sources/FXWindow.rb, line 454
def initial?() ; end

Return true if this is the initial default window.

inquireDNDAction (*args)

Source

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

inquireDNDTypes (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_inquireDNDTypes(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDNDOrigin arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","inquireDNDTypes", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","inquireDNDTypes", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDNDOrigin >(val2);
  result = (VALUE)FXWindow_inquireDNDTypes((FXWindow const *)arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

isActive (*args)

Source

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

isChildOf (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_isChildOf(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isChildOf", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","isChildOf", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)((FXWindow const *)arg1)->isChildOf((FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

isComposite (*args)

Source

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

isDefault (*args)

Source

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

isDragging (*args)

Source

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

isDropEnabled (*args)

Source

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

isDropTarget (*args)

Source

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

isEnabled (*args)

Source

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

isInitial (*args)

Source

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

isOwnerOf (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_isOwnerOf(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isOwnerOf", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","isOwnerOf", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)((FXWindow const *)arg1)->isOwnerOf((FXWindow const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

isShell (*args)

Source

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

killFocus (*args)

Source

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

layout (*args)

Source

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

linkAfter (other)

Source

# File lib/fox16/core.rb, line 347
def linkAfter(other)
  reparent(self.parent, other.next)
end

Relink this window after sibling window other, in the parent’s window list.

linkBefore (other)

Source

# File lib/fox16/core.rb, line 342
def linkBefore(other)
  reparent(self.parent, other)
end

Relink this window before sibling window other, in the parent’s window list.

load (*args)

Source

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

lower (*args)

Source

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

move (*args)

Source

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

numChildren (*args)

Source

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

Number of child windows for this window [Integer]

offeredDNDType (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_offeredDNDType(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDNDOrigin arg2 ;
  FXDragType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","offeredDNDType", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","offeredDNDType", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDNDOrigin >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","offeredDNDType", 3, argv[1] ));
  } 
  arg3 = static_cast< FXDragType >(val3);
  result = (bool)((FXWindow const *)arg1)->offeredDNDType(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

offeredDNDType? (origin, type)

Source

# File rdoc-sources/FXWindow.rb, line 682
def offeredDNDType?(origin, type) ; end

When being dragged over, return true if we are offered the given drag type. The origin is a constant indicating the origin of the data, one of FROM_SELECTION, FROM_CLIPBOARD or FROM_DRAGNDROP. The type is a previously registered drag type.

old_initialize (p, *args, &blk)

Alias for: new

onBeginDrag (*args)

Source

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

onClipboardGained (*args)

Source

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

onClipboardLost (*args)

Source

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

onClipboardRequest (*args)

Source

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

onCmdDelete (*args)

Source

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

onCmdDisable (*args)

Source

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

onCmdEnable (*args)

Source

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

onCmdHide (*args)

Source

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

onCmdLower (*args)

Source

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

onCmdRaise (*args)

Source

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

onCmdShow (*args)

Source

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

onCmdToggleEnabled (*args)

Source

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

onCmdToggleShown (*args)

Source

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

onCmdUpdate (*args)

Source

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

onConfigure (*args)

Source

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

onDNDDrop (*args)

Source

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

onDNDEnter (*args)

Source

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

onDNDLeave (*args)

Source

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

onDNDMotion (*args)

Source

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

onDNDRequest (*args)

Source

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

onDestroy (*args)

Source

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

onDragged (*args)

Source

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

onEndDrag (*args)

Source

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

onEnter (*args)

Source

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

onFocusIn (*args)

Source

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

onFocusOut (*args)

Source

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

onFocusSelf (*args)

Source

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

onKeyPress (*args)

Source

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

onKeyRelease (*args)

Source

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

onLeave (*args)

Source

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

onLeftBtnPress (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onLeftBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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_FXWindow_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onLeftBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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;
}

onMap (*args)

Source

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

onMiddleBtnPress (*args)

Source

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

onMiddleBtnRelease (*args)

Source

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

onMotion (*args)

Source

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

onMouseWheel (*args)

Source

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

onPaint (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_onPaint(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onPaint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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_FXWindow_onQueryHelp(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onQueryHelp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 = to_FXEvent(argv[2]);
  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_FXWindow_onQueryTip(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onQueryTip", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 = to_FXEvent(argv[2]);
  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onRightBtnPress (*args)

Source

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

onRightBtnRelease (*args)

Source

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

onSelectionGained (*args)

Source

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

onSelectionLost (*args)

Source

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

onSelectionRequest (*args)

Source

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

onUngrabbed (*args)

Source

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

onUnmap (*args)

Source

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

onUpdToggleEnabled (*args)

Source

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

onUpdToggleShown (*args)

Source

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

onUpdYes (*args)

Source

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

onUpdate (*args)

Source

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

position (*args)

Source

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

raiseWindow (*args)

Source

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

recalc (*args)

Source

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

releaseClipboard (*args)

Source

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

releaseSelection (*args)

Source

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

remHotKey (*args)

Source

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

removeChild (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_removeChild(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 *","removeChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (FXbool)FXWindow_removeChild(arg1,arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

repaint (*args)

Source

SWIGINTERN VALUE _wrap_FXWindow_repaint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FXWindow_repaint__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              return _wrap_FXWindow_repaint__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "FXWindow.repaint", 
    "    void FXWindow.repaint(FXint x, FXint y, FXint w, FXint h)\n"
    "    void FXWindow.repaint()\n");
  
  return Qnil;
}

reparent (*args)

Source

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

resize (*args)

Source

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

save (*args)

Source

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

scroll (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_scroll(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","scroll", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  ((FXWindow const *)arg1)->scroll(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}

setAccelTable (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setAccelTable(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXAccelTable *arg2 = (FXAccelTable *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setAccelTable", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXAccelTable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXAccelTable *","setAccelTable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXAccelTable * >(argp2);
  (arg1)->setAccelTable(arg2);
  return Qnil;
fail:
  return Qnil;
}

setBackColor (*args)

Source

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

setCursorPosition (*args)

Source

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

setDNDData (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setDNDData(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXDNDOrigin arg2 ;
  FXDragType arg3 ;
  VALUE arg4 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","setDNDData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","setDNDData", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDNDOrigin >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","setDNDData", 3, argv[1] ));
  } 
  arg3 = static_cast< FXDragType >(val3);
  arg4 = argv[2];
  FXWindow_setDNDData((FXWindow const *)arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}

setDefault (*args)

Source

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

setDefaultCursor (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setDefaultCursor(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXCursor *arg2 = (FXCursor *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setDefaultCursor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setDefaultCursor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXCursor * >(argp2);
  (arg1)->setDefaultCursor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setDragCursor (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setDragCursor(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXCursor *arg2 = (FXCursor *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setDragCursor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setDragCursor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXCursor * >(argp2);
  (arg1)->setDragCursor(arg2);
  return Qnil;
fail:
  return Qnil;
}

setDragRectangle (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setDragRectangle(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  bool arg6 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","setDragRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    ecode6 = SWIG_AsVal_bool(argv[4], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","setDragRectangle", 6, argv[4] ));
    } 
    arg6 = static_cast< bool >(val6);
  }
  ((FXWindow const *)arg1)->setDragRectangle(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}

setEnabled (x)

Source

# File lib/fox16/aliases.rb, line 5521
def setEnabled(x)
  x ? enable() : disable()
end

setFocus (*args)

Source

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

setHeight (*args)

Source

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

setHelpTag (*args)

Source

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

setInitial (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setInitial(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setInitial", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInitial", 2, argv[0] ));
    } 
    arg2 = static_cast< bool >(val2);
  }
  (arg1)->setInitial(arg2);
  return Qnil;
fail:
  return Qnil;
}

setKey (*args)

Source

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

setLayoutHints (*args)

Source

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

setSelector (*args)

Source

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

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXWindow_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_FXWindow, 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_FXWindow_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 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_FXWindow_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 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_FXWindow_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;
}

setShown (s)

Source

# File lib/fox16/aliases.rb, line 5552
def setShown(s)
  s ? show() : hide()
end

setTarget (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_setTarget(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXObject *arg2 = (FXObject *) 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 *","setTarget", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  (arg1)->setTarget(arg2);
  return Qnil;
fail:
  return Qnil;
}

setWidth (*args)

Source

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

setX (*args)

Source

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

setY (*args)

Source

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

shell? ()

Source

# File rdoc-sources/FXWindow.rb, line 367
def shell?() ; end

Return true if this window is a shell window.

show (*args)

Source

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

shown (*args)

Source

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

shown? ()

Source

# File rdoc-sources/FXWindow.rb, line 560
def shown?() ; end

Return true if this window is shown.

Also aliased as: visible?

tr (*args)

Source

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

translateCoordinatesFrom (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_translateCoordinatesFrom(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  VALUE 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","translateCoordinatesFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  result = (VALUE)FXWindow_translateCoordinatesFrom((FXWindow const *)arg1,(FXWindow const *)arg2,arg3,arg4);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

translateCoordinatesTo (*args)

Source

SWIGINTERN VALUE
_wrap_FXWindow_translateCoordinatesTo(int argc, VALUE *argv, VALUE self) {
  FXWindow *arg1 = (FXWindow *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  VALUE 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_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesTo", 1, self )); 
  }
  arg1 = reinterpret_cast< FXWindow * >(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 const *","translateCoordinatesTo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  result = (VALUE)FXWindow_translateCoordinatesTo((FXWindow const *)arg1,(FXWindow const *)arg2,arg3,arg4);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

underCursor (*args)

Source

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

underCursor? ()

Source

# File rdoc-sources/FXWindow.rb, line 568
def underCursor?() ; end

Return true if this window is under the cursor

ungrab (*args)

Source

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

ungrabKeyboard (*args)

Source

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

update (*args)

Source

SWIGINTERN VALUE _wrap_FXWindow_update(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FXWindow_update__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              return _wrap_FXWindow_update__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "FXWindow.update", 
    "    void FXWindow.update(FXint x, FXint y, FXint w, FXint h)\n"
    "    void FXWindow.update()\n");
  
  return Qnil;
}

visible= (vis)

Source

# File lib/fox16/core.rb, line 352
def visible=(vis)
  if vis
    show
  else
    hide
  end
end

Setting visible to true calls show, setting it to false calls hide.

visible? ()

Alias for: shown?

width ()

Source

# File rdoc-sources/FXWindow.rb, line 306
def width; end

Return the window width (in pixels).

width= (w)

Source

# File rdoc-sources/FXWindow.rb, line 313
def width=(w); end

Set the window width; and flag the widget as being in need of layout by its parent. This does not immediately update the server- side representation of the widget.