fxruby 1.6.15-x86-mswin32-60

data/examples/RAA.rb

@@ -0,0 +1,25 @@
+require 'soap/rpc/driver'
+require 'iRAA'
+
+module RAA
+  extend SOAP
+
+  class Driver
+    def initialize(server = 'http://raa.ruby-lang.org/soap/1.0/', proxy = nil)
+      @drv = SOAP::RPC::Driver.new(server, RAA::InterfaceNS)
+      @drv.httpproxy = proxy if proxy
+      @drv.mapping_registry = RAA::MappingRegistry
+      RAA::Methods.each do |name, *params|
+	@drv.add_method(name, params)
+      end
+    end
+
+    def setLogDev(logdev)
+      # ignored.
+    end
+
+    def method_missing(msg_id, *a, &b)
+      @drv.__send__(msg_id, *a, &b)
+    end
+  end
+end

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,72 @@
+#!/usr/bin/env ruby
+
+require 'fox16'
+require 'tranexp'
+
+include Fox
+
+TRANSLATIONS = {
+  "x" => "y"
+}
+
+class Babelfish < FXMainWindow
+
+  def initialize(app)
+    # Invoke base class initialize first
+    super(app, "Babelfish", :opts => DECOR_ALL, :width => 600, :height => 400)
+
+    @translator = Tranexp::Http.new
+    
+    # Controls area along the bottom
+    controlsFrame = FXHorizontalFrame.new(self,
+      LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X)
+    FXLabel.new(controlsFrame, "Translate from:")
+    @fromCombo = FXComboBox.new(controlsFrame, 15, :opts => COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK)
+    @fromCombo.numVisible = 6
+    FXLabel.new(controlsFrame, " to:")
+    @toCombo = FXComboBox.new(controlsFrame, 15, :opts => COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK)
+    @toCombo.numVisible = 6
+    Tranexp::Codes.constants.each do |lang|
+      @fromCombo.appendItem(lang)
+      @toCombo.appendItem(lang)
+    end
+    btn = FXButton.new(controlsFrame, "Translate", :opts => BUTTON_NORMAL|LAYOUT_RIGHT)
+    btn.connect(SEL_COMMAND) do
+      from = @fromCombo.getItemText(@fromCombo.currentItem)
+      to = @toCombo.getItemText(@toCombo.currentItem)
+      getApp().beginWaitCursor() do
+        @translatedText.text = @translator.translate(@sourceText.text, from, to)
+      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
+  FXApp.new("Babelfish", "FoxTest") do |app|
+    Babelfish.new(app)
+    app.create
+    app.run
+  end
+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
+