fxruby 1.6.14-universal-darwin-9

data/examples/README

@@ -0,0 +1,53 @@
+This directory contains several example programs for FXRuby, and supporting
+files for the same. Here is a partial list of the files you'll find here:
+
+    button.rb
+        Demonstrates the various layout and appearance options for the
+        FXButton widget.
+
+    dialog.rb
+        Simple example demonstrating how to create both modal and non-modal
+        dialogs.
+
+    dirlist.rb
+        Demonstrates the directory list (FXDirList) widget.
+
+    foursplit.rb
+        Demonstrates the 4-way splitter widget.
+
+    gltest.rb
+        Demonstrates the OpenGL canvas widget, and how to use both timers
+        and chores in FOX applications. This one also requires the OpenGL
+        extensions for Ruby; check the Ruby Application Archive for the
+        current release.
+
+    groupbox.rb
+        This is a kind of periodic table of widgets for FOX; it displays
+        a wide variety of the core widgets with different options.
+
+    header.rb
+        Demonstrates the header widget.
+
+    hello.rb
+        Minimalist FXRuby: the classic "Hello, World!" program
+
+    hello2.rb
+        The souped-up version of "Hello, World!", complete with a PNG icon
+        and tooltips.
+
+    imageviewer.rb
+        This is primarily a demonstration of the image view (FXImageView)
+        widget but it also provides a model for what could be a full-blown
+        FXRuby application. This example has a menu bar and toolbar (both
+        "floatable") and demonstrates how to use FOX's registry mechanism
+        for persistent application settings.
+        and tooltips.
+
+    scribble.rb
+        This is the Ruby version of the scribble program described in the
+        standard FOX documentation. It demonstrates the basics of drawing
+        into a 2-D canvas as well as FOX's GUI updating features.
+
+    shutter.rb
+        Demonstrates the shutter widget, similar to that found in a popular
+        office application.

data/examples/babelfish.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require 'fox16'
+require 'soap/rpc/driver'
+
+include Fox
+
+TRANSLATIONS = {
+  "English to French" => "en_fr",
+  "English to German" => "en_de",
+  "English to Italian" => "en_it",
+  "English to Japanese" => "en_jp",
+  "English to Korean" => "en_kr",
+  "English to Portugese" => "en_pt",
+  "English to Spanish" => "en_es",
+  "French to English" => "fr_en",
+  "German to English" => "de_en",
+  "Italian to English" => "it_en",
+  "Japanese to English" => "jp_en",
+  "Korean to English" => "kr_en",
+  "Portugese to English" => "pt_en",
+  "Spanish to English" => "es_en",
+  "Russian to English" => "ru_en",
+  "German to French" => "de_fr",
+  "French to German" => "fr_de"
+}
+
+class Babelfish < FXMainWindow
+
+  def initialize(app)
+    # Invoke base class initialize first
+    super(app, "Babelfish", nil, nil, DECOR_ALL,
+      0, 0, 600, 400, 0, 0)
+
+    # Initialize the SOAP driver
+    @drv = SOAP::RPC::Driver.new('http://services.xmethods.net/perl/soaplite.cgi', 'urn:xmethodsBabelFish')
+    @drv.add_rpc_method_with_soapaction('BabelFish',
+      'urn:xmethodsBabelFish#BabelFish', 'translationmode', 'sourcedata')
+
+    # Controls area along the bottom
+    controlsFrame = FXHorizontalFrame.new(self,
+      LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X)
+    FXLabel.new(controlsFrame, "Translate from:")
+    @transModeCombo = FXComboBox.new(controlsFrame, 15, :opts => COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK)
+    @transModeCombo.numVisible = 6
+    TRANSLATIONS.keys.each do |key|
+      @transModeCombo.appendItem(key, TRANSLATIONS[key])
+    end
+    btn = FXButton.new(controlsFrame, "Translate", :opts => BUTTON_NORMAL|LAYOUT_RIGHT)
+    btn.connect(SEL_COMMAND) do
+      transMode = @transModeCombo.getItemData(@transModeCombo.currentItem)
+      getApp().beginWaitCursor() do
+        @translatedText.text = @drv.BabelFish(transMode, @sourceText.text)
+      end
+    end
+
+    mainFrame = FXVerticalFrame.new(self,
+      LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y|PACK_UNIFORM_HEIGHT)
+
+    # Source text area in a sunken frame
+    topFrame = FXVerticalFrame.new(mainFrame, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    FXLabel.new(topFrame, "Source Text:", :opts => LAYOUT_FILL_X)
+    sunkenFrame = FXHorizontalFrame.new(topFrame,
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @sourceText = FXText.new(sunkenFrame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    # Translated text output
+    bottomFrame = FXVerticalFrame.new(mainFrame, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    FXLabel.new(bottomFrame, "Translated text:", nil, LAYOUT_FILL_X)
+    sunkenFrame = FXHorizontalFrame.new(bottomFrame,
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @translatedText = FXText.new(sunkenFrame, :opts => TEXT_READONLY|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+  end
+  
+  def create
+    super
+    show(PLACEMENT_SCREEN)
+  end
+end
+
+if __FILE__ == $0
+  # Make application
+  application = FXApp.new("Babelfish", "FoxTest")
+
+  # Make window
+  window = Babelfish.new(application)
+
+  # Create it
+  application.create
+
+  # Run
+  application.run
+end

data/examples/bounce.rb

@@ -0,0 +1,159 @@
+require 'fox16'
+
+include Fox
+
+# How long to pause between updates (in milliseconds)
+ANIMATION_TIME = 20
+
+class Ball
+
+  attr_reader :color
+  attr_reader :center
+  attr_reader :radius
+  attr_reader :dir
+  attr_reader :x, :y
+  attr_reader :w, :h
+  attr_accessor :worldWidth
+  attr_accessor :worldHeight
+
+  # Returns an initialized ball
+  def initialize(r)
+    @radius = r
+    @w = 2*@radius
+    @h = 2*@radius
+    @center = FXPoint.new(50, 50)
+    @x = @center.x - @radius
+    @y = @center.y - @radius
+    @color = FXRGB(255, 0, 0) # red
+    @dir = FXPoint.new(-1, 0)
+    setWorldSize(1000, 1000)
+  end
+  
+  # Draw the ball into this device context
+  def draw(dc)
+    dc.setForeground(color)
+    dc.fillArc(x, y, w, h, 0, 64*90)
+    dc.fillArc(x, y, w, h, 64*90, 64*180)
+    dc.fillArc(x, y, w, h, 64*180, 64*270)
+    dc.fillArc(x, y, w, h, 64*270, 64*360)
+  end
+  
+  def bounce
+    @dir = -@dir
+  end
+  
+  def collision?
+    (x < 0) || (x+w > worldWidth) || (y < 0) || (y+h > worldHeight)
+  end
+
+  def setWorldSize(ww, wh)
+    @worldWidth = ww
+    @worldHeight = wh
+  end
+    
+  def move(units)
+    dx = dir.x*units
+    dy = dir.y*units
+    center.x += dx
+    center.y += dy
+    @x += dx
+    @y += dy
+    if collision?
+      bounce
+      move(units)
+    end
+  end
+end
+
+class BounceWindow < FXMainWindow
+
+  include Responder
+  
+  def initialize(app)
+    # Initialize base class first
+    super(app, "Bounce", :opts => DECOR_ALL, :width => 400, :height => 300)
+    
+    # Set up the canvas
+    @canvas = FXCanvas.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    
+    # Set up the back buffer
+    @backBuffer = FXImage.new(app, nil, IMAGE_KEEP)
+    
+    # Handle expose events (by blitting the image to the canvas)
+    @canvas.connect(SEL_PAINT) { |sender, sel, evt|
+      FXDCWindow.new(sender, evt) { |dc|
+        dc.drawImage(@backBuffer, 0, 0)
+      }
+    }
+    
+    # Handle resize events
+    @canvas.connect(SEL_CONFIGURE) { |sender, sel, evt|
+      @backBuffer.create unless @backBuffer.created?
+      @backBuffer.resize(sender.width, sender.height)
+      @ball.setWorldSize(sender.width, sender.height)
+      drawScene(@backBuffer)
+    }
+    
+    @ball = Ball.new(20)
+  end
+  
+  #
+  # Draws the scene into the back buffer
+  #
+  def drawScene(drawable)
+    FXDCWindow.new(drawable) { |dc|
+      dc.setForeground(FXRGB(255, 255, 255))
+      dc.fillRectangle(0, 0, drawable.width, drawable.height)
+      @ball.draw(dc)
+    }
+  end
+  
+  def updateCanvas
+    @ball.move(10)
+    drawScene(@backBuffer)
+    @canvas.update
+  end
+  
+  #
+  # Handle timeout events
+  #
+  def onTimeout(sender, sel, ptr)
+    # Move the ball and re-draw the scene
+    updateCanvas
+    
+    # Re-register the timeout
+    getApp().addTimeout(ANIMATION_TIME, method(:onTimeout))
+    
+    # Done
+    return 1
+  end
+  
+  #
+  # Create server-side resources
+  #
+  def create
+    # Create base class
+    super
+    
+    # Create the image used as the back-buffer
+    @backBuffer.create
+    
+    # Draw the initial scene into the back-buffer
+    drawScene(@backBuffer)
+    
+    # Register the timer used for animation
+    getApp().addTimeout(ANIMATION_TIME, method(:onTimeout))
+    
+    # Show the main window
+    show(PLACEMENT_SCREEN)
+  end
+end
+
+if __FILE__ == $0
+  FXApp.new("Bounce", "FXRuby") do |theApp|
+    BounceWindow.new(theApp)
+    theApp.create
+    theApp.run
+  end
+end
+

data/examples/browser.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require 'fox16'
+
+include Fox
+
+# Node in the class hierarchy tree
+class ClassTreeNode
+  def initialize(className, parentClassName)
+    @className = className
+    @parentClassName = parentClassName
+    @children = []
+  end
+
+  def addChild(child)
+    @children.push(child)
+  end
+
+  def className
+    @className
+  end
+
+  def parentClassName
+    @parentClassName
+  end
+
+  def <=>(other)
+    className <=> other.className
+  end
+
+  def children
+    @children.sort
+  end
+end
+
+# The class hierarchy tree
+class ClassTree
+  def initialize
+    # Find the Fox module
+    @mFox = Fox
+
+    # Get an hash containing class names for Fox
+    classes = {}
+    @mFox.constants.each do |name|
+      c = @mFox.const_get(name)
+      if c.kind_of? Class
+	parentclass = c.superclass.name.sub("Fox::", "")
+	classNode  = ClassTreeNode.new(name, parentclass)
+	classes[name] = classNode
+      end
+    end
+
+    # Go back and do this
+    roots = []
+    classes.each_value do |aValue|
+      parentNode = classes[aValue.parentClassName]
+      if parentNode
+        parentNode.addChild(aValue)
+      else
+        parentNode = ClassTreeNode.new(aValue.parentClassName, nil)
+      end
+    end
+
+    # FXObject is the root
+    @root = classes["FXObject"]
+  end
+
+  def root
+    return @root
+  end
+end
+
+class BrowserWindow < FXMainWindow
+
+  def initialize(app)
+    # Call base class initializer first
+    super(app, "Browse", nil, nil, DECOR_ALL, 0, 0, 600, 400)
+
+    # Contents
+    contents = FXHorizontalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+
+    # Horizontal splitter
+    splitter = FXSplitter.new(contents, (LAYOUT_SIDE_TOP|LAYOUT_FILL_X|
+      LAYOUT_FILL_Y|SPLITTER_TRACKING|SPLITTER_HORIZONTAL))
+
+    # Create a sunken frame to hold the tree list
+    groupbox = FXGroupBox.new(splitter, "Classes",
+      LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE)
+    frame = FXHorizontalFrame.new(groupbox,
+      LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK)
+
+    # Create the empty tree list
+    @treeList = FXTreeList.new(frame, nil, 0,
+      (TREELIST_BROWSESELECT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|
+       TREELIST_ROOT_BOXES|LAYOUT_FILL_X|LAYOUT_FILL_Y))
+    @treeList.connect(SEL_COMMAND) do |sender, sel, item|
+      getApp().beginWaitCursor do
+        s = getInstanceMethods(item.to_s).join("\n")
+        @methodsText.text = s
+        s = getConstants(item.to_s).join("\n")
+        @constantsText.text = s
+      end
+    end
+
+    # Fill it up based on the tree contents
+    populateTree(@treeList, nil, ClassTree.new.root)
+
+    # Tabbed notebook on the right
+    tabBook = FXTabBook.new(splitter, nil, 0,
+      LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT)
+
+    tab1 = FXTabItem.new(tabBook, "Methods")
+    page1 = FXHorizontalFrame.new(tabBook, FRAME_THICK|FRAME_RAISED)
+    frame1 = FXHorizontalFrame.new(page1,
+      FRAME_THICK|FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @methodsText = FXText.new(frame1, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @methodsText.text = "List of methods goes here"
+    @methodsText.editable = false
+
+    tab2 = FXTabItem.new(tabBook, "Constants")
+    page2 = FXHorizontalFrame.new(tabBook, FRAME_THICK|FRAME_RAISED)
+    frame2 = FXHorizontalFrame.new(page2,
+      FRAME_THICK|FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @constantsText = FXText.new(frame2, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @constantsText.text = "List of constants goes here"
+    @constantsText.editable = false
+
+    # Cache of classname -> method and classname -> constants lists
+    @instanceMethods = {}
+    @classConstants = {}
+  end
+
+  # Recursively fill up the tree list
+  def populateTree(treeList, rootItem, rootNode)
+    rootNode.children.each do |childNode|
+      childItem = treeList.appendItem(rootItem, childNode.className)
+      populateTree(treeList, childItem, childNode)
+    end
+  end
+
+  # Create and show the main window
+  def create
+    super
+    @treeList.parent.parent.setWidth(@treeList.font.getTextWidth('MMMMMMMMMMMMMMMM'))
+    show(PLACEMENT_SCREEN)
+  end
+
+  # Returns an array of instance methods for the named class
+  def getInstanceMethods(className)
+    methods = @instanceMethods[className]
+    if methods.nil?
+      theClass = Fox.const_get(className)
+      methods = theClass.instance_methods.sort
+      @instanceMethods[className] = methods
+    end
+    methods
+  end
+
+  # Returns an array of constants for the named class
+  def getConstants(className)
+    constants = @classConstants[className]
+    if constants.nil?
+      klass = Fox.const_get(className)
+      constants = klass.constants
+      superklass = Fox.const_get(className)
+      if superklass
+        constants -= superklass.superclass.constants
+      else
+        constants -= klass.superclass.constants
+      end
+      constants.sort!
+      @classConstants[className] = constants
+    end
+    constants
+  end
+end
+
+if __FILE__ == $0
+  # Create a new application
+  application = FXApp.new("Browser", "FoxTest")
+
+  # Construct the main window
+  BrowserWindow.new(application)
+
+  # Create the windows
+  application.create
+
+  # Start event loop
+  application.run
+end
+

data/examples/button.rb

@@ -0,0 +1,168 @@
+#/usr/bin/env ruby
+
+require 'fox16'
+
+include Fox
+
+class ButtonWindow < FXMainWindow
+
+  def initialize(app)
+    # Invoke base class initialize first
+    super(app, "Button Test", :opts => DECOR_ALL, :x => 100, :y => 100)
+
+    # Create a tooltip
+    FXToolTip.new(self.getApp())
+
+    # Status bar
+    statusbar = FXStatusBar.new(self,
+      LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|STATUSBAR_WITH_DRAGCORNER)
+
+    # Controls on the right
+    controls = FXVerticalFrame.new(self,
+      LAYOUT_SIDE_RIGHT|LAYOUT_FILL_Y|PACK_UNIFORM_WIDTH)
+
+    # Separator
+    FXVerticalSeparator.new(self,
+      LAYOUT_SIDE_RIGHT|LAYOUT_FILL_Y|SEPARATOR_GROOVE)
+
+    # Contents
+    contents = FXHorizontalFrame.new(self,
+      LAYOUT_SIDE_LEFT|FRAME_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y|PACK_UNIFORM_WIDTH,
+      :padding => 20)
+
+    # Construct icon from a PNG file on disk
+    bigpenguin = loadIcon("bigpenguin.png")
+
+    # The button
+    @button = FXButton.new(contents,
+      "&This is a multi-line label on\na button to show off the full\n" +
+      "capabilities of the button object.\t" +
+      "It also has a tooltip\n(which, by the way, can be multi-line also).\t" +
+      "Here's a helpful message for the status line.",
+      bigpenguin,
+      :opts => FRAME_RAISED|FRAME_THICK|LAYOUT_CENTER_X|LAYOUT_CENTER_Y|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT,
+      :width => 300, :height => 200)
+
+    checkButton = FXCheckButton.new(controls, "Toolbar Style\tCool \"poppy\" style buttons")
+    checkButton.connect(SEL_COMMAND) do |sender, sel, checked|
+      if checked
+        @button.buttonStyle |= BUTTON_TOOLBAR
+        @button.frameStyle = FRAME_RAISED
+      else
+        @button.buttonStyle &= ~BUTTON_TOOLBAR
+        @button.frameStyle = FRAME_RAISED|FRAME_THICK
+      end
+    end
+
+    group1 = FXGroupBox.new(controls, "Horizontal Placement",
+      GROUPBOX_TITLE_CENTER|FRAME_RIDGE)
+    @group1_dt = FXDataTarget.new(2)
+    @group1_dt.connect(SEL_COMMAND) do
+      case @group1_dt.value
+        when 0
+          @button.iconPosition = (@button.iconPosition|ICON_BEFORE_TEXT) & ~ICON_AFTER_TEXT
+        when 1
+          @button.iconPosition = (@button.iconPosition|ICON_AFTER_TEXT) & ~ICON_BEFORE_TEXT
+        when 2
+          @button.iconPosition = (@button.iconPosition & ~ICON_AFTER_TEXT) & ~ICON_BEFORE_TEXT
+      end
+    end
+    FXRadioButton.new(group1, "Before Text", @group1_dt, FXDataTarget::ID_OPTION)
+    FXRadioButton.new(group1, "After Text",  @group1_dt, FXDataTarget::ID_OPTION + 1)
+    FXRadioButton.new(group1, "Centered",    @group1_dt, FXDataTarget::ID_OPTION + 2)
+
+    group2 = FXGroupBox.new(controls, "Vertical Placement",
+      GROUPBOX_TITLE_CENTER|FRAME_RIDGE)
+    @group2_dt = FXDataTarget.new(2)
+    @group2_dt.connect(SEL_COMMAND) do
+      case @group2_dt.value
+        when 0
+          @button.iconPosition = (@button.iconPosition|ICON_ABOVE_TEXT) & ~ICON_BELOW_TEXT
+        when 1
+          @button.iconPosition = (@button.iconPosition|ICON_BELOW_TEXT) & ~ICON_ABOVE_TEXT
+        when 2
+          @button.iconPosition = (@button.iconPosition & ~ICON_ABOVE_TEXT) & ~ICON_BELOW_TEXT
+      end
+    end
+    FXRadioButton.new(group2, "Above Text", @group2_dt, FXDataTarget::ID_OPTION)
+    FXRadioButton.new(group2, "Below Text", @group2_dt, FXDataTarget::ID_OPTION + 1)
+    FXRadioButton.new(group2, "Centered",   @group2_dt, FXDataTarget::ID_OPTION + 2)
+
+    group3 = FXGroupBox.new(controls, "Horizontal Justification",
+      GROUPBOX_TITLE_CENTER|FRAME_RIDGE)
+    @group3_dt = FXDataTarget.new(0)
+    @group3_dt.connect(SEL_COMMAND) do
+      case @group3_dt.value
+        when 0
+          @button.justify &= ~JUSTIFY_HZ_APART
+        when 1
+          @button.justify = (@button.justify & ~JUSTIFY_HZ_APART) | JUSTIFY_LEFT
+        when 2
+          @button.justify = (@button.justify & ~JUSTIFY_HZ_APART) | JUSTIFY_RIGHT
+        when 3
+          @button.justify |= JUSTIFY_HZ_APART
+       end
+    end
+    FXRadioButton.new(group3, "Center", @group3_dt, FXDataTarget::ID_OPTION)
+    FXRadioButton.new(group3, "Left",   @group3_dt, FXDataTarget::ID_OPTION + 1)
+    FXRadioButton.new(group3, "Right",  @group3_dt, FXDataTarget::ID_OPTION + 2)
+    FXRadioButton.new(group3, "Apart",  @group3_dt, FXDataTarget::ID_OPTION + 3)
+
+    group4 = FXGroupBox.new(controls, "Vertical Justification",
+      GROUPBOX_TITLE_CENTER|FRAME_RIDGE)
+    @group4_dt = FXDataTarget.new(0)
+    @group4_dt.connect(SEL_COMMAND) do
+      case @group4_dt.value
+        when 0
+          @button.justify &= ~JUSTIFY_VT_APART
+        when 1
+          @button.justify = (@button.justify & ~JUSTIFY_VT_APART) | JUSTIFY_TOP
+        when 2
+          @button.justify = (@button.justify & ~JUSTIFY_VT_APART) | JUSTIFY_BOTTOM
+        when 3
+          @button.justify |= JUSTIFY_VT_APART
+      end
+    end
+    FXRadioButton.new(group4, "Center", @group4_dt, FXDataTarget::ID_OPTION)
+    FXRadioButton.new(group4, "Top",    @group4_dt, FXDataTarget::ID_OPTION + 1)
+    FXRadioButton.new(group4, "Bottom", @group4_dt, FXDataTarget::ID_OPTION + 2)
+    FXRadioButton.new(group4, "Apart",  @group4_dt, FXDataTarget::ID_OPTION + 3)
+
+    quitButton = FXButton.new(controls, "&Quit", :opts => FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X)
+    quitButton.connect(SEL_COMMAND) { getApp().exit(0) }
+  end
+
+  # Load the named icon from a file
+  def loadIcon(filename)
+    begin
+      filename = File.join("icons", filename)
+      icon = nil
+      File.open(filename, "rb") do |f|
+        icon = FXPNGIcon.new(getApp(), f.read)
+      end
+      icon
+    rescue
+      raise RuntimeError, "Couldn't load icon: #{filename}"
+    end
+  end
+
+  def create
+    super
+    show(PLACEMENT_SCREEN)
+  end
+end
+
+if __FILE__ == $0
+  # Construct an application
+  application = FXApp.new("Button", "FoxTest")
+
+  # Construct the main window
+  ButtonWindow.new(application)
+
+  # Create the application
+  application.create
+
+  # Run it
+  application.run
+end
+