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

class Fox::FXApp

Events¶ ↑

File input modes for {#addInput}¶ ↑

All ways of being modal¶ ↑

Default cursors provided by the application¶ ↑

Messages identifiers¶ ↑