fxrubi 1.6.22.pre1-x86-mingw32

data/lib/fox16/dict.rb

@@ -0,0 +1,35 @@
+#
+# Adds some methods similar to those for Ruby's Hash class
+# to FOX's FXDict class.
+#
+module Fox
+  class FXDict
+    #
+    # Returns a new array populated with the keys from this dictionary.
+    #
+    def keys
+      ary = []
+      each_key { |k| ary << k }
+      ary
+    end
+
+    #
+    # Iterate over the keys in this dictionary.
+    #
+    def each_key
+      pos = first
+      while pos < self.getTotalSize()
+        yield key(pos)
+        pos = self.next(pos)
+      end
+    end
+    
+    #
+    # Returns +true+ if this dictionary contains no key-value pairs.
+    #
+    def empty?
+      self.size == 0
+    end
+  end
+end
+

data/lib/fox16/exceptions_for_fxerror.rb

@@ -0,0 +1,17 @@
+module Fox
+  FXWindow.subclasses.each do |klass|
+    klass.send(:alias_method, :create_without_parent_created_check, :create)
+    klass.send(:define_method, :create) do
+      unless parent.created?
+        raise RuntimeError, "trying to create window before creating parent window"
+      end
+      if owner && !owner.created?
+        raise RuntimeError, "trying to create window before creating owner window"
+      end
+      if visual.nil?
+        raise RuntimeError, "trying to create window without a visual"
+      end
+      create_without_parent_created_check
+    end
+  end
+end

data/lib/fox16/execute_nonmodal.rb

@@ -0,0 +1,70 @@
+module Fox
+  # Module to include in FXDialogBox to provide an easy nonmodal version
+  # of execute.
+  module FTNonModal
+
+    def initialize(*args)
+      super if defined?(super)
+      FXMAPFUNC(SEL_COMMAND, FXDialogBox::ID_CANCEL, :onCmdCancel)
+      FXMAPFUNC(SEL_COMMAND, FXDialogBox::ID_ACCEPT, :onCmdAccept)
+    end
+
+    #
+    # Creates and shows the dialog, and registers the associated block to be
+    # called when the dialog is closed. The block is passed a boolean argument
+    # which is true if and only if the dialog was accepted.
+    #
+    # For example:
+    #
+    #   dialogBox.execute_modal do |accepted|
+    #     if accepted
+    #       puts "Dialog accepted"
+    #     else
+    #       puts "Dialog cancelled"
+    #    end
+    #
+    def execute_modal(placement = PLACEMENT_CURSOR, &block)
+      @__FTNonModal_block = block
+      execute(placement)
+    end
+ 
+    #
+    # Creates and shows the dialog, and registers the associated block to be
+    # called when the dialog is closed. The block is passed a boolean argument
+    # which is true if and only if the dialog was accepted.
+    #
+    # For example:
+    #
+    #   dialogBox.execute_nonmodal do |accepted|
+    #     if accepted
+    #       puts "Dialog accepted"
+    #     else
+    #       puts "Dialog cancelled"
+    #    end
+    #
+    def execute_nonmodal(placement = PLACEMENT_CURSOR, &block)
+      @__FTNonModal_block = block
+      create
+      show placement
+    end
+
+    def onCmdCancel(*args) # :nodoc:
+      on_nonmodal_close(false)
+    end
+
+    def onCmdAccept(*args) # :nodoc:
+      on_nonmodal_close(true)
+    end
+
+    # Called when dialog is closed, with _accepted_ equal to +true+ if and
+    # only if the user accepted the dialog.
+    def on_nonmodal_close(accepted)
+      @__FTNonModal_block[accepted]
+
+      ##return 0 -- why isn't this enough to close window?
+      ## oh well, let's imitate FXTopWindow:
+      getApp().stopModal(self, accepted ? 1 : 0)
+      hide()
+    end
+  end
+end

data/lib/fox16/glgroup.rb

@@ -0,0 +1,166 @@
+begin
+  require 'opengl'
+rescue LoadError
+  # Can't use FXGLGroup since it depends on Ruby/OpenGL
+end
+
+module Fox
+  #
+  # A group of OpenGL objects
+  #
+  class FXGLGroup < FXGLObject
+
+    include Enumerable
+
+    FLT_MAX =  1.0e+20
+    FLT_MIN = -1.0e+20
+    
+    #
+    # Returns an initialized FXGLGroup instance
+    #
+    def initialize
+      super
+      @list = []
+    end
+    
+    #
+    # Return number of objects in this group.
+    #
+    def size
+      @list.size
+    end
+    
+    #
+    # Return child at position _pos_.
+    #
+    def [](pos)
+      @list[pos]
+    end
+    
+    #
+    # Set child at position _pos_ to _obj_.
+    #
+    def []=(pos, obj)
+      @list[pos] = obj
+    end
+
+    #
+    # Iterate over child objects
+    #
+    def each_child # :yields: childObject
+      @list.each { |child| yield child }
+      self
+    end
+
+    alias each each_child
+
+    #
+    # Return bounding box for this group (an FXRangef instance)
+    #
+    def bounds
+      box = nil
+      if @list.empty?
+        box = FXRangef.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+      else
+        box = FXRangef.new(FLT_MAX, -FLT_MAX, FLT_MAX, -FLT_MAX, FLT_MAX, -FLT_MAX)
+        @list.each { |obj| box.include!(obj.bounds) }
+      end
+      box
+    end
+    
+    #
+    # Draw this group into _viewer_ (an FXGLViewer instance).
+    #
+    def draw(viewer)
+      @list.each { |obj| obj.draw(viewer) }
+    end
+    
+    #
+    # Perform hit test in _viewer_ (an FXGLViewer instance).
+    #
+    def hit(viewer)
+#     GL.PushName(0xffffffff)
+      GL.PushName(1000000)
+      @list.each_with_index do |obj, i|
+        GL.LoadName(i)
+	obj.hit(viewer)
+      end
+      GL.PopName
+    end
+    
+    #
+    # Identify object by means of _path_.
+    #
+    def identify(path)
+      objIndex = path.shift
+      @list[objIndex].identify(path)
+    end
+
+    #
+    # Return +true+ if group can be dragged.
+    #
+    def canDrag
+      true
+    end
+    
+    #
+    # Drag group object around in _viewer_ (an FXGLViewer instance),
+    # from (_fx_, _fy_) to (_tx_, _ty_).
+    #
+    def drag(viewer, fx, fy, tx, ty)
+      @list.each { |obj| obj.drag(viewer, fx, fy, tx, ty) }
+    end
+    
+    #
+    # Insert child object (_obj_) at position _pos_.
+    #
+    def insert(pos, obj)
+      raise NotImplementedError
+    end
+    
+    #
+    # Prepend child object (_obj_).
+    #
+    def prepend(obj)
+      @list.unshift(obj)
+    end
+    
+    #
+    # Append child object
+    #
+    def append(obj)
+      @list << obj
+    end
+    
+    alias <<	append
+    
+    #
+    # Replace child object at position _pos_ with _obj_.
+    #
+    def replace(pos, obj)
+      @list[pos] = obj
+    end
+    
+    #
+    # If _obj_ is a reference to an FXGLObject in this group, remove the
+    # child object from the list. If _obj_ is an integer, remove the child
+    # object at that position from the list.
+    #
+    def remove(obj)
+      if obj.is_a? FXGLObject
+        @list.delete(obj)
+      else
+        @list.delete_at(obj)
+      end
+    end
+    
+    alias erase remove
+  
+    #
+    # Remove all children from this group.
+    #
+    def clear
+      @list.clear
+    end
+  end
+end

data/lib/fox16/glshapes.rb

@@ -0,0 +1,456 @@
+require 'opengl'
+
+module Fox
+
+  HANDLE_SIZE = 4.0
+
+  #
+  # OpenGL point object
+  #
+  class FXGLPoint < FXGLObject
+  
+    # Point position, in model coordinates (a 3-element array)
+    attr_accessor :pos
+    
+    #
+    # Returns an initialized FXGLPoint instance.
+    # If no arguments are passed to #new, the initial point position is
+    # (0.0, 0.0, 0.0). You can specify a different initial position by
+    # passing in the x, y and z coordinates individually:
+    #
+    #     aPoint = FXGLPoint.new(x, y, z)
+    #
+    # or as a 3-element array:
+    #
+    #     aPoint = FXGLPoint.new([x, y, z])
+    #
+    def initialize(*args)
+      super()
+      if args.length == 0
+        @pos = [0.0, 0.0, 0.0]
+      elsif args.length == 3
+        @pos = [args[0], args[1], args[2]]
+      else
+        @pos = args[0]
+      end
+    end
+    
+    #
+    # Return the bounding box (an FXRangef instance) for this point.
+    #
+    def bounds
+      FXRangef.new(@pos[0], @pos[0], @pos[1], @pos[1], @pos[2], @pos[2])
+    end
+    
+    #
+    # Draw this point into _viewer_ (an FXGLViewer instance).
+    #
+    def draw(viewer)
+      GL::Color(0.0, 0.0, 1.0)
+      GL::PointSize(HANDLE_SIZE)
+      GL::Begin(GL::POINTS)
+      GL::Vertex(@pos)
+      GL::End()
+    end
+    
+    #
+    # Perform hit test for this point in _viewer_ (an FXGLViewer instance).
+    #
+    def hit(viewer)
+      GL::Begin(GL::POINTS)
+      GL::Vertex(@pos)
+      GL::End()
+    end
+  end
+
+  #
+  # OpenGL line object
+  #
+  class FXGLLine < FXGLObject
+  
+    # Starting point for line [FXGLPoint]
+    attr_accessor :fm
+    
+    # End point for line [FXGLPoint]
+    attr_accessor :to
+    
+    #
+    # Return an initialized FXGLLine instance.
+    #
+    # If no arguments are passed to #new, the initial starting and ending
+    # points for the line are (-0.5, 0.0, 0.0) and (0.5, 0.0, 0.0), respectively.
+    # You can specify different initial start and end points by passing in
+    # another FXGLLine instance from which to copy the start and end point
+    # values, e.g.
+    #
+    #     aLine = FXGLLine.new(anotherLine)
+    #
+    # or by passing in the x, y and z coordinates individually:
+    #
+    #     aLine = FXGLLine.new(x0, y0, z0, x1, y1, z1)
+    #
+    def initialize(*args)
+      super()
+      if args.length == 0
+	@fm = FXGLPoint.new(-0.5, 0.0, 0.0)
+	@to = FXGLPoint.new( 0.5, 0.0, 0.0)
+      elsif args.length == 1
+	@fm = args[0].fm
+	@to = args[0].to
+      else
+	@fm = FXGLPoint.new(args[0], args[1], args[2])
+	@to = FXGLPoint.new(args[3], args[4], args[5])
+      end
+    end
+    
+    #
+    # Return the bounding box (an FXRangef instance) for this line.
+    #
+    def bounds
+      FXRangef.new([@fm.pos[0], @to.pos[0]].min,
+                  [@fm.pos[0], @to.pos[0]].max,
+                  [@fm.pos[1], @to.pos[1]].min,
+                  [@fm.pos[1], @to.pos[1]].max,
+                  [@fm.pos[2], @to.pos[2]].min,
+                  [@fm.pos[2], @to.pos[2]].max)
+    end
+    
+    #
+    # Draw this line into _viewer_ (an FXGLViewer instance).
+    #
+    def draw(viewer)
+      GL::Color(1.0, 0.0, 0.0)
+      GL::PointSize(HANDLE_SIZE)
+      GL::Begin(GL::LINES)
+      GL::Vertex(@fm.pos)
+      GL::Vertex(@to.pos)
+      GL::End()
+    end
+    
+    #
+    # Perform hit-test for this line in _viewer_ (an FXGLViewer instance).
+    #
+    def hit(viewer)
+      GL::Begin(GL::LINES)
+      GL::Vertex(@fm.pos)
+      GL::Vertex(@to.pos)
+      GL::End()
+    end
+  end
+
+  #
+  # OpenGL cube object
+  #
+  class FXGLCube < FXGLShape
+
+    # Cube width [Float]
+    attr_accessor :width
+    
+    # Cube height [Float]
+    attr_accessor :height
+    
+    # Cube depth [Float]
+    attr_accessor :depth
+
+    #
+    # Return an initialized FXGLCube instance.
+    #
+    # One option is to initialize the cube with a specified origin,
+    # width, height and depth:
+    #
+    #     aCube = FXGLCube.new(x, y, z, w, h, d)
+    #
+    # If left unspecified, the width (_w_), height (_h_) and depth (_d_)
+    # default to 1.0.
+    #
+    # Another option is to initialize the cube with a specified origin,
+    # width, height, depth and material:
+    #
+    #     aCube = FXGLCube.new(x, y, z, w, h, d, material)
+    #
+    # where the _material_ is an FXMaterial instance.
+    #
+    def initialize(*args)
+      if args.length == 7
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
+              args[6], args[6])
+      else
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
+      end
+      @width = args[3] ? args[3] : 1.0
+      @height = args[4] ? args[4] : 1.0
+      @depth = args[5] ? args[5] : 1.0
+      setRange(FXRangef.new(-0.5*@width, 0.5*@width,
+                           -0.5*@height, 0.5*@height,
+                           -0.5*@depth, 0.5*@depth))
+    end
+
+    #
+    # Draws this cube into _viewer_ (an FXGLViewer instance).
+    #
+    def drawshape(viewer)
+      xmin, xmax = -0.5*@width, 0.5*@width
+      ymin, ymax = -0.5*@height, 0.5*@height
+      zmin, zmax = -0.5*@depth, 0.5*@depth
+
+      # Draw low face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(0.0, 0.0, -1.0)
+	GL::Vertex(xmin, ymin, zmin)
+	GL::Vertex(xmin, ymax, zmin)
+	GL::Vertex(xmax, ymin, zmin)
+	GL::Vertex(xmax, ymax, zmin)
+      GL::End()
+
+      # Draw east face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(1.0, 0.0, 0.0)
+	GL::Vertex(xmax, ymin, zmin)
+	GL::Vertex(xmax, ymax, zmin)
+	GL::Vertex(xmax, ymin, zmax)
+	GL::Vertex(xmax, ymax, zmax)
+      GL::End()
+
+      # Draw high face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(0.0, 0.0, 1.0)
+	GL::Vertex(xmax, ymin, zmax)
+	GL::Vertex(xmax, ymax, zmax)
+	GL::Vertex(xmin, ymin, zmax)
+	GL::Vertex(xmin, ymax, zmax)
+      GL::End()
+
+      # Draw west face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(-1.0, 0.0, 0.0)
+	GL::Vertex(xmin, ymin, zmax)
+	GL::Vertex(xmin, ymax, zmax)
+	GL::Vertex(xmin, ymin, zmin)
+	GL::Vertex(xmin, ymax, zmin)
+      GL::End()
+
+      # Draw north face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(0.0, 1.0, 0.0)
+	GL::Vertex(xmin, ymax, zmin)
+	GL::Vertex(xmin, ymax, zmax)
+	GL::Vertex(xmax, ymax, zmin)
+	GL::Vertex(xmax, ymax, zmax)
+      GL::End()
+
+      # Draw south face
+      GL::Begin(GL::TRIANGLE_STRIP)
+	GL::Normal(0.0, -1.0, 0.0)
+	GL::Vertex(xmin, ymin, zmax)
+	GL::Vertex(xmin, ymin, zmin)
+	GL::Vertex(xmax, ymin, zmax)
+	GL::Vertex(xmax, ymin, zmin)
+      GL::End()
+    end
+  end
+
+  #
+  # OpenGL cone object
+  #
+  class FXGLCone < FXGLShape
+    # Cone fidelity
+    SLICES_NUMBER = 20
+    STACKS_NUMBER = 20
+    LOOPS = 4
+
+    # Cone height [Float]
+    attr_accessor :height
+    
+    # Cone base radius [Float]
+    attr_accessor :radius
+    
+    # Number of slices (default is 20) [Integer]
+    attr_accessor :slices
+    
+    # Number of stacks (default is 20) [Integer]
+    attr_accessor :stacks
+    
+    # Number of loops (default is 4) [Integer]
+    attr_accessor :loops
+
+    #
+    # Returns an initialized FXGLCone instance.
+    #
+    # One option is to initialize the cone with a specified origin,
+    # height and radius:
+    #
+    #     aCone = FXGLCone.new(x, y, z, h, r)
+    #
+    # If left unspecified, the height (_h_) and radius (_r_) default to 1.0.
+    #
+    # Another option is to initialize the cone with a specified origin,
+    # height, radius and material:
+    #
+    #     aCone = FXGLCone.new(x, y, z, h, r, material)
+    #
+    # where the _material_ is an FXMaterial instance.
+    #
+    def initialize(*args)
+      if args.length == 5
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
+      elsif args.length == 6
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
+              args[5], args[5])
+      end
+      @height = args[3] ? args[3] : 1.0
+      @radius = args[4] ? args[4] : 1.0
+      @slices = SLICES_NUMBER
+      @stacks = STACKS_NUMBER
+      @loops  = LOOPS
+      setRange(FXRangef.new(-@radius, @radius, 0, @height, -@radius, @radius))
+    end
+    
+    #
+    # Draw this cone into _viewer_ (an FXGLViewer instance).
+    #
+    def drawshape(viewer)
+      quad = GLU::NewQuadric()
+      GLU::QuadricDrawStyle(quad, GLU::FILL)
+      GL::PushMatrix()
+      GL::Rotate(-90, 1, 0, 0)
+      GLU::Cylinder(quad, @radius, 0, @height, @slices, @stacks)
+      GLU::QuadricOrientation(quad, GLU::INSIDE)
+      GLU::Disk(quad, 0, @radius, @slices, @loops)
+      GLU::DeleteQuadric(quad)
+      GL::PopMatrix()
+    end
+  end
+
+  #
+  # OpenGL cylinder object
+  #
+  class FXGLCylinder < FXGLShape
+    # Cylinder fidelity
+    SLICES_NUMBER = 20
+    STACKS_NUMBER = 20
+    LOOPS = 4
+
+    # Cylinder height [Float]
+    attr_accessor :height
+    
+    # Cylinder radius [Float]
+    attr_accessor :radius
+    
+    # Number of slices (default is 20) [Integer]
+    attr_accessor :slices
+    
+    # Number of stacks (default is 20) [Integer]
+    attr_accessor :stacks
+    
+    # Number of loops (default is 4) [Integer]
+    attr_accessor :loops
+
+    #
+    # Returns an initialized FXGLCylinder instance.
+    #
+    # One option is to initialize the cylinder with a specified origin,
+    # height and radius:
+    #
+    #     aCylinder = FXGLCylinder.new(x, y, z, h, r)
+    #
+    # If left unspecified, the height (_h_) and radius (_r_) default to 1.0.
+    #
+    # Another option is to initialize the cylinder with a specified origin,
+    # height, radius and material:
+    #
+    #     aCylinder = FXGLCylinder.new(x, y, z, h, r, material)
+    #
+    # where the _material_ is an FXMaterial instance.
+    #
+    def initialize(*args)
+      if args.length == 5
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
+      else
+	super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
+              args[5], args[5])
+      end
+      @height = args[3] ? args[3] : 1.0
+      @radius = args[4] ? args[4] : 1.0
+      @slices = SLICES_NUMBER
+      @stacks = STACKS_NUMBER
+      @loops  = LOOPS
+      setRange(FXRangef.new(-@radius, @radius, 0, @height, -@radius, @radius))
+    end
+    
+    #
+    # Draw this cylinder into _viewer_ (an FXGLViewer instance).
+    #
+    def drawshape(viewer)
+      quad = GLU::NewQuadric()
+      GLU::QuadricDrawStyle(quad, GLU::FILL)
+      GL::PushMatrix()
+      GL::Rotate(-90, 1, 0, 0)
+      GLU::Cylinder(quad, @radius, @radius, @height, @slices, @stacks)
+      GLU::QuadricOrientation(quad, GLU::INSIDE)
+      GLU::Disk(quad, 0, @radius, @slices, @loops)
+      GL::Translate(0, 0, @height)
+      GLU::QuadricOrientation(quad, GLU::OUTSIDE)
+      GLU::Disk(quad, 0, @radius, @slices, @loops)
+      GL::PopMatrix()
+      GLU::DeleteQuadric(quad)
+    end
+  end
+
+  #
+  # OpenGL sphere object
+  #
+  class FXGLSphere < FXGLShape
+    # Sphere fidelity
+    SLICES_NUMBER = 20
+    STACKS_NUMBER = 20
+
+    # Sphere radius [Float]
+    attr_accessor :radius
+    
+    # Number of slices (default is 20) [Integer]
+    attr_accessor :slices
+    
+    # Number of stacks (default is 20) [Integer]
+    attr_accessor :stacks
+
+    #
+    # Returns an initialized FXGLSphere instance.
+    #
+    # One option is to initialize the sphere with a specified origin and
+    # radius:
+    #
+    #     aSphere = FXGLSphere.new(x, y, z, r)
+    #
+    # If left unspecified, the radius (_r_) defaults to 1.0.
+    #
+    # Another option is to initialize the sphere with a specified origin,
+    # radius and material:
+    #
+    #     aSphere = FXGLSphere.new(x, y, z, r, material)
+    #
+    # where the _material_ is an FXMaterial instance.
+    #
+    def initialize(*args)
+      if args.length == 4
+        super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE)
+      else
+        super(args[0], args[1], args[2], SHADING_SMOOTH|STYLE_SURFACE,
+        args[4], args[4])
+      end
+      @radius = args[3] ? args[3] : 1.0
+      @slices = SLICES_NUMBER
+      @stacks = STACKS_NUMBER
+      setRange(FXRangef.new(-@radius, @radius, -@radius, @radius, -@radius, @radius))
+    end
+    
+    #
+    # Draw this sphere into _viewer_ (an FXGLViewer instance).
+    #
+    def drawshape(viewer)
+      quad = GLU::NewQuadric()
+      GLU::QuadricDrawStyle(quad, GLU::FILL)
+      GLU::Sphere(quad, @radius, @slices, @stacks)
+      GLU::DeleteQuadric(quad)
+    end
+  end
+end