fxruby 1.6.27-x64-mingw32

data/rdoc-sources/FXSpring.rb

@@ -0,0 +1,61 @@
+module Fox
+  #
+  # The spring widgets, when properly embedded side by side in a horizontal
+  # frame or vertical frame widget, behave like a set of connected springs
+  # of various lengths.
+  #
+  # The third and fourth arguments to the FXSpring.new method (+relw+ and +relh+)
+  # determine the "length" of the spring. You can also change these settings after
+  # the widget is constructed using the {FXSpring#relativeWidth} and {FXSpring#relativeHeight}
+  # accessor methods.
+  # The actual length that you specify is not really
+  # important; the only thing that counts is the relative length of one
+  # spring widget to that of another, although the length does determine
+  # the default size. The special value zero may be given for +relw+ (or +relh+)
+  # to cause the spring to calculate its default width (height) normally,
+  # just like the FXPacker base class does.
+  #
+  # In a typical scenario, either the relative width or height is set to
+  # zero, an the flag <tt>LAYOUT_FILL_X</tt> or <tt>LAYOUT_FILL_Y</tt> is passed.
+  # When placed inside a horizontal frame, the <tt>LAYOUT_FILL_X</tt> together with
+  # the relative widths of the springs will cause a fixed width-ratio
+  # between the springs.
+  #
+  # You also can mix normal controls and springs together in a horizontal
+  # or vertical frames to provide arbitrary stretchable spacing between
+  # widgets; in this case, the springs do not need to have any children.
+  # Since the spring widget is derived from the FXPacker layout manager,
+  # it provides the same layout behavior as FXPacker.
+  #
+  class FXSpring < FXPacker
+    # Relative width [Integer]
+    attr_accessor :relativeWidth
+
+    # Relative height [Integer]
+    attr_accessor :relativeHeight
+
+    #
+    # Return an initialized FXSpring instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+:: the parent widget for this spring {FXComposite}
+    # +relw+:: the relative width [Integer]
+    # +relh+:: the relative height [Integer]
+    # +opts+:: the options [Integer]
+    # +x+:: initial x-position [Integer]
+    # +y+:: initial y-position [Integer]
+    # +width+:: initial width [Integer]
+    # +height+:: initial height [Integer]
+    # +padLeft+:: left-side padding (in pixels) [Integer]
+    # +padRight+:: right-side padding (in pixels) [Integer]
+    # +padTop+:: top-side padding (in pixels) [Integer]
+    # +padBottom+:: bottom-side padding (in pixels) [Integer]
+    # +hSpacing+:: horizontal spacing (in pixels) [Integer]
+    # +vSpacing+:: vertical spacing (in pixels) [Integer]
+    #
+    def initialize(p, opts=0, relw=0, relh=0, x=0, y=0, width=0, height=0, padLeft=DEFAULT_SPACING, padRight=DEFAULT_SPACING, padTop=DEFAULT_SPACING, padBottom=DEFAULT_SPACING, hSpacing=DEFAULT_SPACING, vSpacing=DEFAULT_SPACING) # :yields: theSpring
+    end
+  end
+end
+

data/rdoc-sources/FXStatusBar.rb

@@ -0,0 +1,42 @@
+module Fox
+  #
+  # Status bar
+  #
+  # === Status bar options
+  #
+  # +STATUSBAR_WITH_DRAGCORNER+:: Causes the drag corner to be shown
+  #
+  class FXStatusBar < FXHorizontalFrame
+
+    # The status line widget {FXStatusLine}
+    attr_reader :statusLine
+
+    # The drag corner widget {FXDragCorner}
+    attr_reader :dragCorner
+
+    # If +true+, the drag corner is shown [Boolean]
+    attr_accessor :cornerStyle
+
+    #
+    # Return an initialized FXStatusBar instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+:: the parent window for this status bar {FXComposite}
+    # +opts+:: status bar options [Integer]
+    # +x+:: initial x-position [Integer]
+    # +y+:: initial y-position [Integer]
+    # +width+:: initial width [Integer]
+    # +height+:: initial height [Integer]
+    # +padLeft+:: internal padding on the left side, in pixels [Integer]
+    # +padRight+:: internal padding on the right side, in pixels [Integer]
+    # +padTop+:: internal padding on the top side, in pixels [Integer]
+    # +padBottom+:: internal padding on the bottom side, in pixels [Integer]
+    # +hSpacing+:: horizontal spacing between widgets, in pixels [Integer]
+    # +vSpacing+:: vertical spacing between widgets, in pixels [Integer]
+    #
+    def initialize(p, opts=0, x=0, y=0, width=0, height=0, padLeft=3, padRight=3, padTop=2, padBottom=2, hSpacing=4, vSpacing=0) # :yields: theStatusBar
+    end
+  end
+end
+

data/rdoc-sources/FXStatusLine.rb

@@ -0,0 +1,60 @@
+module Fox
+  #
+  # The status line normally shows its permanent or "normal" message; when
+  # moving the mouse over a widget which provides status line help, the status line
+  # temporarily replaces its normal message with the help information; the status
+  # line obtains this help message by sending the widget a +ID_QUERY_HELP+ message
+  # with type +SEL_UPDATE+.
+  # If this query does not result in a new status string, the target of
+  # the status line is tried via an ordinary +SEL_UPDATE+ message.
+  # If _none_ of the above work, the status line will display the normal text
+  # (i.e. the string set via the {#normalText}= accessor method).
+  # If the message contains a newline character, then the part before the newline
+  # will be displayed in the highlight color, while the part after the newline
+  # will be shown using the normal text color.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXStatusLine to its target:
+  #
+  # +SEL_UPDATE+::
+  #   Sent when the widget currently under the mouse cursor doesn't respond
+  #   to a +SEL_UPDATE+ message with identifier +ID_QUERY_HELP+, as described
+  #   above.
+  #
+  class FXStatusLine < FXFrame
+
+    # Temporary status message [String]
+    attr_accessor :text
+
+    # Permanent status message [String]
+    attr_accessor :normalText
+
+    # Text font {FXFont}
+    attr_accessor :font
+
+    # Text color {FXColor}
+    attr_accessor :textColor
+
+    # Highlight text color {FXColor}
+    attr_accessor :textHighlightColor
+
+    #
+    # Return an initialized FXStatusLine instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+:: the parent window for this shutter {FXComposite}
+    # +target+:: the message target, if any, for this shutter {FXObject}
+    # +selector+:: the message identifier for this shutter [Integer]
+    #
+    def initialize(p, target=nil, selector=0) # :yields: theStatusLine
+    end
+
+    # Returns the temporary status message (i.e. same as _text_)
+    def to_s
+      text
+    end
+  end
+end
+

data/rdoc-sources/FXStream.rb

@@ -0,0 +1,142 @@
+module Fox
+  #
+  # A stream is a way to serialize data and objects into a byte stream.
+  # Each item of data that is saved or loaded from the stream may be byte-swapped,
+  # thus allowing little-endian machines to read data produced on big endian ones
+  # and vice-versa.
+  # Data is serialized exactly as-is.  There are no tags or other markers
+  # inserted into the stream; thus, the stream may be used to save or load arbitrary
+  # binary data.
+  # Objects derived from FXObjects may be serialized also; whenever a reference to an
+  # object is serialized, a table is consulted to determine if the same object has
+  # been encountered previously; if not, the object is added to the table and then
+  # its contents are serialized.  If the object has been encountered before, only a
+  # reference to the object is serialized.
+  # When loading back a serialized object, new instances are constructed using
+  # the default constructor, and subsequently the object's contents are loaded.
+  # A special container object may be passed in which is placed in the table
+  # as if it had been encountered before; this will cause only references to this
+  # object to be saved.  The container object is typically the top-level document
+  # object which manages all objects contained by it.  Additional objects may be
+  # added using addObject(); these will not be actually saved or loaded.
+  #
+  # === Stream status codes
+  #
+  # +FXStreamOK+::  OK
+  # +FXStreamEnd+::  Try read past end of stream
+  # +FXStreamFull+::  Filled up stream buffer or disk full
+  # +FXStreamNoWrite+::  Unable to open for write
+  # +FXStreamNoRead+::  Unable to open for read
+  # +FXStreamFormat+::  Stream format error
+  # +FXStreamUnknown+::  Trying to read unknown class
+  # +FXStreamAlloc+::  Alloc failed
+  # +FXStreamFailure+::  General failure
+  #
+  # === Stream data flow direction
+  #
+  # +FXStreamDead+::  Unopened stream
+  # +FXStreamSave+::  Saving stuff to stream
+  # +FXStreamLoad+::  Loading stuff from stream
+  #
+  # === Stream seeking
+  #
+  # +FXFromStart+::  Seek from start position
+  # +FXFromCurrent+::  Seek from current position
+  # +FXFromEnd+::  Seek from end position
+  #
+  class FXStream
+
+    # Stream status [Integer]
+    attr_reader :status
+
+    # Stream direction, one of +FXStreamSave+, +FXStreamLoad+ or +FXStreamDead+.
+    attr_reader :direction
+
+    # Parent object {FXObject}
+    attr_reader :container
+
+    # Available buffer space
+    attr_accessor :space
+
+    # Stream position (an offset from the beginning of the stream) [Integer]
+    attr_accessor :position
+
+    #
+    # Construct stream with given container object.  The container object
+    # is an object that will itself not be saved to or loaded from the stream,
+    # but which may be referenced by other objects.  These references will be
+    # properly saved and restored.
+    #
+    # ==== Parameters:
+    #
+    # +cont+:: the container object, or +nil+ if there is none {FXObject}.
+    #
+    def initialize(cont=nil) # :yields: theStream
+    end
+
+    #
+    # Open stream for reading or for writing.
+    # An initial buffer size may be given, which must be at least 16 bytes.
+    # If _data_ is not +nil+, it is expected to point to an external data buffer
+    # of length _size_; otherwise the stream will use an internally managed buffer.
+    # Returns +true+ on success, +false+ otherwise.
+    #
+    # ==== Parameters:
+    #
+    # +save_or_load+:: access mode, either +FXStreamSave+ or +FXStreamLoad+ [Integer]
+    # +size+::  initial buffer size [Integer]
+    # +data+::  external data buffer (if any) [String]
+    #
+    def open(save_or_load, size=8192, data=nil); end
+
+    #
+    # Close stream; returns +true+ if OK.
+    #
+    def close(); end
+
+    #
+    # Flush buffer
+    #
+    def flush(); end
+
+    #
+    # Get available buffer space
+    #
+    def getSpace(); end
+
+    #
+    # Set available buffer space
+    #
+    def setSpace(sp); end
+
+    #
+    # Return +true+ if at end of file or error.
+    #
+    def eof?; end
+
+    #
+    # Set status code, where _err_ is one of the stream status
+    # codes listed above.
+    #
+    def error=(err); end
+
+    # Set the byte-swapped flag to +true+ or +false+.
+    def bytesSwapped=(swapBytes); end
+
+    # Returns +true+ if bytes are swapped for this stream
+    def bytesSwapped?; end
+
+    #
+    # Set stream to big endian mode if +true+. Byte swapping will
+    # be enabled if the machine native byte order is not equal to
+    # the desired byte order.
+    #
+    def bigEndian=(big); end
+
+    #
+    # Return +true+ if big endian mode.
+    #
+    def bigEndian?; end
+  end
+end
+

data/rdoc-sources/FXStringDict.rb

@@ -0,0 +1,38 @@
+module Fox
+  #
+  # An FXStringDict (string dictionary) object maps one string to another
+  # string. The inserted strings are copied when they're inserted.
+  #
+  class FXStringDict < FXDict
+    #
+    # Return an initialized FXStringDict instance.
+    #
+    def initialize; end
+
+    #
+    # Insert a new string indexed by key, with given mark flag.
+    #
+    def insert(key, value, mrk=false); end
+
+    #
+    # Replace or insert a new string indexed by key, unless given mark is lower than the existing mark.
+    #
+    def replace(key, value, mrk=false); end
+
+    #
+    # Remove entry indexed by key.
+    #
+    def remove(key); end
+
+    #
+    # Return the entry indexed by _key_, or nil if the key does not exist.
+    #
+    def find(key); end
+
+    #
+    # Return the string at integer position _pos_.
+    #
+    def data(pos); end
+  end
+end
+

data/rdoc-sources/FXSwitcher.rb

@@ -0,0 +1,78 @@
+module Fox
+  #
+  # The FXSwitcher layout manager automatically arranges its child
+  # windows such that one of them is placed on top; all other
+  # child windows are hidden.
+  # Switcher provides a convenient method to conserve screen
+  # real-estate by arranging several GUI panels to appear in the
+  # same space, depending on context.
+  # Switcher ignores all layout hints from its children; all
+  # children are stretched according to the switcher layout
+  # managers own size.
+  # When the +SWITCHER_HCOLLAPSE+ or +SWITCHER_VCOLLAPSE+ options
+  # are used, the switcher's default size is based on the width or
+  # height of the current child, instead of the maximum width
+  # or height of all of the children.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXSwitcher to its target:
+  #
+  # +SEL_COMMAND+::
+  #   sent whenever the current (topmost) child window changes;
+  #   the message data is an integer indicating the new current window's index.
+  #
+  # === Switcher options
+  #
+  # +SWITCHER_HCOLLAPSE+:: Collapse horizontally to width of current child
+  # +SWITCHER_VCOLLAPSE+:: Collapse vertically to height of current child
+  #
+  # === Message identifiers
+  #
+  # +ID_OPEN_FIRST+:: x
+  # +ID_OPEN_SECOND+:: x
+  # +ID_OPEN_THIRD+:: x
+  # +ID_OPEN_FOURTH+:: x
+  # +ID_OPEN_FIFTH+:: x
+  # +ID_OPEN_SIXTH+:: x
+  # +ID_OPEN_SEVENTH+:: x
+  # +ID_OPEN_EIGHTH+:: x
+  # +ID_OPEN_NINETH+:: x
+  # +ID_OPEN_TENTH+:: x
+  # +ID_OPEN_LAST+:: x
+  #
+  class FXSwitcher < FXPacker
+    # Current child window's index [Integer]
+    attr_accessor :current
+
+    # Switcher style flags [Integer]
+    attr_accessor :switcherStyle
+
+    #
+    # Return an initialized FXSwitcher instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+:: the parent window for this switcher {FXComposite}
+    # +opts+:: switcher options [Integer]
+    # +x+:: initial x-position [Integer]
+    # +y+:: initial y-position [Integer]
+    # +width+:: initial width [Integer]
+    # +height+:: initial height [Integer]
+    # +padLeft+:: internal padding on the left side, in pixels [Integer]
+    # +padRight+:: internal padding on the right side, in pixels [Integer]
+    # +padTop+:: internal padding on the top side, in pixels [Integer]
+    # +padBottom+:: internal padding on the bottom side, in pixels [Integer]
+    #
+    def initialize(p, opts=0, x=0, y=0, width=0, height=0, padLeft=DEFAULT_SPACING, padRight=DEFAULT_SPACING, padTop=DEFAULT_SPACING, padBottom=DEFAULT_SPACING) # :yields: theSwitcher
+    end
+
+    #
+    # Raise the child window at _index_ to the top of the stack.
+    # If _notify_ is +true+, a +SEL_COMMAND+ message is sent to the switcher's message target
+    # Raises IndexError if _index_ is out of bounds.
+    #
+    def setCurrent(index, notify=false); end
+  end
+end
+

data/rdoc-sources/FXTGAIcon.rb

@@ -0,0 +1,63 @@
+module Fox
+  #
+  # Targa Icon
+  #
+  class FXTGAIcon < FXIcon
+    #
+    # Return the suggested file extension for this image type ("tga").
+    #
+    def FXTGAIcon.fileExt; end
+
+    #
+    # Return the MIME type for this image type
+    #
+    def FXTGAIcon.mimeType; end
+
+    #
+    # Return an initialized FXTGAIcon instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+:: an application instance {FXApp}
+    # +pix+:: a memory buffer formatted in Targa file format [String]
+    # +clr+:: transparency color {FXColor}
+    # +opts+:: options [Integer]
+    # +width+:: width [Integer]
+    # +height+:: height [Integer]
+    #
+    def initialize(a, pix=nil, clr=0, opts=0, width=1, height=1) # :yields: theTGAIcon
+    end
+  end
+
+  #
+  # Load a Targa file from a stream.
+  # If successful, returns an array containing the image pixel data (as a
+  # String), the number of channels (either 3 or 4), the image width and the image height.
+  # If it fails, the function returns +nil+.
+  #
+  # ==== Parameters:
+  #
+  # +store+:: stream from which to read the file data {FXStream}
+  #
+  def Fox.fxloadTGA(store); end
+
+  #
+  # Save a Targa image to a stream.
+  # Returns +true+ on success, +false+ on failure.
+  #
+  # ==== Parameters:
+  #
+  # +store+::  stream to which to write the image data {FXStream}
+  # +data+::  the image pixel data [String]
+  # +channels+:: number of channels in the image pixel data: 3 for RGB data, or 4 for RGBA data [Integer]
+  # +width+::  width [Integer]
+  # +height+::  height [Integer]
+  #
+  def Fox.fxsaveTGA(store, data, channels, width, height); end
+
+  #
+  # Return +true+ if _store_ (an FXStream instance) contains a TGA image.
+  #
+  def Fox.fxcheckTGA(store); end
+end
+