fxruby 1.6.27-x64-mingw32

data/rdoc-sources/FXDCPrint.rb

@@ -0,0 +1,127 @@
+module Fox
+  #
+  # Bounding box
+  #
+  class FXPSBounds
+
+    # Minimum x-coordinate [Float]
+    attr_accessor :xmin
+
+    # Maximum x-coordinate [Float]
+    attr_accessor :xmax
+
+    # Minimum y-coordinate [Float]
+    attr_accessor :ymin
+
+    # Maximum y-coordinate
+    attr_accessor :ymax
+
+    # Returns an initialized FXPSBounds instance
+    def initialize; end
+  end
+
+
+  #
+  # Describes printer
+  #
+  # === Printer flags
+  #
+  # +PRINT_DEST_PAPER+:: Send print to paper
+  # +PRINT_DEST_FILE+::  Send print to file
+  # +PRINT_PAGES_ALL+::  Print all pages
+  # +PRINT_PAGES_EVEN+:: Print even pages only
+  # +PRINT_PAGES_ODD+::  Print odd pages only
+  # +PRINT_PAGES_RANGE+:: Print range of pages
+  # +PRINT_COLLATE_NORMAL+:: Normal collate order
+  # +PRINT_COLLATE_REVERSED+:: Reversed collate order
+  # +PRINT_PORTRAIT+::  Portrait orientation
+  # +PRINT_LANDSCAPE+::  Landscape orientation
+  # +PRINT_BLACKANDWHITE+:: Black and white output
+  # +PRINT_COLOR+::  Color output
+  # +PRINT_NOBOUNDS+::  Must determine bounding box
+  #
+  # === Printer media size
+  #
+  # +MEDIA_CUSTOM+::  Custom paper size
+  # +MEDIA_USLETTER+::  US Letter size
+  # +MEDIA_LEGAL+::  US Legal size
+  # +MEDIA_A4+::  A4
+  # +MEDIA_ENVELOPE+::  #10 Envelope
+  #
+  class FXPrinter
+    # Printer name [String]
+    attr_accessor :name
+
+    # First page that can be printed [Integer]
+    attr_accessor :firstpage
+
+    # Last page that can be printed [Integer]
+    attr_accessor :lastpage
+
+    # Current page to print [Integer]
+    attr_accessor :currentpage
+
+    # On output, this is the first page to print [Integer]
+    attr_accessor :frompage
+
+    # On output, last page to print [Integer]
+    attr_accessor :topage
+
+    #
+    # Media size index, one of +MEDIA_CUSTOM+, +MEDIA_USLETTER+, +MEDIA_LEGAL+,
+    # +MEDIA_A4+ or +MEDIA_ENVELOPE+ [Integer]
+    #
+    attr_accessor :mediasize
+
+    # Width of paper in points (1/72 of an inch) [Float]
+    attr_accessor :mediawidth
+
+    # Height of paper in points [Float]
+    attr_accessor :mediaheight
+
+    # Left margin [Float]
+    attr_accessor :leftmargin
+
+    # Right margin [Float]
+    attr_accessor :rightmargin
+
+    # Top margin [Float]
+    attr_accessor :topmargin
+
+    # Bottom margin [Float]
+    attr_accessor :bottommargin
+
+    # Number of copies [Integer]
+    attr_accessor :numcopies
+
+    # Flags [Integer]
+    attr_accessor :flags
+
+    # Returns an initialized FXPrinter instance
+    def initialize; end
+  end
+
+  #
+  # Postscript Printer Device Context
+  #
+  class FXDCPrint < FXDC
+    # Returns an initialized FXDCPrint instance.
+    def initialize(app)
+    end
+
+    #
+    # Generate print job epilog.
+    # See also {#beginPrint}.
+    #
+    def endPrint(); end
+
+    #
+    # Generate end of page.
+    # See also {#beginPage}.
+    #
+    def endPage(); end
+
+    def setContentRange(pxmin, pymin, pxmax, pymax); end
+  end
+end
+

data/rdoc-sources/FXDCWindow.rb

@@ -0,0 +1,33 @@
+module Fox
+  #
+  # A window device context allows drawing into an FXDrawable, such as an
+  # on-screen window (i.e. FXWindow and its derivatives) or an off-screen image (FXImage
+  # and its derivatives).
+  # Because certain hardware resources are locked down, only one FXDCWindow may be
+  # locked on a drawable at any one time.
+  #
+  class FXDCWindow < FXDC
+    #
+    # Construct a device context for drawing into a window (specified by _drawable_).
+    # If _event_ is +nil_, the device context is constructed for normal drawing, and the
+    # clip rectangle is set to the whole rectange.
+    # If _event_ is a reference to an FXEvent, the device context is constructed for
+    # painting in response to an expose; this sets the clip rectangle to the exposed rectangle.
+    # If an optional code block is provided, the new device context will be passed into the block as an
+    # argument and {#end} will be called automatically when the block terminates.
+    #
+    def initialize(drawable, event=nil) # :yields: dc
+    end
+
+    #
+    # Lock in a drawable surface.
+    #
+    def begin(drawable) ; end
+
+    #
+    # Unlock the drawable surface.
+    #
+    def end() ; end
+  end
+end
+

data/rdoc-sources/FXDataTarget.rb

@@ -0,0 +1,66 @@
+module Fox
+  #
+  # A data target allows a valuator widget such as an FXSlider or FXTextField
+  # to be directly connected with a variable in the program.
+  # Whenever the valuator control changes, the variable connected through
+  # the data target is automatically updated; conversely, whenever the program
+  # changes a variable, all the connected valuator widgets will be updated
+  # to reflect this new value on the display. For example:
+  #
+  #     data = FXDataTarget.new("Some Text")
+  #     textfield = FXTextField.new(p, 12, data, FXDataTarget::ID_VALUE)
+  #
+  # Data targets also allow connecting other kinds of widgets (like FXRadioButton and
+  # FXMenuCommand) to a variable. In this case, the new value of the connected variable
+  # is computed by subtracting <code>FXDataTarget::ID_OPTION</code> from the message
+  # identifier. For example, to tie a group of radio buttons to a single data target's
+  # value (so that the buttons are mutually exclusive), use code like this:
+  #
+  #     data = FXDataTarget.new(0)
+  #     radio1 = FXRadioButton.new(p, "1st choice", data, FXDataTarget::ID_OPTION)
+  #     radio2 = FXRadioButton.new(p, "2nd choice", data, FXDataTarget::ID_OPTION + 1)
+  #     radio3 = FXRadioButton.new(p, "3rd choice", data, FXDataTarget::ID_OPTION + 2)
+  #
+  # Note that if you'd like the data target to "forward" its +SEL_COMMAND+ or
+  # +SEL_CHANGED+ to some other target object after it has updated the data
+  # target value, you can do that just as you would for any other widget.
+  # For example, continuing the previous code snippet:
+  #
+  #     data.connect(SEL_COMMAND) {
+  #       puts "The new data target value is #{data.value}"
+  #     }
+  #
+  # === Events
+  #
+  # The following messages are sent by FXDataTarget to its target:
+  #
+  # +SEL_COMMAND+::   Sent after the data target processes a +SEL_COMMAND+ message itself
+  # +SEL_CHANGED+::   Sent after the data target processes a +SEL_CHANGED+ message itself
+  #
+  # === Message identifiers
+  #
+  # +ID_VALUE+::    Causes the FXDataTarget to ask sender for value
+  # +ID_OPTION+::   +ID_OPTION++_i_ will set the value to _i_, where -10000 <= _i_ <= 10000
+  #
+  class FXDataTarget < FXObject
+
+    # The message target object for this data target {FXObject}
+    attr_accessor :target
+
+    # The message identifier for this data target [Integer]
+    attr_accessor :selector
+
+    # The data target's current value [Object]
+    attr_accessor :value
+
+    #
+    # Return a new FXDataTarget instance, initialized with the specified _value_.
+    # If the optional message target object and message identifier (_tgt_ and _sel_)
+    # are specified, the data target will forward the +SEL_COMMAND+ or +SEL_COMMAND+
+    # to this other target.
+    #
+    def initialize(value=nil, target=nil, selector=0) # :yields: theDataTarget
+    end
+  end
+end
+

data/rdoc-sources/FXDebugTarget.rb

@@ -0,0 +1,25 @@
+module Fox
+  #
+  # A debug target prints out every message it receives.
+  # To use it, simply make the FXDebugTarget a target of the widget
+  # whose messages you want to see.
+  #
+  class FXDebugTarget < FXObject
+    #
+    # Returns an array of strings containing the names of the message types.
+    # So, for example,
+    #
+    # puts FXDebugTarget.messageTypeName[SEL_COMMAND]
+    #
+    # should print the text "SEL_COMMAND".
+    #
+    def FXDebugTarget.messageTypeName ; end
+
+    #
+    # Construct a debug target.
+    #
+    def initialize # :yields: theDebugTarget
+    end
+  end
+end
+

data/rdoc-sources/FXDelegator.rb

@@ -0,0 +1,23 @@
+module Fox
+  #
+  # A delegator forwards messages to a delegate object.
+  # Delegators are used when you need to multiplex messages
+  # toward any number of target objects.
+  # For example, many controls may be connected to FXDelegator,
+  # instead of directly to the document object.  Changing the
+  # delegate in FXDelegator will then reconnect the controls with their
+  # new target.
+  #
+  class FXDelegator < FXObject
+
+    # The object to which all messages are delegated {FXObject}
+    attr_accessor :delegate
+
+    #
+    # Construct a new delegator
+    #
+    def initialize(delegate=nil) # :yields: theDelegate
+    end
+  end
+end
+

data/rdoc-sources/FXDial.rb

@@ -0,0 +1,107 @@
+module Fox
+  #
+  # The Dial widget is a valuator widget which is able to provide a cyclic
+  # value range when the <tt>DIAL_CYCLIC</tt> is passed, or a simple linear value range.
+  # While being turned, the dial sends a <tt>SEL_CHANGED</tt> message to its target;
+  # at the end of the interaction, a <tt>SEL_COMMAND</tt> message is sent.
+  # The message data represents the current value (an integer). The options
+  # <tt>DIAL_VERTICAL</tt> and <tt>DIAL_HORIZONTAL</tt> control the orientation of the dial.
+  # An optional notch can be used to indicate the zero-position of
+  # the dial; display of the notch is controlled by the <tt>DIAL_HAS_NOTCH</tt> option.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXDial to its target:
+  #
+  # +SEL_KEYPRESS+::  sent when a key goes down; the message data is an FXEvent instance.
+  # +SEL_KEYRELEASE+::  sent when a key goes up; the message data is an FXEvent instance.
+  # +SEL_LEFTBUTTONPRESS+:: sent when the left mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_LEFTBUTTONRELEASE+:: sent when the left mouse button goes up; the message data is an FXEvent instance.
+  # +SEL_CHANGED+::             sent when the dial's value changes; the message data is the new value (an integer).
+  # +SEL_COMMAND+::  sent when the user stops changing the dial's value and releases the mouse button; the message data is the new value (an integer).
+  #
+  # === Dial style options
+  #
+  # +DIAL_VERTICAL+::     Vertically oriented
+  # +DIAL_HORIZONTAL+::   Horizontal oriented
+  # +DIAL_CYCLIC+::       Value wraps around
+  # +DIAL_HAS_NOTCH+::    Dial has a Center Notch
+  # +DIAL_NORMAL+::       same a +DIAL_VERTICAL+
+  #
+  class FXDial < FXFrame
+
+    # Dial value [Integer]
+    attr_accessor :value
+
+    # Dial range [Range]
+    attr_accessor :range
+
+    #
+    # The revolution increment is the amount of change in the position
+    # for revolution of the dial; the dial may go through multiple revolutions
+    # to go through its whole range. By default it takes one 360 degree turn of
+    # the dial to go from the lower to the upper range. [Integer]
+    #
+    attr_accessor :revolutionIncrement
+
+    #
+    # The spacing for the small notches; this should be set
+    # in tenths of degrees in the range [1,3600], and the value should
+    # be a divisor of 3600, so as to make the notches come out evenly. [Integer]
+    #
+    attr_accessor :notchSpacing
+
+    #
+    # The notch offset is the position of the center notch; the value should
+    # be tenths of degrees in the range [-3600,3600]. [Integer]
+    #
+    attr_accessor :notchOffset
+
+    # Current dial style [Integer]
+    attr_accessor :dialStyle
+
+    # Center notch color {FXColor}
+    attr_accessor :notchColor
+
+    # Status line help text for this dial [String]
+    attr_accessor :helpText
+
+    # Tool tip message for this dial
+    attr_accessor :tipText
+
+    #
+    # Construct a dial widget
+    #
+    # ==== Parameters:
+    #
+    # +p+:: parent widget for this dial {FXComposite}
+    # +target+:: message target object for this dial {FXObject}
+    # +selector+:: message identifier [Integer]
+    # +opts+::
+    # +x+::
+    # +y+::
+    # +width+::
+    # +height+::
+    # +padLeft+::
+    # +padRight+::
+    # +padTop+::
+    # +padBottom+::
+    #
+    def initialize(p, target=nil, selector=0, opts=DIAL_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theDial
+    end
+
+    #
+    # Set the dial value. If _notify_ is +true+, a +SEL_COMMAND+ message is
+    # sent to the dial's message target after the value is changed.
+    #
+    def setValue(value, notify=false); end
+
+    #
+    # Set the dial's range. If _notify_ is +true+, and the range modification
+    # causes the dial's value to change, a +SEL_COMMAND+ message is sent
+    # to the dial's message target after the value is changed.
+    #
+    def setRange(range, notify=false); end
+  end
+end
+

data/rdoc-sources/FXDialogBox.rb

@@ -0,0 +1,32 @@
+module Fox
+  #
+  # Dialog box window.
+  #
+  # When a dialog box receives a +SEL_COMMAND+ message with identifier
+  # +ID_CANCEL+ or +ID_ACCEPT+, the dialog box breaks out of the modal
+  # loop and returns a completion code of either 0 or 1, respectively.
+  #
+  # To close a dialog box when it's not running modally, simply call
+  # {#hide} (or send it the +ID_HIDE+ command message).
+  #
+  # === Message identifiers
+  #
+  # +ID_CANCEL+:: Close the dialog, cancel the entry
+  # +ID_ACCEPT+:: Close the dialog, accept the entry
+  #
+  class FXDialogBox < FXTopWindow
+    #
+    # Construct an empty dialog box.
+    # If the _owner_ is an FXWindow instance, the dialog will always float over that window.
+    # If the _owner_ is an FXApp instance, it will be a free-floating dialog.
+    #
+    def initialize(owner, title, opts=DECOR_TITLE|DECOR_BORDER, x=0, y=0, width=0, height=0, padLeft=10, padRight=10, padTop=10, padBottom=10, hSpacing=4, vSpacing=4) # :yields: theDialogBox
+    end
+
+    #
+    # Run a modal invocation of the dialog, with specified initial _placement_.
+    #
+    def execute(placement=PLACEMENT_CURSOR); end
+  end
+end
+

data/rdoc-sources/FXDict.rb

@@ -0,0 +1,78 @@
+module Fox
+  #
+  # The dictionary class maintains a fast-access hash table of entities
+  # indexed by a character string.
+  # It is typically used to map strings to pointers; however, derived classes
+  # may allow any type of data to be indexed by strings.
+  #
+  class FXDict < FXObject
+
+    # Total number of entries in the table [Integer]
+    attr_reader :length
+
+    # Position of first filled slot, or >= total [Integer]
+    attr_reader :first
+
+    # Position of last filled slot, or -1 [Integer]
+    attr_reader :last
+
+    alias size length
+
+    #
+    # Construct an empty dictionary.
+    #
+    def initialize ; end
+
+    #
+    # Return key at position _pos_.
+    #
+    def key(pos) ; end
+
+    #
+    # Return mark flag of entry at position _pos_.
+    #
+    def marked?(pos) ; end
+
+    #
+    # Return position of next filled slot after _pos_ in the hash table,
+    # or a value greater than or equal to total if no filled
+    # slot was found.
+    #
+    def next(pos) ; end
+
+    #
+    # Return position of previous filled slot before _pos_ in the hash table,
+    # or a -1 if no filled slot was found.
+    #
+    def prev(pos) ; end
+
+    #
+    # Clear all entries
+    #
+    def clear() ; end
+
+    #
+    # Iterate over the keys in this dictionary.
+    #
+    def each_key # :yields: key
+    end
+
+    #
+    # Returns a new array populated with the keys from this dictionary.
+    #
+    def keys() ; end
+
+    #
+    # Returns +true+ if the given _key_ is present.
+    #
+    def has_key?(key) ; end
+
+    alias include? has_key?
+    alias member?  has_key?
+
+    #
+    # Returns +true+ if this dictionary contains no key-value pairs.
+    #
+    def empty?() ; end
+  end
+end