fxruby 1.6.20-x86-linux

data/rdoc-sources/FXArrowButton.rb

@@ -0,0 +1,69 @@
+module Fox
+  #
+  # Button with an arrow; the arrow can point in any direction.
+  # When clicked, the arrow button sends a SEL_COMMAND to its target.
+  # When ARROW_REPEAT is passed, the arrow button sends a SEL_COMMAND
+  # repeatedly while the button is pressed.
+  # The option ARROW_AUTO together with ARROW_REPEAT makes the arrow
+  # button work in repeat mode simply by hovering the cursor over it.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXArrowButton 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_COMMAND+::
+  #   sent when the button is clicked (or repeatedly while the button is held
+  #   down, if the +ARROW_REPEAT+ option is in effect).
+  #
+  # === Arrow style options
+  #
+  # +ARROW_NONE+::      no arrow
+  # +ARROW_UP+::        arrow points up
+  # +ARROW_DOWN+::      arrow points down
+  # +ARROW_LEFT+::      arrow points left
+  # +ARROW_RIGHT+::     arrow points right
+  # +ARROW_AUTO+::	automatically fire when hovering mouse over button
+  # +ARROW_REPEAT+::    button repeats if held down
+  # +ARROW_AUTOGRAY+::  automatically gray out when not updated
+  # +ARROW_AUTOHIDE+::  automatically hide when not updated
+  # +ARROW_TOOLBAR+::   button is toolbar-style
+  # +ARROW_NORMAL+::    same as <tt>FRAME_RAISED|FRAME_THICK|ARROW_UP</tt>
+  #
+  # === Message identifiers
+  #
+  # +ID_REPEAT+::
+  #   message identifier used by the timer (internally) that handles
+  #   the auto-repeat feature (activated by the +ARROW_REPEAT+ option).
+
+  class FXArrowButton < FXFrame
+
+    # Arrow button state, where +true+ means the button is down [Boolean]
+    attr_accessor :state
+
+    # Status line help text for this arrow button [String]
+    attr_accessor :helpText
+
+    # Tool tip message for this arrow button [String]
+    attr_accessor :tipText
+
+    # Arrow style flags (see above)
+    attr_accessor :arrowStyle
+
+    # Default arrow size, in pixels [Integer]
+    attr_accessor :arrowSize
+
+    # Justification mode
+    attr_accessor :justify
+
+    # Fill color for the arrow [FXColor]
+    attr_accessor :arrowColor
+
+    # Construct arrow button
+    def initialize(parent, target=nil, selector=0, opts=ARROW_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theArrowButton
+    end
+  end
+end

data/rdoc-sources/FXBMPIcon.rb

@@ -0,0 +1,67 @@
+module Fox
+  #
+  # The BMP Icon class is a convenience class for working with icons in the
+  # Microsoft Bitmap (.bmp) graphics file format.  This makes it possible to
+  # use resources created with Windows development tools inside FOX without
+  # need for graphics file format translators.  The bitmap loaded handles
+  # 1, 4, and 8 bit paletted bitmaps, 16 and 24 bit RGB bitmaps, and
+  # 32 bit RGBA bitmaps.
+  #
+  class FXBMPIcon < FXIcon
+    #
+    # Return the suggested file extension for this image type ("bmp").
+    #
+    def FXBMPIcon.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXBMPIcon.mimeType; end
+    
+    #
+    # Return an initialized FXBMPIcon instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in BMP file format [String]
+    # +clr+::	transparency color [FXColor]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, clr=FXRGB(192,192,192), opts=0, width=1, height=1) # :yields: theBMPIcon
+    end
+  end
+
+  #
+  # Load a BMP file from a stream.
+  # If successful, returns an array containing the image pixel data (as a
+  # String), the transparency color, 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.fxloadBMP(store); end
+
+  #
+  # Save a BMP 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]
+  # +transp+::	transparency color [FXColor]
+  # +width+::	width [Integer]
+  # +height+::	height [Integer]
+  #
+  def Fox.fxsaveBMP(store, data, transp, width, height); end
+  
+  #
+  # Return +true+ if _store_ (an FXStream instance) contains a BMP image.
+  #
+  def Fox.fxcheckBMP(store); end
+end

data/rdoc-sources/FXBMPImage.rb

@@ -0,0 +1,30 @@
+module Fox
+  #
+  # Microsoft Bitmap image.
+  #
+  class FXBMPImage < FXImage
+    #
+    # Return the suggested file extension for this image type ("bmp").
+    #
+    def FXBMPImage.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXBMPImage.mimeType; end
+    
+    #
+    # Return an initialized FXBMPImage instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in BMP file format [String]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, opts=0, width=1, height=1)	# :yields: theBMPImage
+    end
+  end
+end

data/rdoc-sources/FXBitmap.rb

@@ -0,0 +1,115 @@
+module Fox
+  #
+  # A bitmap is a rectangular array of pixels.
+  # It supports two representations of these pixels: a client-side pixel buffer,
+  # and a server-side pixmap which is stored in an organization directly compatible
+  # with the screen, for fast drawing onto the device. The server-side representation
+  # is not directly accessible from the current process at it lives in the process
+  # of the X server or GDI (on Microsoft Windows).
+  # The client-side pixel array is of size height x (width+7)/8 bytes; in other
+  # words, 8 pixels packed into a single byte, starting with bit zero on the left.
+  # 
+  # === Image rendering hints
+  #
+  # +BITMAP_KEEP+::	Keep pixel data in client
+  # +BITMAP_OWNED+::	Pixel data is owned by image
+  # +BITMAP_SHMI+::	Using shared memory image
+  # +BITMAP_SHMP+::	Using shared memory pixmap
+  #
+  class FXBitmap < FXDrawable
+  
+    alias data getData
+
+    #
+    # Return an initialized FXBitmap instance.
+    # If a client-side pixel buffer (the _pixels_ argument) has been specified,
+    # the bitmap does not own that pixel buffer unless the +BITMAP_OWNED+ flag
+    # is set. If the +BITMAP_OWNED+ flag _is_ set, but a +nil+ value for _pixels_
+    # is passed in, a pixel buffer will be automatically created and will be
+    # owned by the bitmap. The flags +BITMAP_SHMI+ and +BITMAP_SHMP+ may be
+    # specified for large bitmaps to instruct FXBitmap#render to use shared
+    # memory to communicate with the server.
+    #
+    def initialize(app, pixels=nil, opts=0, width=1, height=1) # :yields: theBitmap
+    end
+
+    #
+    # Populate the bitmap with new pixel data of the same size; it will assume
+    # ownership of the pixel data if the +BITMAP_OWNED+ option is passed in the _opts_.
+    # The server-side representation of the image, if it exists, is not updated;
+    # to update ther server-side representation, call #render.
+    #
+    def setData(pix, opts=0); end
+
+    #
+    # Populate the bitmap with new pixel data of a new size; it will assume ownership
+    # of the pixel data if the +BITMAP_OWNED+ option is passed in the _opts_. The size of the server-
+    # side representation of the image, if it exists, is adjusted but the contents are
+    # not updated; to update the server-side representation, call #render.
+    #
+    def setData(pix, opts, w, h); end
+
+    # Return the pixel data.
+    def getData(); end
+    
+    # Return the option flags.
+    def options; end
+    
+    # Set the options.
+    def options=(opts); end
+
+    # Retrieve pixels from the server-side bitmap.
+    def restore; end
+
+    # Render the server-side representation of the bitmap from the client-side pixels.
+    def render() ; end
+    
+    #
+    # Release the client-side pixels buffer and free it if it was owned.
+    # If it is not owned, the image just forgets about the buffer.
+    #
+    def release(); end
+
+    #
+    # Resize both client-side and server-side representations (if any) to the
+    # given width and height.  The new representations typically contain garbage
+    # after this operation and need to be re-filled.
+    #
+    def resize(w, h); end
+
+    # Save pixel data only
+    def savePixels(stream); end
+    
+    # Load pixel data from a stream
+    def loadPixels(stream); end
+
+    # Get pixel state (either +true+ or +false+) at (_x_, _y_)
+    def getPixel(x, y) ; end
+
+    # Change pixel at (_x_, _y_), where _color_ is either +true+ or +false+.
+    def setPixel(x, y, color) ; end
+    
+    #
+    # Rescale pixels image to the specified width and height; this calls
+    # #resize to adjust the client and server side representations.
+    #
+    def scale(w, h); end
+    
+    # Mirror the bitmap horizontally and/or vertically
+    def mirror(horizontal, vertical); end
+    
+    # Rotate bitmap by _degrees_ degrees (counter-clockwise)
+    def rotate(degrees); end
+    
+    #
+    # Crop bitmap to given rectangle; this calls #resize to adjust the client
+    # and server side representations.  The new bitmap may be smaller or larger
+    # than the old one; blank areas are filled with _color_. There must be at
+    # least one pixel of overlap between the old and the new bitmap.
+    #
+    def crop(x, y, w, h, color=false); end
+    
+    # Fill bitmap with uniform value
+    def fill(color); end
+  end
+end

data/rdoc-sources/FXBitmapFrame.rb

@@ -0,0 +1,31 @@
+module Fox
+  #
+  # The bitmap frame is a simple frame widget displaying an monochrome bitmap
+  # image; the bitmap is not owned by the bitmap frame so it must be explicitly
+  # deleted elsewhere.
+  #
+  class FXBitmapFrame < FXFrame
+  
+    # The current image being displayed [FXBitmap]
+    attr_accessor :bitmap
+    
+    # The color used for the "on" bits in the bitmap [FXColor]
+    attr_accessor :onColor
+    
+    # The color used for the "off" bits in the bitmap [FXColor]
+    attr_accessor :offColor
+    
+    #
+    # The current justification mode, some combination of the flags
+    # +JUSTIFY_LEFT+, +JUSTIFY_RIGHT+, +JUSTIFY_TOP+ and +JUSTIFY_BOTTOM+
+    # [Integer]
+    #
+    attr_accessor :justify
+    
+    #
+    # Return an initialized FXBitmapFrame instance.
+    #
+    def initialize(p, bmp, opts=FRAME_SUNKEN|FRAME_THICK, x=0, y=0, width=0, height=0, padLeft=0, padRight=0, padTop=0, padBottom=0) # :yields: theBitmapFrame
+    end
+  end
+end

data/rdoc-sources/FXBitmapView.rb

@@ -0,0 +1,44 @@
+module Fox
+  #
+  # The Bitmap View widget display a scrollable view of a monochrome bitmap image;
+  # the bitmap is not owned by the bitmap frame so it must be explicitly deleted
+  # elsewhere.  Thus, a single bitmap image can be displayed inside multiple bitmap
+  # view widgets.
+  #
+  # === Bitmap alignment styles
+  #
+  # +BITMAPVIEW_NORMAL+::	Normal mode is centered
+  # +BITMAPVIEW_CENTER_X+::	Centered horizontally
+  # +BITMAPVIEW_LEFT+::		Left-aligned
+  # +BITMAPVIEW_RIGHT+::	Right-aligned
+  # +BITMAPVIEW_CENTER_Y+::	Centered vertically
+  # +BITMAPVIEW_TOP+::		Top-aligned
+  # +BITMAPVIEW_BOTTOM+::	Bottom-aligned
+  #
+  # === Events
+  #
+  # +SEL_RIGHTBUTTONPRESS+::	sent when the right mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_RIGHTBUTTONRELEASE+::	sent when the right mouse button goes up; the message data is an FXEvent instance.
+  #
+  class FXBitmapView < FXScrollArea
+  
+    # The bitmap [FXBitmap]
+    attr_accessor :bitmap
+    
+    # The color used for the "on" bits in the bitmap [FXColor]
+    attr_accessor :onColor
+
+    # The color used for the "off" bits in the bitmap [FXColor]
+    attr_accessor :offColor
+
+    # Current alignment [Integer]
+    attr_accessor :alignment
+
+    #
+    # Return an initialized FXBitmapView instance.
+    #
+    def initialize(p, bmp=nil, target=nil, selector=0, opts=0, x=0, y=0, width=0, height=0) # :yields: theBitmapView
+    end
+  end
+end
+

data/rdoc-sources/FXButton.rb

@@ -0,0 +1,59 @@
+module Fox
+  #
+  # A button provides a push button, with optional icon and/or text label.
+  # When pressed, the button widget sends a <tt>SEL_COMMAND</tt> to its target.
+  # Passing the <tt>BUTTON_TOOLBAR</tt> style option gives buttons a "flat" look, and
+  # causes the edge of the button to be raised when the cursor moves over it.
+  # Passing <tt>BUTTON_DEFAULT</tt> allows the button to become the default button in
+  # a dialog, when the focus moves to it.  The default widget in a dialog
+  # is the widget which will accept the _Return_ key when it is pressed.
+  # The <tt>BUTTON_INITIAL</tt> flag makes the button the default widget when the
+  # focus moves to a widget which can not itself be a default widget.
+  # There should be only a single button in the dialog which is the
+  # initial default; typically this is the _OK_ or _Close_ button.
+  # The option <tt>BUTTON_AUTOGRAY</tt> (<tt>BUTTON_AUTOHIDE</tt>) causes the button to be grayed
+  # out (hidden) if its handler does not respond to the <tt>SEL_UPDATE</tt> message.
+  # This is useful when messages are delegated, for example when using a
+  # multiple document interface, where the ultimate destination of a message
+  # can be changed.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXButton 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_COMMAND+::		sent when the button is clicked.
+  #
+  # === Button state bits
+  #
+  # +STATE_UP+::        Button is up
+  # +STATE_DOWN+::      Button is down
+  # +STATE_ENGAGED+::   Button is engaged
+  # +STATE_UNCHECKED+:: Same as +STATE_UP+ (used for check buttons or radio buttons)
+  # +STATE_CHECKED+::   Same as +STATE_ENGAGED+ (used for check buttons or radio buttons)
+  #
+  # === Button flags
+  #
+  # +BUTTON_AUTOGRAY+:: Automatically gray out when not updated
+  # +BUTTON_AUTOHIDE+:: Automatically hide button when not updated
+  # +BUTTON_TOOLBAR+::  Toolbar style button [flat look]
+  # +BUTTON_DEFAULT+::  May become default button when receiving focus
+  # +BUTTON_INITIAL+::  This button is the initial default button
+  # +BUTTON_NORMAL+::   Default button flags (<tt>FRAME_RAISED|FRAME_THICK|JUSTIFY_NORMAL|ICON_BEFORE_TEXT</tt>)
+  #
+  class FXButton < FXLabel
+  
+    # Button state (one of +STATE_UP+, +STATE_DOWN+, etc.) [Integer]
+    attr_accessor :state
+    
+    # Button style flags (some combination of +BUTTON_AUTOGRAY+, +BUTTON_AUTOHIDE+, etc.) [Integer]
+    attr_accessor :buttonStyle
+
+    # Construct button with specified _text_ and _icon_.
+    def initialize(parent, text, icon=nil, target=nil, selector=0, opts=BUTTON_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theButton
+    end
+  end
+end

data/rdoc-sources/FXCURCursor.rb

@@ -0,0 +1,13 @@
+module Fox
+  #
+  # CUR Cursor class
+  #
+  class FXCURCursor < FXCursor
+    #
+    # Construct a cursor from memory stream in Microsoft CUR format.
+    # The image is limited to 32x32 pixels.
+    #
+    def initialize(app, pixels) # :yields: theCursor
+    end
+  end
+end

data/rdoc-sources/FXCanvas.rb

@@ -0,0 +1,18 @@
+module Fox
+  # Canvas, an area drawn by another object
+  #
+  # === Events
+  #
+  # The following messages are sent by FXCanvas 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_MOTION+::	sent when the mouse moves; the message data is an FXEvent instance.
+  # +SEL_PAINT+::	sent when the canvas needs to be redrawn; the message data is an FXEvent instance.
+
+  class FXCanvas < FXWindow
+    # Construct new drawing canvas widget
+    def initialize(parent, target=nil, selector=0, opts=FRAME_NORMAL, x=0, y=0, width=0, height=0) # :yields: theCanvas
+    end
+  end
+end