class Fox::FXGLViewer

Canvas, an area drawn by another object

Events¶ ↑

The following messages are sent by FXGLViewer to its message target:

SEL_KEYPRESS: sent when a key goes down; the message data is an FXEvent instance.
SEL_KEYRELEASE: sent when a key goes up; the message data is an FXEvent instance.
SEL_LEFTBUTTONPRESS: sent when the left mouse button goes down; the message data is an FXEvent instance.
SEL_LEFTBUTTONRELEASE: sent when the left mouse button goes up; the message data is an FXEvent instance.
SEL_MIDDLEBUTTONPRESS: sent when the middle mouse button goes down; the message data is an FXEvent instance.
SEL_MIDDLEBUTTONRELEASE: sent when the middle mouse button goes up; the message data is an FXEvent instance.
SEL_RIGHTBUTTONPRESS: sent when the right mouse button goes down; the message data is an FXEvent instance.
SEL_RIGHTBUTTONRELEASE: sent when the right mouse button goes up; the message data is an FXEvent instance.
SEL_MOTION: sent when the mouse pointer is moved; the message data is an FXEvent instance.
SEL_MOUSEWHEEL: sent when the mouse wheel is spun; the message data is an FXEvent instance.
SEL_CLICKED: sent when the mouse is single-clicked somewhere in the widget; the message data is a reference to the clicked object (possibly nil)
SEL_DOUBLECLICKED: sent when the mouse is double-clicked somewhere in the widget; the message data is a reference to the clicked object (possibly nil)
SEL_TRIPLECLICKED: sent when the mouse is triple-clicked somewhere in the widget; the message data is a reference to the clicked object (possibly nil)
SEL_PICKED: sent when an object is picked; the message data is an FXEvent instance.
SEL_SELECTED: sent when object(s) are selected in the viewer; the message data is an array of references to the selected objects.
SEL_DESELECTED: sent when object(s) are deselected in the viewer; the message data is an array of references to the deselected objects.
SEL_LASSOED: sent when a lasso-selection has been completed; the message data is an FXEvent instance.
SEL_INSERTED: sent when the viewer receives a SEL_INSERTED message.
SEL_DELETED: sent when the viewer receives a SEL_COMMAND message with the ID_DELETE_SEL identifier; the message data is an array of references to the selected object(s).
SEL_DRAGGED: sent when the selected object is dragged around in the viewer; the message data is a reference to the selected object.
SEL_COMMAND: sent when the mouse is clicked somewhere in the widget; the message data is a reference to the clicked object (possibly nil)
SEL_CHANGED: sent when the selection changes; the message data is a reference to the newly selected object (or nil).

`FXGLViewer` options¶ ↑

VIEWER_LIGHTING: Lighting is on
VIEWER_FOG: Fog mode on
VIEWER_DITHER: Dithering

Projection modes (class constants)¶ ↑

PARALLEL: Parallel projection
PERSPECTIVE: Perspective projection

Message identifiers¶ ↑

ID_PERSPECTIVE: x
ID_PARALLEL: x
ID_FRONT: x
ID_BACK: x
ID_LEFT: x
ID_RIGHT: x
ID_TOP: x
ID_BOTTOM: x
ID_RESETVIEW: x
ID_FITVIEW: x
ID_TIPTIMER: x
ID_TOP_COLOR: x
ID_BOTTOM_COLOR: x
ID_BACK_COLOR: x
ID_AMBIENT_COLOR: x
ID_LIGHT_AMBIENT: x
ID_LIGHT_DIFFUSE: x
ID_LIGHT_SPECULAR: x
ID_LIGHTING: x
ID_TURBO: x
ID_FOG: x
ID_DITHER: x
ID_SCALE_X: x
ID_SCALE_Y: x
ID_SCALE_Z: x
ID_DIAL_X: x
ID_DIAL_Y: x
ID_DIAL_Z: x
ID_ROLL: x
ID_PITCH: x
ID_YAW: x
ID_FOV: x
ID_ZOOM: x
ID_CUT_SEL: x
ID_COPY_SEL: x
ID_PASTE_SEL: x
ID_DELETE_SEL: x
ID_PRINT_IMAGE: x
ID_PRINT_VECTOR: x
ID_LASSO_ZOOM: x
ID_LASSO_SELECT: x

Attributes

ambientColor [RW]

Global ambient light color {FXMat4f}

center [RW]

Object center {FXVec3f}

distance [RW]

Target point distance [Float]

eyePosition [R]

Eye position {FXVec3f}

eyeVector [R]

Eyesight vector {FXVec3f}

fieldOfView [RW]

Camera field of view angle (in degrees) [Float]

helpText [RW]

Status line help text [String]

invTransform [R]

The inverse of the current transformation matrix {FXMat4f}

light [RW]

Light source settings {FXLight}

material [RW]

Default object material setting {FXMaterial}

maxHits [RW]

The maximum hits, i.e. the maximum size of the pick buffer [Integer]. When less than or equal to zero, picking is essentially turned off.

orientation [RW]

Camera orientation {FXQuatf}

projection [RW]

The projection mode (either FXGLViewer::PERSPECTIVE or FXGLViewer::PARALLEL)

scale [RW]

Current scaling factors {FXVec3f}

scene [RW]

The current scene object {FXGLObject}

selection [RW]

The selection {FXGLObject}

tipText [RW]

Tool tip text [String]

transform [R]

The current transformation matrix {FXMat4f}

turboMode [W]

Set turbo mode [Boolean]

viewport [R]

The viewport for this viewer {FXViewport}

zoom [RW]

Camera zoom factor [Float]

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE _wrap_new_FXGLViewer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs;
  if (argc > 10) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if ((argc >= 2) && (argc <= 9)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
        }
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_FXGLViewer__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_FXGLViewer__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_FXGLViewer__SWIG_0(nargs, args, self);
              }
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
                }
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  if (argc <= 7) {
                    return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
                  }
                  {
                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
                  }
                  if (_v) {
                    if (argc <= 8) {
                      return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
                    }
                    {
                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 10)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXGLViewer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXObject, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
            }
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
              }
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
                }
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  if (argc <= 7) {
                    return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
                  }
                  {
                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
                  }
                  if (_v) {
                    if (argc <= 8) {
                      return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
                    }
                    {
                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
                    }
                    if (_v) {
                      if (argc <= 9) {
                        return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
                      }
                      {
                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "FXGLViewer.new", 
    "    FXGLViewer.new(FXComposite *p, FXGLVisual *vis, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
    "    FXGLViewer.new(FXComposite *p, FXGLVisual *vis, FXGLViewer *sharegroup, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
  
  return Qnil;
}

new (parent, vis, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 119
def initialize(parent, vis, *args, &blk)
  argument_names = %w{target selector opts x y width height}
  default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
  params = {}
  params = args.pop if args.last.is_a? Hash
  if args.length > 0 && (args[0].is_a?(FXGLViewer))
    sharegroup = args[0]
    args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
    params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
    params = default_params.merge(params)
    old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
  else
    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(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
  end
end

Also aliased as: old_initialize

objectType ()

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_objectType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXGLViewer::objectType));
  return _val;
}

objectType= (p1)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_objectType_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 '""FXGLViewer::objectType""' of type '""FXDragType""'");
    }
    FXGLViewer::objectType = static_cast< FXDragType >(val);
  }
  return _val;
fail:
  return Qnil;
}

objectTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_objectTypeName(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)FXGLViewer_objectTypeName();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

Public Instance Methods

canFocus (*args)

Source

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

changeFocus (*args)

Source

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

clearShape (*args)

Source

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

contains (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disable (*args)

Source

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

doesSaveUnder (*args)

Source

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

doesTurbo (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_doesTurbo(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","doesTurbo", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXbool)((FXGLViewer const *)arg1)->doesTurbo();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

doesTurbo? ()

Source

# File rdoc-sources/FXGLViewer.rb, line 318
def doesTurbo?; end

When drawing a GL object, if doesTurbo? returns true, the object may choose to perform a reduced complexity drawing as the user is interactively manipulating; another update will be done later when the full complexity drawing can be performed again.

dropDisable (*args)

Source

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

dropEnable (*args)

Source

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

enable (*args)

Source

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

eyeToScreen (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_eyeToScreen(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","eyeToScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","eyeToScreen", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","eyeToScreen", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  result = (VALUE)FXGLViewer_eyeToScreen(arg1,SWIG_STD_MOVE(arg2));
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

eyeToWorld (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_eyeToWorld(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","eyeToWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","eyeToWorld", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","eyeToWorld", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  result = (arg1)->eyeToWorld(arg2);
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

fitToBounds (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_fitToBounds(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXRangef *arg2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","fitToBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","fitToBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","fitToBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXRangef * >(argp2);
  result = (FXbool)(arg1)->fitToBounds((FXRangef const &)*arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

getAmbientColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getAmbientColor(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec4f *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getAmbientColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXVec4f *) &((FXGLViewer const *)arg1)->getAmbientColor();
  {
    FXVec4f* resultptr = new FXVec4f(*result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
  }
  return vresult;
fail:
  return Qnil;
}

getBackgroundColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getBackgroundColor(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXbool arg2 = (FXbool) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec4f *result = 0 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getBackgroundColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  if (argc > 0) {
    arg2 = to_FXbool(argv[0]);
  }
  result = (FXVec4f *) &((FXGLViewer const *)arg1)->getBackgroundColor(arg2);
  {
    FXVec4f* resultptr = new FXVec4f(*result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
  }
  return vresult;
fail:
  return Qnil;
}

getBoreVector (*args)

Source

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

getCenter (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getCenter(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec3f *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getCenter", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXVec3f *) &((FXGLViewer const *)arg1)->getCenter();
  {
    FXVec3f* resultptr = new FXVec3f(*result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

getDefaultHeight (*args)

Source

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

getDefaultWidth (*args)

Source

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

getDistance (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getDistance(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXdouble)((FXGLViewer const *)arg1)->getDistance();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

getEyePosition (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getEyePosition(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getEyePosition", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = ((FXGLViewer const *)arg1)->getEyePosition();
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

getEyeVector (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getEyeVector(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getEyeVector", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = ((FXGLViewer const *)arg1)->getEyeVector();
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

getFieldOfView (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getFieldOfView(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getFieldOfView", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXdouble)((FXGLViewer const *)arg1)->getFieldOfView();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

getHeightForWidth (*args)

Source

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

getHelpText (*args)

Source

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

getInvTransform (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getInvTransform(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getInvTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXMat4f *) &((FXGLViewer const *)arg1)->getInvTransform();
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

getLight (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getLight(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXLight 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getLight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = FXGLViewer_getLight((FXGLViewer const *)arg1);
  {
    FXLight *resultptr = new FXLight(result);
    vresult = FXRbGetRubyObj(resultptr, "FXLight *");
  }
  return vresult;
fail:
  return Qnil;
}

getMaterial (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getMaterial(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMaterial 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = FXGLViewer_getMaterial((FXGLViewer const *)arg1);
  {
    FXMaterial *resultptr = new FXMaterial(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMaterial *");
  }
  return vresult;
fail:
  return Qnil;
}

getMaxHits (*args)

Source

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

getOrientation (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getOrientation(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXQuatf *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXQuatf *) &((FXGLViewer const *)arg1)->getOrientation();
  vresult = FXRbGetRubyObj(result, "FXQuatf *");
  return vresult;
fail:
  return Qnil;
}

getProjection (*args)

Source

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

getScale (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getScale(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec3f *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getScale", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXVec3f *) &((FXGLViewer const *)arg1)->getScale();
  {
    FXVec3f* resultptr = new FXVec3f(*result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

getScene (*args)

Source

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

getSelection (*args)

Source

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

getTipText (*args)

Source

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

getTransform (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getTransform(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXMat4f *) &((FXGLViewer const *)arg1)->getTransform();
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

getTurboMode (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getTurboMode(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getTurboMode", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXbool)((FXGLViewer const *)arg1)->getTurboMode();
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

getViewport (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getViewport(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXViewport 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = FXGLViewer_getViewport((FXGLViewer const *)arg1);
  {
    FXViewport* resultptr = new FXViewport(result);
    vresult = FXRbGetRubyObj(resultptr, "FXViewport *");
  }
  return vresult;
fail:
  return Qnil;
}

getWidthForHeight (*args)

Source

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

getZSortFunc (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getZSortFunc(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getZSortFunc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (VALUE)FXGLViewer_getZSortFunc((FXGLViewer const *)arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

getZoom (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_getZoom(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getZoom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXdouble)((FXGLViewer const *)arg1)->getZoom();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

hide (*args)

Source

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

isComposite (*args)

Source

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

isCurrent (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_isCurrent(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","isCurrent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXbool)FXGLViewer_isCurrent((FXGLViewer const *)arg1);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

killFocus (*args)

Source

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

lasso (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_lasso(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","lasso", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  result = (VALUE)FXGLViewer_lasso(arg1,arg2,arg3,arg4,arg5);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

layout (*args)

Source

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

load (*args)

Source

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

locked? ()

Source

# File rdoc-sources/FXGLViewer.rb, line 304
def locked?; end

Returns true if the viewer is locked

lower (*args)

Source

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

makeCurrent (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_makeCurrent(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","makeCurrent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXbool)FXGLViewer_makeCurrent(arg1);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

makeNonCurrent (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_makeNonCurrent(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","makeNonCurrent", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXbool)FXGLViewer_makeNonCurrent(arg1);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

modelPix (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_modelPix(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","modelPix", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXdouble)((FXGLViewer const *)arg1)->modelPix();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

Size of pixel in model coordinates [Float]

move (*args)

Source

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

old_initialize (parent, vis, *args, &blk)

Alias for: new

onChanged (*args)

Source

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

onClicked (*args)

Source

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

onClipboardGained (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onClipboardGained(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardGained", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onClipboardLost(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardLost", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onCmdAmbientColor (*args)

Source

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

onCmdBack (*args)

Source

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

onCmdBackColor (*args)

Source

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

onCmdBottom (*args)

Source

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

onCmdCopySel (*args)

Source

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

onCmdCutSel (*args)

Source

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

onCmdDeleteSel (*args)

Source

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

onCmdDither (*args)

Source

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

onCmdFitView (*args)

Source

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

onCmdFog (*args)

Source

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

onCmdFov (*args)

Source

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

onCmdFront (*args)

Source

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

onCmdGradientBackColor (*args)

Source

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

onCmdLassoSelect (*args)

Source

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

onCmdLassoZoom (*args)

Source

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

onCmdLeft (*args)

Source

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

onCmdLightAmbient (*args)

Source

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

onCmdLightDiffuse (*args)

Source

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

onCmdLightSpecular (*args)

Source

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

onCmdLighting (*args)

Source

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

onCmdParallel (*args)

Source

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

onCmdPasteSel (*args)

Source

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

onCmdPerspective (*args)

Source

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

onCmdPrintImage (*args)

Source

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

onCmdPrintVector (*args)

Source

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

onCmdResetView (*args)

Source

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

onCmdRight (*args)

Source

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

onCmdRollPitchYaw (*args)

Source

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

onCmdTop (*args)

Source

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

onCmdTurbo (*args)

Source

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

onCmdXYZDial (*args)

Source

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

onCmdXYZScale (*args)

Source

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

onCmdZoom (*args)

Source

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

onDNDDrop (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onDNDDrop(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDDrop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onDNDEnter(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDEnter", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onDNDLeave(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDLeave", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onDNDMotion(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDMotion", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onDeleted (*args)

Source

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

onDeselected (*args)

Source

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

onDoubleClicked (*args)

Source

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

onEnter (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onEnter(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onEnter", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onFocusIn(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onFocusIn", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onFocusOut(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onFocusOut", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onInserted (*args)

Source

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

onKeyPress (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onKeyPress(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onKeyPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onKeyRelease(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onKeyRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onLassoed (*args)

Source

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

onLeave (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onLeave(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeave", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeftBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeftBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onMiddleBtnPress (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMiddleBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMiddleBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onMotion(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMotion", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onMouseWheel(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMouseWheel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onPaint(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onPaint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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 = 0;
  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}

onPick (*args)

Source

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

onQueryHelp (*args)

Source

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

onQueryTip (*args)

Source

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

onRightBtnPress (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onRightBtnPress", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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_FXGLViewer_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onRightBtnRelease", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(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;
}

onSelected (*args)

Source

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

onTipTimer (*args)

Source

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

onTripleClicked (*args)

Source

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

onUngrabbed (*args)

Source

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

onUpdAmbientColor (*args)

Source

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

onUpdBack (*args)

Source

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

onUpdBackColor (*args)

Source

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

onUpdBottom (*args)

Source

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

onUpdCurrent (*args)

Source

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

onUpdDeleteSel (*args)

Source

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

onUpdDither (*args)

Source

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

onUpdFog (*args)

Source

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

onUpdFov (*args)

Source

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

onUpdFront (*args)

Source

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

onUpdGradientBackColor (*args)

Source

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

onUpdLeft (*args)

Source

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

onUpdLightAmbient (*args)

Source

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

onUpdLightDiffuse (*args)

Source

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

onUpdLightSpecular (*args)

Source

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

onUpdLighting (*args)

Source

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

onUpdParallel (*args)

Source

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

onUpdPerspective (*args)

Source

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

onUpdRight (*args)

Source

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

onUpdRollPitchYaw (*args)

Source

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

onUpdTop (*args)

Source

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

onUpdTurbo (*args)

Source

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

onUpdXYZDial (*args)

Source

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

onUpdXYZScale (*args)

Source

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

onUpdZoom (*args)

Source

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

pick (*args)

Source

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

position (*args)

Source

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

raiseWindow (*args)

Source

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

readFeedback (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_readFeedback(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","readFeedback", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  result = (VALUE)FXGLViewer_readFeedback(arg1,arg2,arg3,arg4,arg5);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

readPixels (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_readPixels(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","readPixels", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  result = (VALUE)FXGLViewer_readPixels(arg1,arg2,arg3,arg4,arg5);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

recalc (*args)

Source

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

reparent (*args)

Source

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

resize (*args)

Source

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

save (*args)

Source

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

screenToEye (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_screenToEye(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXfloat arg4 = (FXfloat) 0.0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","screenToEye", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  if (argc > 2) {
    ecode4 = SWIG_AsVal_float(argv[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","screenToEye", 4, argv[2] ));
    } 
    arg4 = static_cast< FXfloat >(val4);
  }
  result = (arg1)->screenToEye(arg2,arg3,arg4);
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

screenToTarget (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_screenToTarget(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","screenToTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (arg1)->screenToTarget(arg2,arg3);
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

select(x, y, w, h) → FXGLObject **

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_select(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXGLObject **result = 0 ;
  VALUE vresult = Qnil;
  
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  result = (FXGLObject **)FXGLViewer_select(arg1,arg2,arg3,arg4,arg5);
  {
    vresult=Qnil;
    if(result){
      vresult=rb_ary_new();
      FXGLObject** p=result;
      while(*p){
        rb_ary_push(vresult,to_ruby(*p));
        p++;
      }
      FXFREE(&result);
    }
  }
  return vresult;
fail:
  return Qnil;
}

Iterate thru each element in the FXGLViewer and select those that match a condition. A block must be provided.

setAmbientColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setAmbientColor(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXVec4f *arg2 = 0 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setAmbientColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    if (TYPE(argv[0]) == T_ARRAY) {
      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
    } else {
      FXVec4f *p;
      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
      arg2 = new FXVec4f(*p);
    }
  }
  (arg1)->setAmbientColor((FXVec4f const &)*arg2);
  delete arg2;
  return Qnil;
fail:
  delete arg2;
  return Qnil;
}

setBackColor (*args)

Source

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

setBackgroundColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setBackgroundColor(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXVec4f *arg2 = 0 ;
  FXbool arg3 = (FXbool) 2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setBackgroundColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    if (TYPE(argv[0]) == T_ARRAY) {
      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
    } else {
      FXVec4f *p;
      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
      arg2 = new FXVec4f(*p);
    }
  }
  if (argc > 1) {
    arg3 = to_FXbool(argv[1]);
  }
  (arg1)->setBackgroundColor((FXVec4f const &)*arg2,arg3);
  delete arg2;
  return Qnil;
fail:
  delete arg2;
  return Qnil;
}

setBounds (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setBounds(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXRangef *arg2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXRangef * >(argp2);
  result = (FXbool)FXGLViewer_setBounds(arg1,(FXRangef const &)*arg2);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

setCenter (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setCenter(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setCenter", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","setCenter", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","setCenter", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  (arg1)->setCenter(arg2);
  return Qnil;
fail:
  return Qnil;
}

setDefault (*args)

Source

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

setDistance (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setDistance(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXdouble arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  (arg1)->setDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}

setFieldOfView (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setFieldOfView(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXdouble arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setFieldOfView", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setFieldOfView", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  (arg1)->setFieldOfView(arg2);
  return Qnil;
fail:
  return Qnil;
}

setFocus (*args)

Source

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

setHelpText (*args)

Source

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

setLight (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setLight(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXLight *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setLight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXLight,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXLight const &","setLight", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXLight const &","setLight", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXLight * >(argp2);
  (arg1)->setLight((FXLight const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

setMaterial (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setMaterial(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXMaterial *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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMaterial,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMaterial const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMaterial const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXMaterial * >(argp2);
  (arg1)->setMaterial((FXMaterial const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

setMaxHits (*args)

Source

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

setOrientation (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setOrientation(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXQuatf arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatf,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatf","setOrientation", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf","setOrientation", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXQuatf * >(argp2));
    }
  }
  (arg1)->setOrientation(arg2);
  return Qnil;
fail:
  return Qnil;
}

setProjection (*args)

Source

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

setScale (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setScale(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","setScale", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","setScale", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  (arg1)->setScale(arg2);
  return Qnil;
fail:
  return Qnil;
}

setScene (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setScene(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXGLObject *arg2 = (FXGLObject *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setScene", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLObject *","setScene", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXGLObject * >(argp2);
  (arg1)->setScene(arg2);
  return Qnil;
fail:
  return Qnil;
}

setSelection (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setSelection(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXGLObject *arg2 = (FXGLObject *) 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setSelection", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLObject *","setSelection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXGLObject * >(argp2);
  (arg1)->setSelection(arg2);
  return Qnil;
fail:
  return Qnil;
}

setShape (*args)

Source

SWIGINTERN VALUE _wrap_FXGLViewer_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_FXGLViewer, 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_FXGLViewer_setShape__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLViewer, 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_FXGLViewer_setShape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLViewer, 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_FXGLViewer_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;
}

setTipText (*args)

Source

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

setTurboMode (*args)

Source

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

setZSortFunc (*args)

Source

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

setZoom (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_setZoom(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXdouble arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setZoom", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setZoom", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  (arg1)->setZoom(arg2);
  return Qnil;
fail:
  return Qnil;
}

show (*args)

Source

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

swapBuffers (*args)

Source

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

tr (*args)

Source

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

translate (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_translate(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","translate", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","translate", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  (arg1)->translate(arg2);
  return Qnil;
fail:
  return Qnil;
}

turboMode? ()

Source

# File rdoc-sources/FXGLViewer.rb, line 321
def turboMode?; end

Returns true if turbo mode is enabled

worldPix (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_worldPix(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","worldPix", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  result = (FXdouble)((FXGLViewer const *)arg1)->worldPix();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

Size of pixel in world coordinates [Float]

worldToEye (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_worldToEye(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< FXVec3f > 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldToEye", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","worldToEye", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","worldToEye", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  result = (arg1)->worldToEye(arg2);
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

worldToEyeZ (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_worldToEyeZ(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  SwigValueWrapper< FXVec3f > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  FXfloat 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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldToEyeZ", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","worldToEyeZ", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","worldToEyeZ", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
    }
  }
  result = (FXfloat)(arg1)->worldToEyeZ(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}

worldVector (*args)

Source

SWIGINTERN VALUE
_wrap_FXGLViewer_worldVector(int argc, VALUE *argv, VALUE self) {
  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXVec3f > result;
  VALUE vresult = Qnil;
  
  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_FXGLViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldVector", 1, self )); 
  }
  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  result = (arg1)->worldVector(arg2,arg3,arg4,arg5);
  {
    FXVec3f* resultptr = new FXVec3f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
  }
  return vresult;
fail:
  return Qnil;
}

class Fox::FXGLViewer

Events¶ ↑

FXGLViewer options¶ ↑

Projection modes (class constants)¶ ↑

Message identifiers¶ ↑

`FXGLViewer` options¶ ↑