module Fox
  # FOX Event
  class FXEvent

    # Event type [Integer]
    attr_reader :type

    # Time of last event [Integer]
    attr_reader :time

    # Window-relative x-coordinate [Integer]
    attr_reader :win_x

    # Window-relative y-coordinate [Integer]
    attr_reader :win_y

    # Root window x-coordinate [Integer]
    attr_reader :root_x

    # Root window y-coordinate [Integer]
    attr_reader :root_y

    # Keyboard/modifier state [Integer]
    attr_reader :state

    # Button, keysym or mode; DDE source [Integer]
    attr_reader :code

    # Text of keyboard event [String]
    attr_reader :text

    # Window-relative x-coordinate of previous mouse location [Integer]
    attr_reader :last_x

    # Window-relative y-coordinate of previous mouse location [Integer]
    attr_reader :last_y

    # Window-relative x-coordinate of mouse press [Integer]
    attr_reader :click_x

    # Window-relative y-coordinate of mouse press [Integer]
    attr_reader :click_y

    # Root window x-coordinate of mouse press [Integer]
    attr_reader :rootclick_x

    # Root window y-coordinate of mouse press [Integer]
    attr_reader :rootclick_y

    # Time of mouse button press [Integer]
    attr_reader :click_time

    # Mouse button pressed [Integer]
    attr_reader :click_button

    # Click count [Integer]
    attr_reader :click_count

    # Target drag type being requested [Integer]
    attr_reader :target

    # Return true if cursor moved since last press
    def moved? ; end

    # Exposed rectangle for paint events
    def rect ; end

    # Return true if this is a synthetic expose event
    def synthetic? ; end
  end

  #
  # 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
  #
  # === All ways of being modal
  #
  # +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

  class FXApp < FXObject

    # Application name [String]
    attr_reader :appName

    # Vendor name [String]
    attr_reader :vendorName

    # Argument count [Integer]
    attr_reader :argc

    # Argument vector [Array]
    attr_reader :argv

    # Display [Integer]
    attr_reader :display

    # Border color {FXColor}
    attr_accessor :borderColor

    # Background color of GUI controls {FXColor}
    attr_accessor :baseColor

    # Hilite color of GUI controls {FXColor}
    attr_accessor :hiliteColor

    # Shadow color of GUI controls {FXColor}
    attr_accessor :shadowColor

    # Default background color {FXColor}
    attr_accessor :backColor

    # Default foreground color {FXColor}
    attr_accessor :foreColor

    # Default foreground color for selected objects {FXColor}
    attr_accessor :selforeColor

    # Default background color for selected objects {FXColor}
    attr_accessor :selbackColor

    # Default foreground color for tooltips {FXColor}
    attr_accessor :tipforeColor

    # Default background color for tooltips {FXColor}
    attr_accessor :tipbackColor

    # Default text color for selected menu items {FXColor}
    attr_accessor :selMenuTextColor

    # Default background color for selected menu items {FXColor}
    attr_accessor :selMenuBackColor

    # Default visual {FXVisual}
    attr_accessor :defaultVisual

    # Default font {FXFont}
    attr_accessor :normalFont

    # Wait cursor {FXCursor}
    attr_accessor :waitCursor

    # Monochrome visual {FXVisual}
    attr_reader :monoVisual

    # Root window {FXRootWindow}
    attr_reader :rootWindow

    # The window under the cursor, if any {FXWindow}
    attr_reader :cursorWindow

    # The window at the end of the focus chain, if any {FXWindow}
    attr_reader :focusWindow

    # The active top-level window, if any {FXWindow}
    attr_reader :activeWindow

    # The window of the current modal loop {FXWindow}
    attr_reader :modalWindow

    # Mode of current modal loop [Integer]
    attr_reader :modalModality

    # Typing speed used for the FXIconList, FXList and FXTreeList widgets' lookup features,
    # in milliseconds. Default value is 1000 milliseconds.
    attr_accessor :typingSpeed

    # Click speed, in milliseconds [Integer]
    attr_accessor :clickSpeed

    # Scroll speed, in milliseconds [Integer]
    attr_accessor :scrollSpeed

    # Scroll delay time, in milliseconds [Integer]
    attr_accessor :scrollDelay

    # Blink speed, in milliseconds [Integer]
    attr_accessor :blinkSpeed

    # Animation speed, in milliseconds [Integer]
    attr_accessor :animSpeed

    # Menu pause, in milliseconds [Integer]
    attr_accessor :menuPause

    # Tooltip pause, in milliseconds [Integer]
    attr_accessor :tooltipPause

    # Tooltip time, in milliseconds [Integer]
    attr_accessor :tooltipTime

    # Drag delta, in pixels [Integer]
    attr_accessor :dragDelta

    # Number of wheel lines [Integer]
    attr_accessor :wheelLines

    # Scroll bar size [Integer]
    attr_accessor :scrollBarSize

    # Amount of time (in milliseconds) to yield to Ruby's thread scheduler [Integer]
    attr_accessor :sleepTime

    # Message translator {FXTranslator}
    attr_accessor :translator

    # Copyright notice for library
    def FXApp.copyright() ; end

    #
    # 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.
    #
    def initialize(appName="Application", vendorName="FoxDefault") # :yields: theApp
    end

    #
    # Open connection to display; this is called by {#init}.
    #
    def openDisplay(dpyname=nil) ; end

    # Close connection to the display
    def closeDisplay() ; end

    # Return true if the application has been initialized.
    def initialized?; end

    # Return +true+ if input methods are supported.
    def hasInputMethod?; end

    #
    # Process any timeouts due at this time.
    #
    def handleTimeouts(); end

    #
    # 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.
    #
    def addSignal(sig, tgt, sel, immediate=false, flags=0) ; end

    #
    # Remove signal message for signal _sig_.
    #
    def removeSignal(sig) ; end

    #
    # 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+).
    #
    def removeInput(fd, mode) ; end

    # Create application's windows
    def create() ; end

    # Destroy application's windows
    def destroy() ; end

    # Detach application's windows
    def detach() ; end

    #
    # Return key state (either +true+ or +false+) for _keysym_.
    #
    def getKeyState(keysym); end

    #
    # Peek to determine if there's an event.
    #
    def peekEvent(); end

    # Perform one event dispatch; return +true+ if event was dispatched.
    def runOneEvent(blocking=true); end

    # Run the main application event loop until {#stop} is called,
    # and return the exit code passed as argument to {#stop}.
    def run(); end

    #
    # Run an event loop till some flag becomes non-zero, and
    # then return.
    #
    def runUntil(condition); end

    #
    # Run event loop while events are available, non-modally.
    # Return when no more events, timers, or chores are outstanding.
    #
    def runWhileEvents(); end

    #
    # 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.
    #
    def runModalWhileEvents(window=nil); end

    # Run modal event loop, blocking keyboard and mouse events to all windows
    # until {#stopModal} is called.
    def runModal(); end

    # 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.
    def runModalFor(window); end

    # 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.
    def runModalWhileShown(window); end

    # Run popup menu while shown, until {#stop} or {#stopModal} is called.
    # Also returns when entering previous cascading popup menu.
    def runPopup(window); end

    # Returns +true+ if the window is modal
    def modal?(window) ; end

    # 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_.
    def stop(value=0); end

    #
    # Break out of the matching modal loop, returning code equal to _value_.
    # All deeper nested event loops are terminated with code equal to 0.
    #
    def stopModal(window, value=0); end

    #
    # Break out of the innermost modal loop, returning code equal to _value_.
    #
    def stopModal(value=0); end

    # Force GUI refresh
    def forceRefresh(); end

    # Schedule a refresh
    def refresh(); end

    # Flush pending repaints
    def flush(sync=false); end

    # Paint all windows marked for repainting.
    # On return all the applications windows have been painted.
    def repaint(); end

    #
    # 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.
    #
    def reg; end

    # Initialize application.
    # Parses and removes common command line arguments, reads the registry.
    # Finally, if _connect_ is +true+, it opens the display.
    def init(argv, connect=true) ; end

    # Exit application.
    # Closes the display and writes the registry.
    def exit(code=0); end

    #
    # 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}.
    #
    def registerDragType(name) ; end

    #
    # Return the name of a previously registered drag type, e.g.
    #
    #   dragTypeName = app.getDragTypeName(yamlDragType)
    #
    # See also {#registerDragType}.
    #
    def getDragTypeName(dragType) ; end

    # Beep
    def beep(); end

    # Return application instance
    def FXApp.instance(); end

    # End the most deeply nested wait-cursor block.
    # See also {#beginWaitCursor}.
    def endWaitCursor(); end

    #
    # 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}.
    #
    def getDefaultCursor(which) ; end

    #
    # Replace one of the default application cursors with _cursor_; e.g
    #
    #   app.setDefaultCursor(DEF_ROTATE_CURSOR, myRotateCursor)
    #
    # See also {#getDefaultCursor}.
    #
    def setDefaultCursor(which, cursor); end

    #
    # Write a window and its children, and all resources reachable from this
    # window, into the stream _store_ (an FXStream instance).
    #
    # ==== Parameters:
    #
    # +store+::  {FXStream}
    # +window+:: {FXWindow}
    #
    def writeWindow(store, window); end

    #
    # 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:
    #
    # +store+::  {FXStream}
    # +father+:: {FXWindow}
    # +owner+::  {FXWindow}
    #
    def readWindow(store, father, owner); end

    #
    # 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.
    #
    def mutex(); end

    # Dump widget information
    def dumpWidgets() ; end

    # Return the number of existing windows.
    def windowCount; end

    # Enable support for multithreaded applications
    def enableThreads(); end

    # Disable support for multithreaded applications
    def disableThreads(); end

    # Check to see if multithreaded applications are supported
    def threadsEnabled?(); end
  end
end