fxrubi 1.6.22.pre1-x86-mingw32

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
+