class Fox::FXApp

Application Object

Events

The FXApp object itself doesn’t have a designated message target like other FOX objects, but it can send messages to objects for a few special events.

Timers: When a timeout event is registered with the application using the addTimeout method, a SEL_TIMEOUT message is sent to the message target.
Chores: When a chore event is registered with the application using the addChore method, a SEL_CHORE message is sent to the message target.
Inputs: When an input event is registered with the application using the addInput method, a SEL_IO_READ, SEL_IO_WRITE or SEL_IO_EXCEPT message may be sent to the message target.
Signals: When a signal handler object is registered with the application using the addSignal method, a SEL_SIGNAL message may be sent to the message target.

File input modes for {#addInput}

INPUT_NONE: inactive
INPUT_READ: read input fd
INPUT_WRITE: write input fd
INPUT_EXCEPT: except input fd

MODAL_FOR_NONE: Non modal event loop (dispatch normally)
MODAL_FOR_WINDOW: Modal dialog (beep if outside of modal dialog)
MODAL_FOR_POPUP: Modal for popup (always dispatch to popup)

Default cursors provided by the application

These constants symbolically represent the different cursor shapes used in FOX applications, and can be used as the which arguments for {#getDefaultCursor} and {#setDefaultCursor}.

DEF_ARROW_CURSOR: Arrow cursor
DEF_RARROW_CURSOR: Reverse arrow cursor
DEF_TEXT_CURSOR: Text cursor
DEF_HSPLIT_CURSOR: Horizontal split cursor
DEF_VSPLIT_CURSOR: Vertical split cursor
DEF_XSPLIT_CURSOR: Cross split cursor
DEF_SWATCH_CURSOR: Color swatch drag cursor
DEF_MOVE_CURSOR: Move cursor
DEF_DRAGH_CURSOR: Resize horizontal edge
DEF_DRAGV_CURSOR: Resize vertical edge
DEF_DRAGTL_CURSOR: Resize upper-leftcorner
DEF_DRAGBR_CURSOR: Resize bottom-right corner
DEF_DRAGTR_CURSOR: Resize upper-right corner
DEF_DRAGBL_CURSOR: Resize bottom-left corner
DEF_DNDSTOP_CURSOR: Drag and drop stop
DEF_DNDCOPY_CURSOR: Drag and drop copy
DEF_DNDMOVE_CURSOR: Drag and drop move
DEF_DNDLINK_CURSOR: Drag and drop link
DEF_CROSSHAIR_CURSOR: Cross hair cursor
DEF_CORNERNE_CURSOR: North-east cursor
DEF_CORNERNW_CURSOR: North-west cursor
DEF_CORNERSE_CURSOR: South-east cursor
DEF_CORNERSW_CURSOR: South-west cursor
DEF_HELP_CURSOR: Help arrow cursor
DEF_HAND_CURSOR: Hand cursor
DEF_ROTATE_CURSOR: Rotate cursor
DEF_WAIT_CURSOR: Wait cursor

Messages identifiers

ID_QUIT: Terminate the application normally
ID_DUMP: Dump the current widget tree

Attributes

animSpeed [RW]

Animation speed, in milliseconds [Integer]

appName [R]

Application name [String]

argc [R]

Argument count [Integer]

argv [R]

Argument vector [Array]

backColor [RW]

Default background color {FXColor}

baseColor [RW]

Background color of GUI controls {FXColor}

blinkSpeed [RW]

Blink speed, in milliseconds [Integer]

borderColor [RW]

Border color {FXColor}

clickSpeed [RW]

Click speed, in milliseconds [Integer]

cursorWindow [R]

The window under the cursor, if any {FXWindow}

defaultVisual [RW]

Default visual {FXVisual}

display [R]

Display [Integer]

dragDelta [RW]

Drag delta, in pixels [Integer]

foreColor [RW]

Default foreground color {FXColor}

hiliteColor [RW]

Hilite color of GUI controls {FXColor}

menuPause [RW]

Menu pause, in milliseconds [Integer]

modalModality [R]

Mode of current modal loop [Integer]

modalWindow [R]

The window of the current modal loop {FXWindow}

monoVisual [R]

Monochrome visual {FXVisual}

normalFont [RW]

Default font {FXFont}

rootWindow [R]

Root window {FXRootWindow}

scrollDelay [RW]

Scroll delay time, in milliseconds [Integer]

scrollSpeed [RW]

Scroll speed, in milliseconds [Integer]

selMenuBackColor [RW]

Default background color for selected menu items {FXColor}

selMenuTextColor [RW]

Default text color for selected menu items {FXColor}

selbackColor [RW]

Default background color for selected objects {FXColor}

selforeColor [RW]

Default foreground color for selected objects {FXColor}

shadowColor [RW]

Shadow color of GUI controls {FXColor}

sleepTime [RW]

Amount of time (in milliseconds) to yield to Ruby’s thread scheduler [Integer]

tipbackColor [RW]

Default background color for tooltips {FXColor}

tipforeColor [RW]

Default foreground color for tooltips {FXColor}

tooltipPause [RW]

Tooltip pause, in milliseconds [Integer]

tooltipTime [RW]

Tooltip time, in milliseconds [Integer]

translator [RW]

Message translator {FXTranslator}

typingSpeed [RW]

Typing speed used for the FXIconList, FXList and FXTreeList widgets’ lookup features, in milliseconds. Default value is 1000 milliseconds.

vendorName [R]

Vendor name [String]

waitCursor [RW]

Wait cursor {FXCursor}

wheelLines [RW]

Number of wheel lines [Integer]

Public Class Methods

Source

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

instance (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_instance(int argc, VALUE *argv, VALUE self) {
  FXApp *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (FXApp *)FXApp::instance();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXApp(int argc, VALUE *argv, VALUE self) {
  FXchar *arg1 = (FXchar *) "Application" ;
  FXchar *arg2 = (FXchar *) "FoxDefault" ;
  FXApp *result = 0 ;
  
  if ((argc < 0) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  if (argc > 0) {
    arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  }
  if (argc > 1) {
    arg2 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
  }
  {
    result = (FXApp *)new_FXApp((char const *)arg1,(char const *)arg2);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (*args, &blk)

Source

# File lib/fox16/kwargs.rb, line 259
def initialize(*args, &blk)
  argument_names = %w{appName vendorName}
  default_params = { :appName => "Application", :vendorName => "FoxDefault" }
  params = {}
  params = args.pop if args.last.is_a? Hash
  args.each_with_index { |e, i| params[argument_names[i].intern] = e }
  params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
  params = default_params.merge(params)
  old_initialize(params[:appName], params[:vendorName], &blk)
end

Also aliased as: old_initialize

Public Instance Methods

activeWindow (*args)

Source

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

The active top-level window, if any {FXWindow}

addChore (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_addChore(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 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 ;
  
  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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addChore", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","addChore", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  if (argc > 2) {
    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 *","addChore", 4, argv[2] )); 
    }
  }
  (arg1)->addChore(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}

addInput (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_addInput(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  FXuint arg3 ;
  FXObject *arg4 = (FXObject *) 0 ;
  FXSelector arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  arg2 = argv[0];
  arg3 = NUM2UINT(argv[1]);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","addInput", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FXObject * >(argp4);
  arg5 = NUM2UINT(argv[3]);
  result = (bool)FXApp_addInput(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

addSignal (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_addSignal(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  FXObject *arg3 = (FXObject *) 0 ;
  FXSelector arg4 ;
  FXbool arg5 = (FXbool) 0 ;
  FXuint arg6 = (FXuint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addSignal", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  arg2 = argv[0];
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","addSignal", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXObject * >(argp3);
  arg4 = NUM2UINT(argv[2]);
  if (argc > 3) {
    arg5 = to_FXbool(argv[3]);
  }
  if (argc > 4) {
    arg6 = NUM2UINT(argv[4]);
  }
  FXApp_addSignal(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}

addTimeout (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_addTimeout(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  FXuint arg4 = (FXuint) 1000 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res5 ;
  
  if ((argc < 2) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","addTimeout", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  if (argc > 2) {
    arg4 = NUM2UINT(argv[2]);
  }
  if (argc > 3) {
    res5 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","addTimeout", 5, argv[3] )); 
    }
  }
  (arg1)->addTimeout(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}

beep (*args)

Source

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

beginWaitCursor (*args)

Source

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

closeDisplay (*args)

Source

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

create (*args)

Source

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

destroy (*args)

Source

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

detach (*args)

Source

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

disableThreads ()

Source

# File rdoc-sources/FXApp.rb, line 537
def disableThreads(); end

Disable support for multithreaded applications

dumpWidgets (*args)

Source

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

enableThreads ()

Source

# File rdoc-sources/FXApp.rb, line 534
def enableThreads(); end

Enable support for multithreaded applications

endWaitCursor (*args)

Source

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

exit (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_exit(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXint arg2 = (FXint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","exit", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  if (argc > 0) {
    arg2 = NUM2INT(argv[0]);
  }
  FXApp_exit(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

findWindowAt (*args)

Source

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

findWindowWithId (*args)

Source

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

flush (*args)

Source

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

focusWindow (*args)

Source

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

The window at the end of the focus chain, if any {FXWindow}

forceRefresh (*args)

Source

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

getAnimSpeed (*args)

Source

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

getAppName (*args)

Source

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

getArgc (*args)

Source

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

getArgv (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getArgv(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXchar **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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getArgv", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXchar **)((FXApp const *)arg1)->getArgv();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

getBackColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getBackColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getBackColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getBaseColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getBaseColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBaseColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getBaseColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getBlinkSpeed (*args)

Source

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

getBorderColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getBorderColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBorderColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getBorderColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getClickSpeed (*args)

Source

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

getCursorWindow (*args)

Source

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

getDefaultCursor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getDefaultCursor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXDefaultCursor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FXCursor *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDefaultCursor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDefaultCursor","getDefaultCursor", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDefaultCursor >(val2);
  result = (FXCursor *)((FXApp const *)arg1)->getDefaultCursor(arg2);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXCursor, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

getDefaultVisual (*args)

Source

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

getDisplay (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getDisplay(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuval 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDisplay", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXuval)FXApp_getDisplay((FXApp const *)arg1);
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}

getDragDelta (*args)

Source

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

getDragTypeName (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getDragTypeName(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXDragType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FXString result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDragTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragType","getDragTypeName", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDragType >(val2);
  result = ((FXApp const *)arg1)->getDragTypeName(arg2);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}

getDragWindow (*args)

Source

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

getForeColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getForeColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getForeColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getForeColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getHiliteColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getHiliteColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getHiliteColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getHiliteColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getKeyState (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getKeyState(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXuint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getKeyState", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  result = (bool)((FXApp const *)arg1)->getKeyState(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

getMenuPause (*args)

Source

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

getModalWindow (*args)

Source

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

getModality (*args)

Source

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

getMonoVisual (*args)

Source

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

getNormalFont (*args)

Source

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

getPopupWindow (*args)

Source

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

getRootWindow (*args)

Source

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

getScrollDelay (*args)

Source

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

getScrollSpeed (*args)

Source

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

getSelMenuBackColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getSelMenuBackColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelMenuBackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getSelMenuBackColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getSelMenuTextColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getSelMenuTextColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelMenuTextColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getSelMenuTextColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getSelbackColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getSelbackColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelbackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getSelbackColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getSelforeColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getSelforeColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelforeColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getSelforeColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getShadowColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getShadowColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getShadowColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getShadowColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getSleepTime (*args)

Source

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

getTipbackColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getTipbackColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTipbackColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getTipbackColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getTipforeColor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getTipforeColor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTipforeColor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXColor)((FXApp const *)arg1)->getTipforeColor();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getTooltipPause (*args)

Source

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

getTooltipTime (*args)

Source

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

getTranslator (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_getTranslator(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXTranslator *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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTranslator", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXTranslator *)((FXApp const *)arg1)->getTranslator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

getTypingSpeed (*args)

Source

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

getVendorName (*args)

Source

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

getWaitCursor (*args)

Source

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

getWheelLines (*args)

Source

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

getWindowCount (*args)

Source

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

handleTimeouts (*args)

Source

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

hasChore? (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_hasChoreq___(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","hasChore", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","hasChore", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  result = (bool)((FXApp const *)arg1)->hasChore(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

hasInputMethod? (*args)

Source

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

hasTimeout? (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_hasTimeoutq___(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","hasTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","hasTimeout", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  result = (bool)((FXApp const *)arg1)->hasTimeout(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

init (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_init(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  bool arg3 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","init", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  arg2 = argv[0];
  if (argc > 1) {
    ecode3 = SWIG_AsVal_bool(argv[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","init", 3, argv[1] ));
    } 
    arg3 = static_cast< bool >(val3);
  }
  FXApp_init(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

initialized? ()

Source

# File rdoc-sources/FXApp.rb, line 295
def initialized?; end

Return true if the application has been initialized.

isInitialized (*args)

Source

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

isModal (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_isModal(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","isModal", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","isModal", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (bool)((FXApp const *)arg1)->isModal(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

load (*args)

Source

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

mutex (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_mutex(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMutex *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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","mutex", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXMutex *) &(arg1)->mutex();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMutex, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

old_initialize (*args, &blk)

Alias for: new

onCmdDump (*args)

Source

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

onCmdHover (*args)

Source

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

onCmdQuit (*args)

Source

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

openDisplay (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_openDisplay(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXchar *arg2 = (FXchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","openDisplay", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  if (argc > 0) {
    arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
  }
  result = (bool)(arg1)->openDisplay((FXchar const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

peekEvent (*args)

Source

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

readWindow (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_readWindow(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXStream *arg2 = 0 ;
  FXWindow **arg3 = 0 ;
  FXWindow *arg4 = (FXWindow *) 0 ;
  FXWindow *arg5 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FXWindow *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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","readWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 &","readWindow", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","readWindow", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_p_FXWindow,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *&","readWindow", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXWindow *&","readWindow", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FXWindow ** >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXWindow *","readWindow", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< FXWindow * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXWindow, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXWindow *","readWindow", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< FXWindow * >(argp5);
  {
    if (!arg5) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  result = (FXWindow *)FXApp_readWindow(arg1,*arg2,*arg3,arg4,arg5);
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

refresh (*args)

Source

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

reg (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_reg(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXRegistry *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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","reg", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  result = (FXRegistry *) &(arg1)->reg();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXRegistry, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}

registerDragType (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_registerDragType(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< FXString > p2 ;
  FXDragType 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","registerDragType", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  p2 = to_FXString(argv[0]); arg2 = &p2;
  result = (FXDragType)((FXApp const *)arg1)->registerDragType((FXString const &)*arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

remainingTimeout (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_remainingTimeout(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXuint 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","remainingTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","remainingTimeout", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  result = (FXuint)(arg1)->remainingTimeout(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

removeChore (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_removeChore(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeChore", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","removeChore", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  (arg1)->removeChore(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

removeInput (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_removeInput(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  FXuint 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeInput", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  arg2 = argv[0];
  arg3 = NUM2UINT(argv[1]);
  result = (bool)FXApp_removeInput(arg1,arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

removeSignal (*args)

Source

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

removeTimeout (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_removeTimeout(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXObject *arg2 = (FXObject *) 0 ;
  FXSelector arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","removeTimeout", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXObject * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  (arg1)->removeTimeout(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

repaint (*args)

Source

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

run (*args)

Source

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

runModal (*args)

Source

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

runModalFor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_runModalFor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalFor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","runModalFor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (FXint)FXApp_runModalFor(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

runModalWhileEvents (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_runModalWhileEvents(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalWhileEvents", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  if (argc > 0) {
    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 *","runModalWhileEvents", 2, argv[0] )); 
    }
    arg2 = reinterpret_cast< FXWindow * >(argp2);
  }
  result = (FXint)FXApp_runModalWhileEvents(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

runModalWhileShown (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_runModalWhileShown(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalWhileShown", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","runModalWhileShown", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  result = (FXint)FXApp_runModalWhileShown(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

runOnUiThread (&block)

Source

# File lib/fox16/thread.rb, line 15
def runOnUiThread(&block)
  @event_handler_events << block
  @event_handler_pwr.write 'e'
end

runOneEvent (*args)

Source

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

runPopup (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_runPopup(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXWindow *arg2 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runPopup", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 *","runPopup", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXWindow * >(argp2);
  {
    if (!arg2) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  result = (FXint)FXApp_runPopup(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

runUntil (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_runUntil(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXuint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runUntil", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuint &","runUntil", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXuint &","runUntil", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXuint * >(argp2);
  result = (FXint)FXApp_runUntil(arg1,*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

runWhileEvents (*args)

Source

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

save (*args)

Source

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

scrollBarSize (*args)

Source

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

Scroll bar size [Integer]

scrollBarSize= (*args)

Source

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

Scroll bar size [Integer]

setAnimSpeed (*args)

Source

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

setBackColor (*args)

Source

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

setBaseColor (*args)

Source

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

setBlinkSpeed (*args)

Source

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

setBorderColor (*args)

Source

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

setClickSpeed (*args)

Source

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

setDefaultCursor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_setDefaultCursor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXDefaultCursor arg2 ;
  FXCursor *arg3 = (FXCursor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setDefaultCursor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDefaultCursor","setDefaultCursor", 2, argv[0] ));
  } 
  arg2 = static_cast< FXDefaultCursor >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXCursor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXCursor *","setDefaultCursor", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXCursor * >(argp3);
  FXApp_setDefaultCursor(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setDefaultVisual (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_setDefaultVisual(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXVisual *arg2 = (FXVisual *) 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setDefaultVisual", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXVisual, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVisual *","setDefaultVisual", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXVisual * >(argp2);
  FXApp_setDefaultVisual(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

setDragDelta (*args)

Source

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

setForeColor (*args)

Source

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

setHiliteColor (*args)

Source

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

setMenuPause (*args)

Source

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

setNormalFont (*args)

Source

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

setRootWindow (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_setRootWindow(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXRootWindow *arg2 = (FXRootWindow *) 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setRootWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXRootWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRootWindow *","setRootWindow", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXRootWindow * >(argp2);
  (arg1)->setRootWindow(arg2);
  return Qnil;
fail:
  return Qnil;
}

setScrollDelay (*args)

Source

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

setScrollSpeed (*args)

Source

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

setSelMenuBackColor (*args)

Source

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

setSelMenuTextColor (*args)

Source

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

setSelbackColor (*args)

Source

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

setSelforeColor (*args)

Source

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

setShadowColor (*args)

Source

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

setSleepTime (*args)

Source

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

setTipbackColor (*args)

Source

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

setTipforeColor (*args)

Source

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

setTooltipPause (*args)

Source

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

setTooltipTime (*args)

Source

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

setTranslator (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_setTranslator(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXTranslator *arg2 = (FXTranslator *) 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTranslator", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTranslator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTranslator *","setTranslator", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXTranslator * >(argp2);
  (arg1)->setTranslator(arg2);
  return Qnil;
fail:
  return Qnil;
}

setTypingSpeed (*args)

Source

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

setWaitCursor (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_setWaitCursor(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXCursor *arg2 = (FXCursor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setWaitCursor", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setWaitCursor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXCursor * >(argp2);
  FXApp_setWaitCursor(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

setWheelLines (*args)

Source

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

stop (*args)

Source

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

stopModal (*args)

Source

SWIGINTERN VALUE _wrap_FXApp_stopModal(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_FXApp_stopModal__SWIG_1(nargs, args, self);
      }
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        return _wrap_FXApp_stopModal__SWIG_1(nargs, args, self);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXApp_stopModal__SWIG_0(nargs, args, self);
        }
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          return _wrap_FXApp_stopModal__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXApp.stopModal", 
    "    void FXApp.stopModal(FXWindow *window, FXint value)\n"
    "    void FXApp.stopModal(FXint value)\n");
  
  return Qnil;
}

threadsEnabled= (*args)

Source

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

threadsEnabled? (*args)

Source

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

windowCount ()

Source

# File rdoc-sources/FXApp.rb, line 531
def windowCount; end

Return the number of existing windows.

writeWindow (*args)

Source

SWIGINTERN VALUE
_wrap_FXApp_writeWindow(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  FXStream *arg2 = 0 ;
  FXWindow *arg3 = (FXWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FXbool 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_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","writeWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< FXApp * >(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 &","writeWindow", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","writeWindow", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(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 *","writeWindow", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< FXWindow * >(argp3);
  result = (FXbool)(arg1)->writeWindow(*arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

Private Instance Methods

event_handler_pull (prd)

Source

# File lib/fox16/thread.rb, line 37
def event_handler_pull(prd)
  prd.read(1)
  while !@event_handler_events.empty?
    ev = @event_handler_events.shift
    ev.call
  end
end

event_handler_setup ()

Source

# File lib/fox16/thread.rb, line 22
def event_handler_setup
  if RUBY_PLATFORM =~ /mingw|mswin/i
    require 'socket'
    gs = TCPServer.open('localhost', 0)
    prd = TCPSocket.open('localhost', gs.addr[1])
    pwr = gs.accept
    gs.close
  else
    prd, pwr = IO.pipe
  end
  self.addInput(prd, Fox::INPUT_READ){ event_handler_pull(prd) }
  @event_handler_pwr = pwr
  @event_handler_events = Queue.new
end