Copyright notice for library

Return application instance

Construct application object; the appName and vendorName strings are used as keys into the registry database for this application‘s settings. Only one single application object can be constructed.

Add a idle processing message to be sent to a target object when the system becomes idle, i.e. when there are no more events to be processed. There are several forms for addChore; the original form (from FOX) takes two arguments, a target object and a message identifier:

    app.addChore(tgt, sel)

If a chore with the same target and message already exists, it will be rescheduled.

A second form takes a Method instance as its single argument:

    app.addChore(mthd)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form takes a block:

    app.addChore() do |sender, sel, data|
        ... handle the chore ...
    end

All of these return a reference to an opaque FXChore instance that can be passed to removeChore if it is necessary to remove the chore before it fires.

For the last two forms, you can pass in the optional +:repeat+ parameter to cause the chore to be re-registered after it fires, e.g.

    chore = app.addChore(:repeat => true) do |sender, sel, data|
        ... handle the chore ...
        ... re-add the chore ...
    end

Add a file descriptor fileDesc to be watched for activity as determined by mode, where mode is a bitwise OR (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT). A message of type SEL_IO_READ, SEL_IO_WRITE, or SEL_IO_EXCEPT will be sent to the target when the specified activity is detected on the file descriptor.

There are several forms for addInput; the original form (from FOX) takes four arguments:

  anApp.addInput(fileDesc, mode, anObject, aMessageId)

A second form takes three arguments:

  anApp.addInput(fileDesc, mode, aMethod)

For this form, aMethod should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of addInput takes a block:

  anApp.addInput(fileDesc, mode) { |sender, sel, data|
    ... handle the I/O event ...
  }

Register a signal processing message to be sent to target object when the specified signal is raised.

There are several forms for addSignal; the original form (from FOX) takes (up to) five arguments:

  anApp.addSignal(aSignal, anObject, aMessageId, sendImmediately=false, flags=0)

Here, aSignal is a string indicating the operating system signal of interest (such as "SIGINT"). The second and third arguments are the target object and message identifier for the message to be sent when this signal is raised. If sendImmediately is true, the message will be sent to the target right away; this should be used with extreme care as the application is interrupted at an unknown point in its execution. The flags are to be set as per POSIX definitions.

A second form of addSignal takes a Method instance as its second argument:

  anApp.addSignal(aSignal, aMethod, sendImmediately=false, flags=0)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of addSignal takes a block:

  anApp.addSignal(aSignal, sendImmediately=false, flags=0) { |sender, sel, data|
    ... handle the signal ...
  }

Add signal processing message to be sent to target object when the signal sig is raised; flags are to be set as per POSIX definitions. When immediate is true, the message will be sent to the target right away; this should be used with extreme care as the application is interrupted at an unknown point in its execution.

Alias for addSignal

Add a timeout message to be sent to target object in ms milliseconds. By default, the timer fires only once after the interval expires. The last argument is optional user data which will be passed along as the ptr argument of the message handler. If a timer with the same target and message already exists, it will be rescheduled.

There are several forms for addTimeout; the original form (from FOX) takes three arguments:

    timeout = app.addTimeout(delay, tgt, sel)

Here, delay is the time interval (in milliseconds) to wait before firing this timeout. The second and third arguments are the target object and message identifier for the message to be sent when this timeout fires.

A second form of addTimeout takes a Method instance as its single argument:

    timeout = app.addTimeout(delay, mthd)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of addTimeout takes a block:

    timeout = app.addTimeout(delay) do |sender, sel, data|
        ... handle the timeout ...
    end

All of these return a reference to an opaque object (actually, a hash) that can be passed to removeTimeout if it is necessary to remove the timeout before it fires.

For the last two forms, you can pass in the optional +:repeat+ parameter to cause the timeout to be re-registered after it fires, e.g.

    timeout = app.addTimeout(delay, :repeat => true) do |sender, sel, data|
        ... handle the timeout ...
        ... re-add the timeout with the same delay ...
    end

Beep

Changes the default application cursor to an hourglass shape, to provide a visual cue to the user that it‘s time to wait. To revert the default application cursor to its normal shape, call the endWaitCursor method. For example,

   getApp().beginWaitCursor()
     ... time-consuming operation ...
   getApp().endWaitCursor()

Invocations of beginWaitCursor may be nested, and if so, the call to endWaitCursor is matched with the most recent call to beginWaitCursor.

If an optional code block is provided, endWaitCursor is automatically called after the block terminates, e.g.

   getApp().beginWaitCursor() {
             ... time-consuming operation ...
     ... endWaitCursor() is called automatically ...
   }

Close connection to the display

Create application‘s windows

Destroy application‘s windows

Detach application‘s windows

Disable support for multithreaded applications

Dump widget information

Enable support for multithreaded applications

End the most deeply nested wait-cursor block. See also beginWaitCursor.

Exit application. Closes the display and writes the registry.

Flush pending repaints

Force GUI refresh

Return a reference to one of the default application cursors (an FXCursor instance), where which is one of the default cursor identifiers listed above, e.g.

  rotateCursor = app.getDefaultCursor(DEF_ROTATE_CURSOR)

See also setDefaultCursor.

Return the name of a previously registered drag type, e.g.

  dragTypeName = app.getDragTypeName(yamlDragType)

See also registerDragType.

Return key state (either true or false) for keysym.

Process any timeouts due at this time.

Return true if given chore has been set, otherwise return false.

For example, you might set up a chore at some point in the execution:

    chore = app.addChore { ... }

but decide that you want to "cancel" that chore later (before it‘s had a chance to run):

    if app.hasChore?(chore)
      app.removeChore(chore)
    end

Return true if input methods are supported.

Return true if given timeout has been set, otherwise return false.

For example, suppose you set up a timeout event to run ten seconds from now:

    timeout = app.addTimeout(10*1000, ...)

but in the meantime, you decide that you want to cancel it if it hasn‘t run yet:

    if app.hasTimeout?(timeout)
      app.removeTimeout(timeout)
    end

Initialize application. Parses and removes common command line arguments, reads the registry. Finally, if connect is true, it opens the display.

Return true if the application has been initialized.

Returns true if the window is modal

Return a reference to the application-wide mutex (an FXMutex instance). Normally, the main user interface thread holds this mutex, insuring that no other threads are modifying data during the processing of user interface messages. However, whenever the main user interface thread blocks for messages, it releases this mutex, to allow other threads to modify the same data. When a new message becomes available, the main user interface thread regains the mutex prior to dispatching the message. Other threads should hold this mutex only for short durations, so as to not starve the main user interface thread.

Open connection to display; this is called by init.

Peek to determine if there‘s an event.

Read a window and its children from the stream store, and append it under father; note it is initially not created yet. Return a reference to the new window.

Parameters:

Schedule a refresh

Return a reference to the registry (an FXRegistry instance). The registry keeps settings and configuration information for an application, which are automatically loaded when the application starts up, and saved when the application terminates.

Register a drag type with the given name and return the drag drag type. If this drag type has already been registered, this method will return the previously returned drag type. For example,

  yamlDragType = app.registerDragType("application/x-yaml")

See also getDragTypeName.

Return the time remaining (in milliseconds) until the given timer fires. If the timer is past due, zero is returned. If there is no such timer, infinity (UINT_MAX) is returned.

For example:

    timeout = app.addTimeout(ms, ...)
    time_left = app.remainingTimeout(timeout)

Remove idle processing message identified by tgt and sel. See the documentation for hasChore? for an example of how to use the removeChore method.

Remove input message and target object for the specified file descriptor and mode, which is a bitwise OR of (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).

Remove signal message for signal sig.

Remove timeout previously registered using addTimeout; returns nil. For an example of how to use removeTimeout, see the documentation for the hasTimeout? method.

Paint all windows marked for repainting. On return all the applications windows have been painted.

Run the main application event loop until stop is called, and return the exit code passed as argument to stop.

Run modal event loop, blocking keyboard and mouse events to all windows until stopModal is called.

Run a modal event loop for the given window, until stop or stopModal is called. Except for the modal window and its children, user input to all windows is blocked; if the modal window is nil all user input is blocked.

Run event loop while there are events are available in the queue. Returns 1 when all events in the queue have been handled, and 0 when the event loop was terminated due to stop or stopModal. Except for the modal window and its children, user input to all windows is blocked; if the modal window is nil, all user input is blocked.

Run modal while window is shown, or until stop or stopModal is called. Except for the modal window and its children, user input to all windows is blocked; if the modal window is nil all user input is blocked.

Perform one event dispatch; return true if event was dispatched.

Run popup menu while shown, until stop or stopModal is called. Also returns when entering previous cascading popup menu.

Run an event loop till some flag becomes non-zero, and then return.

Run event loop while events are available, non-modally. Return when no more events, timers, or chores are outstanding.

Replace one of the default application cursors with cursor; e.g

  app.setDefaultCursor(DEF_ROTATE_CURSOR, myRotateCursor)

See also getDefaultCursor.

Terminate the outermost event loop, and all inner modal loops; All more deeper nested event loops will be terminated with code equal to 0, while the outermost event loop will return code equal to value.

Break out of the innermost modal loop, returning code equal to value.

Break out of the matching modal loop, returning code equal to value. All deeper nested event loops are terminated with code equal to 0.

Check to see if multithreaded applications are supported

Return the number of existing windows.

Write a window and its children, and all resources reachable from this window, into the stream store (an FXStream instance).

Parameters: