ruby-processing 1.0.5 → 1.0.6

data/CHANGELOG

@@ -1,3 +1,11 @@
+v1.0.6 Inner Classes...
+  * Java-style inner classes. Any inner class of a sketch will now have the 
+    Processing methods and constants proxied down for convenience.
+  * Sketches with tiny sizes get displayed in a nicer fashion.
+  * New Blue Logo: Ruby-Processing, literally.
+  * Moumar contributed a patch for the control_panel library, allowing your
+    sliders and buttons to have an initial value.
+    
 v1.0.5 Spring Cleaning...
   * The "Learning Processing" examples are now a separate project, a 
     long-merited change. They'll grow up on their own at 

data/lib/ruby-processing.rb

@@ -14,7 +14,7 @@ require 'ruby-processing/helpers/numeric'
 
 # The top-level namespace, a home for all Ruby-Processing classes.
 module Processing
-  VERSION = [1,0,5] unless defined? Processing::VERSION
+  VERSION = [1,0,6] unless defined? Processing::VERSION
   
   # Returns the current version of Ruby-Processing.
   def self.version

data/lib/ruby-processing/app.rb

@@ -45,11 +45,9 @@ module Processing
       :key_typed      => :keyTyped
     }
     
-    # Override the default width and height to make them a little larger.
-    DEFAULT_WIDTH = 200
-    DEFAULT_HEIGHT = 200
-
 
+    # When certain special methods get added to the sketch, we need to let
+    # Processing call them by their expected Java names.
     def self.method_added(method_name) #:nodoc:
       if METHODS_TO_WATCH_FOR.keys.include?(method_name)
         alias_method METHODS_TO_WATCH_FOR[method_name], method_name
@@ -176,11 +174,12 @@ module Processing
       proxy_java_fields
       set_sketch_path unless online?
       make_accessible_to_the_browser if online?
-      @width  = options[:width] || DEFAULT_WIDTH
-      @height = options[:height] || DEFAULT_HEIGHT
-      @title  = options[:title] || File.basename(Processing::SKETCH_PATH, '.rb').titleize
-      @render_mode  ||= JAVA2D
-      @@full_screen ||= options[:full_screen]
+      default_title = File.basename(Processing::SKETCH_PATH).sub(/(\.rb|\.pde)$/, '').titleize
+      @width  = options[:width]   ||  DEFAULT_WIDTH
+      @height = options[:height]  ||  DEFAULT_HEIGHT
+      @title  = options[:title]   ||  default_title
+      @render_mode                ||= JAVA2D
+      @@full_screen               ||= options[:full_screen]
       self.init
       determine_how_to_display
     end
@@ -189,6 +188,7 @@ module Processing
     # Make sure we set the size if we set it before we start the animation thread.
     def start
       self.size(@width, @height)
+      mix_proxy_into_inner_classes
       super()
     end
 
@@ -309,9 +309,9 @@ module Processing
     end
     
     
-    # Is the sketch done displaying itself?
-    def done_displaying?
-      @done_displaying
+    # Is the sketch finished?
+    def finished?
+      @declared_fields['finished'].value(java_self)
     end
     
 
@@ -351,15 +351,28 @@ module Processing
     # some methods. Add to this list as needed.
     def proxy_java_fields
       @declared_fields = {}
-      fields = %w(sketchPath key frameRate defaultSize)
+      fields = %w(sketchPath key frameRate defaultSize finished)
       fields.each {|f| @declared_fields[f] = java_class.declared_field(f) }
     end
     
     
+    # Mix the Processing::Proxy into any inner classes defined for the
+    # sketch, attempting to mimic the behavior of Java's inner classes.
+    def mix_proxy_into_inner_classes
+      unwanted = /Java::ProcessingCore/
+      klass = Processing::App.sketch_class
+      klass.constants.each do |name|
+        const = klass.const_get name
+        next if const.class != Class || const.to_s.match(unwanted)
+        const.class_eval 'include Processing::Proxy'
+      end
+    end
+    
+    
     # Tests to see which display method should run.
     def determine_how_to_display
       # Wait for init to get its grey tracksuit on and run a few laps.
-      sleep 0.02 while default_size? && !@@full_screen
+      sleep 0.02 while default_size? && !finished? && !@@full_screen
       
       if online?
         display_in_an_applet
@@ -376,7 +389,6 @@ module Processing
     end
     
     
-    # Go full screen, if possible
     def display_full_screen(display)
       @frame = java.awt.Frame.new(display.default_configuration)
       mode = display.display_mode
@@ -396,12 +408,17 @@ module Processing
 
     def display_in_a_window
       @frame = javax.swing.JFrame.new(@title)
-      @frame.add(self)
+      @frame.set_layout nil
+      @frame.add self
       @frame.pack
       @frame.set_default_close_operation(javax.swing.JFrame::EXIT_ON_CLOSE)
       @frame.set_resizable(false)
-      # Plus 22 for the height of the window's title bar
-      @frame.set_size(width, height + 22)
+      ins           = @frame.get_insets
+      hpad, vpad    = ins.left + ins.right, ins.top + ins.bottom
+      frame_width   = [width, MIN_WINDOW_WIDTH].max + hpad
+      frame_height  = [height, MIN_WINDOW_HEIGHT].max + vpad
+      @frame.set_size(frame_width, frame_height)
+      set_bounds((frame_width - width) / 2.0, (frame_height - vpad - height) / 2.0, width, height)
       @frame.show
     end
 
@@ -429,5 +446,53 @@ module Processing
       window.set_member('ruby', ruby)
     end
 
-  end
-end
+  end # Processing::App
+  
+  
+  # This module will get automatically mixed in to any inner class of 
+  # a Processing::App, in order to mimic Java's inner classes, which have
+  # unfettered access to the methods defined in the surrounding class.
+  module Proxy
+    
+    # Generate the list of method names that we'd like to proxy for inner classes. 
+    # Nothing camelCased, nothing __internal__, just the Processing API.
+    def self.desired_method_names
+      bad_method = /__/    # Internal JRuby methods.
+      unwanted = PApplet.superclass.instance_methods + Object.instance_methods
+      methods = Processing::App.public_instance_methods
+      methods.reject {|m| unwanted.include?(m) || bad_method.match(m) }
+    end
+      
+    
+    # Proxy methods through to the sketch. Perhaps extend this to support blocks?
+    def self.proxy_methods
+      code = desired_method_names.inject('') do |code, method|
+        code << <<-EOS
+          def #{method}(*args)                # def rect(*args)
+            $app.#{method} *args              #   $app.rect *args
+          end                                 # end
+        EOS
+      end
+      module_eval(code, "Processing::Proxy", 1)
+    end
+    
+    
+    # Proxy the sketch's constants on to the inner classes.
+    def self.proxy_constants
+      Processing::App.constants.each do |name|
+        Processing::Proxy.const_set(name, Processing::App.const_get(name))
+      end
+    end
+    
+    
+    # Don't do all of the work unless we have an inner class that needs it.
+    def self.included(inner_class)
+      return if @already_defined
+      proxy_methods
+      proxy_constants
+      @already_defined = true
+    end
+    
+  end # Processing::Proxy
+  
+end # Processing

data/lib/ruby-processing/exporters/base_exporter.rb

@@ -8,7 +8,7 @@ module Processing
   class BaseExporter
     include FileUtils
     
-    DEFAULT_DIMENSIONS = {'width' => 200, 'height' => 200}
+    DEFAULT_DIMENSIONS = {'width' => '100', 'height' => '100'}
     DEFAULT_DESCRIPTION = ''
     
     # Returns the filepath, basename, and directory name of the sketch.

data/lib/ruby-processing/runners/base.rb

@@ -28,7 +28,7 @@ module Processing
   def self.load_and_run_sketch
     source = self.read_sketch_source
     has_sketch = !!source.match(/^[^#]*< Processing::App/)
-    has_methods = !!source.match(/^[^#]*def setup/)
+    has_methods = !!source.match(/^[^#]*(def\s+setup|def\s+draw)/)
     
     if has_sketch
       load Processing::SKETCH_PATH

data/lib/ruby-processing/runners/watch.rb

@@ -49,7 +49,7 @@ module Processing
       return unless app
       app.no_loop
       # Wait for the animation thread to finish rendering
-      sleep 0.05
+      sleep 0.075
       app.close
       constant_names = app.class.to_s.split(/::/)
       app_class_name = constant_names.pop

data/lib/templates/applet/index.html.erb

@@ -24,11 +24,14 @@
       padding: 0;
     }
     #container {
-      width: <%= @width + 14 %>px;
+      width: <%= [@width.to_i, 200].max + 14 %>px;
       margin: 0 auto;
       margin-top: 20px;
+      text-align: center;
     }
     #the_applet {
+      margin: 0 auto;
+      width: <%= @width.to_i %>px;
       padding: 6px; 
       padding-top: 7px; padding-bottom: 2px;
       background: #262626 url(images/top.png) top left repeat-x;
@@ -42,7 +45,7 @@
     }
     #description {
       font-size: 12px;
-      width: <%= @width - 16 if @width %>px;
+      width: <%= [@width.to_i, 200].max - 16 %>px;
       padding: 7px 15px 7px 15px;
       background: #111;
       text-align: justify;
@@ -74,7 +77,8 @@
       <param name="archive" value="<%= @file_list %>" />
       <param name="jruby.eval" value="ARGV[0] = '<%= @main_file %>'; require 'ruby-processing/runners/run.rb'" />
       <param name="image" value="images/ruby.jpg" />
-      <param name="boxbgcolor" value="#000000" />   
+      <param name="centerimage" value="true" /> 
+      <param name="boxmessage" value="Loading <%= @title %>..." />
       <param name="lang" value="en" />
       <param name="mayscript" value="true" />
       <param name="scriptable" value="true" />

data/library/control_panel/control_panel.rb

@@ -3,11 +3,12 @@
 # These controls will set instance variables on the sketches.
 
 # You can make sliders, checkboxes, buttons, and drop-down menus.
+# (optionally) pass the range and default value.
 
 module ControlPanel
 
   class Slider < javax.swing.JSlider
-    def initialize(name, range, control_panel, proc=nil)
+    def initialize(control_panel, name, range, initial_value, proc=nil)
       min, max = range.begin * 100, range.end * 100
       super(min, max)
       set_minor_tick_spacing((max - min).abs / 10)
@@ -20,6 +21,8 @@ module ControlPanel
         $app.instance_variable_set("@#{name}", value) unless value.nil?
         proc.call(value) if proc
       end
+      set_value(initial_value ? initial_value*100 : min)
+      fire_state_changed
     end
     
     def value
@@ -35,7 +38,7 @@ module ControlPanel
   
   
   class Menu < javax.swing.JComboBox  
-    def initialize(name, elements, control_panel, proc=nil)
+    def initialize(control_panel, name, elements, initial_value, proc=nil)
       super(elements.to_java(:String))
       set_preferred_size(java.awt.Dimension.new(190, 30))
       control_panel.add_element(self, name)
@@ -43,6 +46,7 @@ module ControlPanel
         $app.instance_variable_set("@#{name}", value) unless value.nil?
         proc.call(value) if proc
       end
+      set_selected_index(initial_value ? elements.index(initial_value) : 0)
     end
     
     def value
@@ -52,7 +56,7 @@ module ControlPanel
   
   
   class Checkbox < javax.swing.JCheckBox
-    def initialize(name, control_panel, proc=nil)
+    def initialize(control_panel, name, proc=nil)
       @control_panel = control_panel
       super(name.to_s)
       set_preferred_size(java.awt.Dimension.new(190, 64))
@@ -71,7 +75,7 @@ module ControlPanel
   
   
   class Button < javax.swing.JButton
-    def initialize(name, control_panel, proc=nil)
+    def initialize(control_panel, name, proc=nil)
       super(name.to_s)
       set_preferred_size(java.awt.Dimension.new(170, 64))
       control_panel.add_element(self, name, false, true)
@@ -99,7 +103,7 @@ module ControlPanel
       set_resizable false
       # Need to wait for the sketch to finish sizing...
       Thread.new do
-        sleep 0.2 while $app.default_size? || !$app.done_displaying?
+        sleep 0.2 while $app.default_size?
         set_location($app.width + 10, 0)
         show
       end
@@ -120,20 +124,21 @@ module ControlPanel
       dispose
     end
     
-    def slider(name, range=0..100, &block)
-      slider = Slider.new(name, range, self, block || nil)
+    def slider(name, range=0..100, initial_value = nil, &block)
+      slider = Slider.new(self, name, range, initial_value, block || nil)
     end
 
-    def menu(name, *elements, &block)
-      menu = Menu.new(name, elements, self, block || nil)
+    def menu(name, elements, initial_value = nil, &block)
+      menu = Menu.new(self, name, elements, initial_value, block || nil)
     end
     
-    def checkbox(name, &block)
-      checkbox = Checkbox.new(name, self, block || nil)
+    def checkbox(name, initial_value = nil, &block)
+      checkbox = Checkbox.new(self, name, block || nil)
+      checkbox.do_click if initial_value == true
     end
     
     def button(name, &block)
-      button = Button.new(name, self, block || nil)
+      button = Button.new(self, name, block || nil)
     end
   end
   
@@ -150,4 +155,4 @@ module ControlPanel
 end
 
 
-Processing::App.send :include, ControlPanel::InstanceMethods
+Processing::App.send :include, ControlPanel::InstanceMethods

data/samples/circle_collision.rb

@@ -1,52 +1,45 @@
 # Based on http://processing.org/learning/topics/circlecollision.html
 # by Joe Holt
 
-require 'ruby-processing'
-
-class Vect2D
-  attr_accessor :vx, :vy
-  def initialize(vx = 0.0, vy = 0.0)
-    @vx = vx
-    @vy = vy
-  end
-end
-
-
-class Ball
-  attr_accessor :x, :y, :r, :m, :vec
-  def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
-    @x = x
-    @y = y
-    @r = r
-    @m = r*0.1
-    @vec = vec
-  end
-
-  def draw
-    r = @r * 2
-    P.ellipse @x, @y, r, r
-    @px = @x
-    @py = @y
-  end
-
-  def erase
-    r = @r * 2
-    P.rect @px, @py, r, r
-  end
-end
-
-
 class Sketch < Processing::App
+  
+  # This inner class demonstrates the use of Ruby-Processing's emulation of
+  # Java inner classes. The Balls are able to call Processing::App methods.
+  class Ball
+    attr_accessor :x, :y, :r, :m, :vec
+    def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
+      @x, @y, @r = x, y, r
+      @m = r * 0.1
+      @vec = vec
+    end
+    
+    def move
+      @x += @vec.x
+      @y += @vec.y
+    end
+  
+    def draw
+      r = @r * 2
+      ellipse @x, @y, r, r
+      @px, @py = @x, @y
+    end
+  
+    def erase
+      r = @r * 2
+      rect @px, @py, r, r
+    end
+  end
+  
 
   def setup
     smooth
-    noStroke
-    frameRate 30
-    rectMode RADIUS
+    no_stroke
+    frame_rate 30
+    rect_mode RADIUS
 
     @balls = []
-    5.times { @balls << Ball.new(10, Vect2D.new(2.15, -1.35), *emptySpace(15)) }
-    2.times { @balls << Ball.new(40, Vect2D.new(-1.65, 0.42), *emptySpace(45)) }
+    5.times { @balls << Ball.new(10, PVector.new(2.15, -1.35), *empty_space(15)) }
+    2.times { @balls << Ball.new(40, PVector.new(-1.65, 0.42), *empty_space(45)) }
 
     @frame_time = nil
     @frame_count = 0
@@ -55,9 +48,7 @@ class Sketch < Processing::App
 
   def draw
     t = Time.now
-    if @frame_time
-        fps = 1.0 / (t - @frame_time)
-    end
+    fps = 1.0 / (t - @frame_time) if @frame_time
     @frame_time = t
     @frame_count += 1
 
@@ -72,19 +63,17 @@ class Sketch < Processing::App
     # move the balls 
     fill 240
     @balls.each do |ball|
-      ball.x += ball.vec.vx
-      ball.y += ball.vec.vy
+      ball.move
       ball.draw
-      checkBoundaryCollision ball
+      check_boundary_collision ball
     end
-    checkObjectCollisions
-    1 * 20
+    check_object_collisions
   end
 
 
-  def emptySpace(r)
+  def empty_space(r)
     x = y = nil
-    while !x || !emptySpace?(x, y, r) do
+    while !x || !empty_space?(x, y, r) do
       x = rand(width)
       y = rand(height)
     end
@@ -92,7 +81,7 @@ class Sketch < Processing::App
   end
 
 
-  def emptySpace?(x, y, r)
+  def empty_space?(x, y, r)
     @balls.each do |ball|
       vx = x - ball.x
       vy = y - ball.y
@@ -103,7 +92,7 @@ class Sketch < Processing::App
   end
 
 
-  def checkObjectCollisions
+  def check_object_collisions
 
     (0...(@balls.length)).each do |ia|
       ((ia+1)...(@balls.length)).each do |ib|
@@ -112,15 +101,15 @@ class Sketch < Processing::App
         bb = @balls[ib]
   
         # get distances between the balls components
-        bVect = Vect2D.new
-        bVect.vx = bb.x - ba.x
-        bVect.vy = bb.y - ba.y
+        bVect = PVector.new
+        bVect.x = bb.x - ba.x
+        bVect.y = bb.y - ba.y
 
         # calculate magnitude of the vector separating the balls
-        bVectMag = sqrt(bVect.vx * bVect.vx + bVect.vy * bVect.vy)
+        bVectMag = sqrt(bVect.x * bVect.x + bVect.y * bVect.y)
         next if bVectMag >= ba.r + bb.r
         # get angle of bVect
-        theta  = atan2(bVect.vy, bVect.vx)
+        theta  = atan2(bVect.y, bVect.x)
         # precalculate trig values
         sine = sin(theta)
         cosine = cos(theta)
@@ -134,32 +123,32 @@ class Sketch < Processing::App
         # bTemp[0].x and bTemp[0].y will initialize
         # automatically to 0.0, which is what you want
         # since bb will rotate around ba
-        bTemp[1].x  = cosine * bVect.vx + sine * bVect.vy
-        bTemp[1].y  = cosine * bVect.vy - sine * bVect.vx
+        bTemp[1].x  = cosine * bVect.x + sine * bVect.y
+        bTemp[1].y  = cosine * bVect.y - sine * bVect.x
 
         # rotate Temporary velocities
-        vTemp = [Vect2D.new, Vect2D.new]
-        vTemp[0].vx  = cosine * ba.vec.vx + sine * ba.vec.vy
-        vTemp[0].vy  = cosine * ba.vec.vy - sine * ba.vec.vx
-        vTemp[1].vx  = cosine * bb.vec.vx + sine * bb.vec.vy
-        vTemp[1].vy  = cosine * bb.vec.vy - sine * bb.vec.vx
+        vTemp = [PVector.new, PVector.new]
+        vTemp[0].x  = cosine * ba.vec.x + sine * ba.vec.y
+        vTemp[0].y  = cosine * ba.vec.y - sine * ba.vec.x
+        vTemp[1].x  = cosine * bb.vec.x + sine * bb.vec.y
+        vTemp[1].y  = cosine * bb.vec.y - sine * bb.vec.x
 
         # Now that velocities are rotated, you can use 1D
         # conservation of momentum equations to calculate 
         # the final velocity along the x-axis.
-        vFinal = [Vect2D.new, Vect2D.new]
+        vFinal = [PVector.new, PVector.new]
         # final rotated velocity for ba
-        vFinal[0].vx = ((ba.m - bb.m) * vTemp[0].vx + 2 * bb.m * 
-          vTemp[1].vx) / (ba.m + bb.m)
-        vFinal[0].vy = vTemp[0].vy
+        vFinal[0].x = ((ba.m - bb.m) * vTemp[0].x + 2 * bb.m * 
+          vTemp[1].x) / (ba.m + bb.m)
+        vFinal[0].y = vTemp[0].y
         # final rotated velocity for ba
-        vFinal[1].vx = ((bb.m - ba.m) * vTemp[1].vx + 2 * ba.m * 
-          vTemp[0].vx) / (ba.m + bb.m)
-        vFinal[1].vy = vTemp[1].vy
+        vFinal[1].x = ((bb.m - ba.m) * vTemp[1].x + 2 * ba.m * 
+          vTemp[0].x) / (ba.m + bb.m)
+        vFinal[1].y = vTemp[1].y
 
         # hack to avoid clumping
-        bTemp[0].x += vFinal[0].vx
-        bTemp[1].x += vFinal[1].vx
+        bTemp[0].x += vFinal[0].x
+        bTemp[1].x += vFinal[1].x
 
         # Rotate ball positions and velocities back
         # Reverse signs in trig expressions to rotate 
@@ -178,36 +167,34 @@ class Sketch < Processing::App
         ba.y = ba.y + bFinal[0].y
 
         # update velocities
-        ba.vec.vx = cosine * vFinal[0].vx - sine * vFinal[0].vy
-        ba.vec.vy = cosine * vFinal[0].vy + sine * vFinal[0].vx
-        bb.vec.vx = cosine * vFinal[1].vx - sine * vFinal[1].vy
-        bb.vec.vy = cosine * vFinal[1].vy + sine * vFinal[1].vx
+        ba.vec.x = cosine * vFinal[0].x - sine * vFinal[0].y
+        ba.vec.y = cosine * vFinal[0].y + sine * vFinal[0].x
+        bb.vec.x = cosine * vFinal[1].x - sine * vFinal[1].y
+        bb.vec.y = cosine * vFinal[1].y + sine * vFinal[1].x
       end
     end
 
   end
 
 
-  def checkBoundaryCollision(ball)
-
+  def check_boundary_collision(ball)
     if ball.x > width-ball.r
       ball.x = width-ball.r
-      ball.vec.vx *= -1
+      ball.vec.x *= -1
     elsif ball.x < ball.r
       ball.x = ball.r
-      ball.vec.vx *= -1
+      ball.vec.x *= -1
     end
     if ball.y > height-ball.r
       ball.y = height-ball.r
-      ball.vec.vy *= -1
+      ball.vec.y *= -1
     elsif ball.y < ball.r
       ball.y = ball.r
-      ball.vec.vy *= -1
+      ball.vec.y *= -1
     end
-
   end
 
 end
 
 
-P = Sketch.new(:width => 400, :height => 400, :title => "CircleCollision2")
+Sketch.new(:width => 400, :height => 400, :title => "CircleCollision2")