ruby-processing 1.0.3 → 1.0.4

data/CHANGELOG

@@ -1,3 +1,15 @@
+v1.0.4 Bare is Beautiful...
+  * Ruby-Processing now supports "bare" sketches, which are sketches that 
+    consist of only setup and draw methods, or sketches that contain no method
+    definitions at all (implicitly wrapping them in a 'setup'). This works
+    by pre-processing the code.
+  * Initialization heavily tweaked so that size() works as in Processing,
+    from within setup(), and so that you can call full_screen as a class method,
+    in your class definition, to avoid the need for explicit sketch instantiation.
+  * "rp5 create" has a "--bare" option.
+  * Many samples now use the bare style, and more "Learning Processing" examples
+    were contributed by Juris Galang.
+
 v1.0.3 Tweaks and Tuneups...
   * "rp5 watch" is now a bit more robust, and tries to reload every
   * file, global, and constant that it thinks it needs to.

data/README

@@ -17,6 +17,9 @@
   * Live Coding via JRuby's IRB. Loads in your sketch so you can futz with 
     variables and remake methods on the fly.
     
+  * Bare sketches. Write your Ruby-Processing sketches without having to define
+    a class. Without defining methods, even.
+    
   * A "Control Panel" library, so that you can easily create sliders, buttons,
     checkboxes and drop-down menus, and hook them into your sketch's instance 
     variables.

data/lib/patches/JRubyApplet.diff

@@ -0,0 +1,24 @@
+Index: src/org/jruby/JRubyApplet.java
+===================================================================
+--- src/org/jruby/JRubyApplet.java	(revision 9392)
++++ src/org/jruby/JRubyApplet.java	(working copy)
+@@ -257,6 +257,10 @@
+         }
+     }
+ 
++    public synchronized void eval(String code) {
++        this.runtime.evalScriptlet(code);
++    }
++
+     public synchronized void setBackgroundColor(Color color) {
+         backgroundColor = color;
+         repaint();
+@@ -381,7 +385,7 @@
+         
+         public ConsoleFacade(String bannerText) {
+             textPane = new JTextPane();
+-	    textPane.setMargin(new Insets(4, 4, 0, 4));
++	          textPane.setMargin(new Insets(4, 4, 0, 4));
+             textPane.setCaretColor(new Color(0xa4, 0x00, 0x00));
+             textPane.setBackground(new Color(0xf2, 0xf2, 0xf2));
+             textPane.setForeground(new Color(0xa4, 0x00, 0x00));

data/lib/patches/PATCHES.txt

@@ -0,0 +1,3 @@
+These patches should be applied to the JRuby and Processing sources, respectively
+before vendoring them into Ruby-Processing. It is my fervent wish that one day 
+we'll be rid of both.

data/lib/patches/PApplet.diff

@@ -0,0 +1,27 @@
+Index: core/src/processing/core/PApplet.java
+===================================================================
+--- core/src/processing/core/PApplet.java	(revision 5371)
++++ core/src/processing/core/PApplet.java	(working copy)
+@@ -1386,7 +1386,22 @@
+         } catch (RendererChangeException e) {
+           // Give up, instead set the new renderer and re-attempt setup()
+           return;
++
++        // Catch a JRuby exception so that the RendererChangeExceptions
++        // that we're looking for don't get stuck in Ruby-space.
++        } catch (RuntimeException e) {
++          String message = e.getMessage();
++          String name = RendererChangeException.class.getName();
++          String regex = "(?s).*" + name + ".*";
++          regex = regex.replace("$", "\\$");
++          if (message != null && message.matches(regex)) {
++            // Give up, instead set the new renderer and re-attempt setup()
++            return;
++          } else {
++            throw e;
++          }
+         }
++        
+         this.defaultSize = false;
+ 
+       } else {  // frameCount > 0, meaning an actual draw()

data/lib/ruby-processing.rb

@@ -7,12 +7,14 @@ unless defined? RP5_ROOT
   RP5_ROOT = File.expand_path(File.dirname(__FILE__) + "/../")
 end
 
+SKETCH_ROOT = Dir.pwd unless defined? SKETCH_ROOT
+
 require 'ruby-processing/helpers/string'
 require 'ruby-processing/helpers/numeric'
 
 # The top-level namespace, a home for all Ruby-Processing classes.
 module Processing
-  VERSION = [1,0,3] unless defined? Processing::VERSION
+  VERSION = [1,0,4] unless defined? Processing::VERSION
   
   # Returns the current version of Ruby-Processing.
   def self.version
@@ -21,6 +23,7 @@ module Processing
   
   autoload :App,                  'ruby-processing/app'
   autoload :Runner,               'ruby-processing/runner'
+  autoload :Watcher,              'ruby-processing/runners/watch'
   autoload :Creator,              'ruby-processing/exporters/creator'
   autoload :BaseExporter,         'ruby-processing/exporters/base_exporter'
   autoload :AppletExporter,       'ruby-processing/exporters/applet_exporter'

data/lib/ruby-processing/app.rb

@@ -4,7 +4,7 @@
 
 require 'java'
 
-module Processing 
+module Processing   
 
   # Conditionally load core.jar
   require "#{RP5_ROOT}/lib/core/core.jar" unless Object.const_defined?(:JRUBY_APPLET)  
@@ -19,8 +19,6 @@ module Processing
   # called constantly, for every frame.
   class App < PApplet
     include Math
-
-    import "javax.swing.JFrame"
     
     # Include some processing classes that we'd like to use:
     %w(PShape PImage PGraphics PFont PVector).each do |klass|
@@ -46,6 +44,10 @@ module Processing
       :key_released   => :keyReleased,
       :key_typed      => :keyTyped 
     }
+    
+    # Override the default width and height to make them a little larger.
+    DEFAULT_WIDTH = 200
+    DEFAULT_HEIGHT = 200
 
 
     def self.method_added(method_name) #:nodoc:
@@ -67,8 +69,18 @@ module Processing
     end
     
 
-    def self.current=(app); @current_app = app; end
-    def self.current; @current_app; end   
+    # Handy getters and setters on the class go here:
+    def self.sketch_class;  @sketch_class;        end 
+    def self.full_screen;   @@full_screen = true; end
+    def full_screen?;       @@full_screen;        end
+    
+    
+    # Keep track of what inherits from the Processing::App, because we're going
+    # to want to instantiate one.
+    def self.inherited(subclass)
+      super(subclass)
+      @sketch_class = subclass
+    end
     
 
     # Are we running inside an applet?
@@ -103,8 +115,14 @@ module Processing
     def self.load_ruby_library(dir)
       dir = dir.to_sym
       return true if @@loaded_libraries[dir]
-      return @@loaded_libraries[dir] = (require "library/#{dir}/#{dir}") if online?
-      local_path = "#{Dir.pwd}/library/#{dir}"
+      if online?
+        begin
+          return @@loaded_libraries[dir] = (require "library/#{dir}/#{dir}")
+        rescue LoadError => e
+          return false
+        end
+      end
+      local_path = "#{SKETCH_ROOT}/library/#{dir}"
       gem_path = "#{RP5_ROOT}/library/#{dir}"
       path = File.exists?(local_path) ? local_path : gem_path
       return false unless (File.exists?("#{path}/#{dir}.rb"))
@@ -122,10 +140,10 @@ module Processing
       dir = dir.to_sym
       return true if @@loaded_libraries[dir]
       return @@loaded_libraries[dir] = !!(JRUBY_APPLET.get_parameter("archive").match(%r(#{dir}))) if online?
-      local_path = "#{Dir.pwd}/library/#{dir}"
+      local_path = "#{SKETCH_ROOT}/library/#{dir}"
       gem_path = "#{RP5_ROOT}/library/#{dir}"
       path = File.exists?(local_path) ? local_path : gem_path
-      jars = Dir.glob("#{path}/**/*.jar")
+      jars = Dir["#{path}/**/*.jar"]
       return false if jars.empty?
       jars.each {|jar| require jar }
       # Here goes...
@@ -139,23 +157,12 @@ module Processing
       end
       return @@loaded_libraries[dir] = true
     end
-
+    
 
     def self.has_slider(*args) #:nodoc:
       raise "has_slider has been replaced with a nicer control_panel library. Check it out."
     end
-
-
-    # Used by the Processing::Watcher to completely remove all 
-    # traces of the current sketch, so that it can be loaded afresh.
-    def self.wipe_out_current_app!
-      app = Processing::App.current
-      return unless app
-      app_class_name = app.class.to_s.to_sym
-      app.close
-      Object.send(:remove_const, app_class_name)
-    end
-
+    
 
     # When you make a new sketch, you pass in (optionally), 
     # a width, height, title, and whether or not you want to 
@@ -163,20 +170,26 @@ module Processing
     #
     # This is a little different than Processing where height
     # and width are declared inside the setup method instead.
-    def initialize(options = {})
+    def initialize(options={})
       super()
-      $app = App.current = self
+      $app = self
+      proxy_java_fields
       set_sketch_path unless online?
-      make_accessible_to_the_browser
-      options = {
-        :width => 400, 
-        :height => 400, 
-        :title => "",
-        :full_screen => false
-      }.merge(options)
-      @width, @height, @title = options[:width], options[:height], options[:title]
-      @render_mode = JAVA2D
-      determine_how_to_display options
+      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]
+      self.init
+      determine_how_to_display
+    end
+    
+    
+    # Make sure we set the size if we set it before we start the animation thread.
+    def start
+      self.size(@width, @height)
+      super()
     end
 
 
@@ -189,10 +202,17 @@ module Processing
     # By default, your sketch path is the folder that your sketch is in.
     # If you'd like to do something fancy, feel free.
     def set_sketch_path(path=nil)
-      field = self.java_class.declared_field('sketchPath')
-      local = File.dirname(SKETCH_PATH)
+      field = @declared_fields['sketchPath']
+      local = SKETCH_ROOT
       default = $__windows_app_mode__ ? "#{local}/lib" : local
-      field.set_value(Java.ruby_to_java(self), path || default)
+      field.set_value(java_self, path || default)
+    end
+    
+    
+    # Specify what rendering Processing should use, without needing to pass size.
+    def render_mode(mode_const)
+      @render_mode = mode_const
+      size(@width, @height, @render_mode)
     end
 
 
@@ -204,13 +224,6 @@ module Processing
     end
 
 
-    # Specify what rendering Processing should use.
-    def render_mode(mode_const)
-      @render_mode = mode_const
-      size(@width, @height, @render_mode)
-    end
-
-
     # Nice block method to draw to a buffer.
     # You can optionally pass it a width, a height, and a renderer.
     # Takes care of starting and ending the draw for you.
@@ -232,14 +245,18 @@ module Processing
         yield x, y
       end
     end
+    
+    
+    # Provide a convenient handle for the Java-space version of self.
+    def java_self
+      @java_self ||= Java.ruby_to_java self
+    end
 
 
     # Fix java conversion problems getting the last key
     # If it's ASCII, return the character, otherwise the integer
     def key
-      field = java_class.declared_field 'key'
-      app = Java.ruby_to_java self
-      int = field.value(app)
+      int = @declared_fields['key'].value(java_self)
       int < 256 ? int.chr : int
     end
 
@@ -260,6 +277,25 @@ module Processing
     def key_code;     keyCode;      end
 
 
+    # frame_rate needs to support reading and writing
+    def frame_rate(fps = nil)
+      return @declared_fields['frameRate'].value(java_self) unless fps
+      super(fps)
+    end
+    
+    
+    # Is the sketch still displaying with the default size?
+    def default_size?
+      @declared_fields['defaultSize'].value(java_self)
+    end
+    
+    
+    # Is the sketch done displaying itself?
+    def done_displaying?
+      @done_displaying
+    end
+    
+
     # Is the mouse pressed for this frame?
     def mouse_pressed?
       Java.java_to_primitive(java_class.field("mousePressed").value(java_object))
@@ -277,70 +313,81 @@ module Processing
     def lerp_color(*args)
       args.length > 3 ? self.class.lerp_color(*args) : super(*args) 
     end
-    
+
 
     # Cleanly close and shutter a running sketch.
     def close
-      Processing::App.current = nil
+      $app = nil
       control_panel.remove if respond_to?(:control_panel) && !online?
-      container = (@frame || JRUBY_APPLET)
+      container = online? ? JRUBY_APPLET : @frame
       container.remove(self)
       self.destroy
       container.dispose
     end
-
-    
-    def quit
-      exit
-    end
     
     
     private
     
+    # Proxy over a list of Java declared fields that have the same name as 
+    # some methods. Add to this list as needed.
+    def proxy_java_fields
+      @declared_fields = {}
+      fields = %w(sketchPath key frameRate defaultSize)
+      fields.each {|f| @declared_fields[f] = java_class.declared_field(f) }
+    end
+    
+    
     # Tests to see which display method should run.
-    def determine_how_to_display(options)
-      if online? # Then display it in an applet.
+    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
+      
+      if online?
         display_in_an_applet
-      elsif options[:full_screen] # Then display it fullscreen.
-        graphics_env = java.awt.GraphicsEnvironment.get_local_graphics_environment.get_default_screen_device
-        graphics_env.is_full_screen_supported ? display_full_screen(graphics_env) : display_in_a_window
-      else # Then display it in a window.
+      elsif full_screen?
+        # linux doesn't support full screen exclusive mode, but don't worry, it works very well
+        display   = java.awt.GraphicsEnvironment.get_local_graphics_environment.get_default_screen_device
+        linux     = java.lang.System.get_property("os.name") == "Linux"
+        supported = display.full_screen_supported?
+        supported || linux ? display_full_screen(display) : display_in_a_window
+      else
         display_in_a_window
       end
+      @done_displaying = true
     end
     
     
-    def display_full_screen(graphics_env)
-      @frame = java.awt.Frame.new
-      mode = graphics_env.display_mode
+    # Go full screen, if possible
+    def display_full_screen(display)
+      @frame = java.awt.Frame.new(display.default_configuration)
+      mode = display.display_mode
       @width, @height = mode.get_width, mode.get_height
-      gc = graphics_env.get_default_configuration
       @frame.set_undecorated true
+      @frame.set_ignore_repaint true
       @frame.set_background java.awt.Color.black
       @frame.set_layout java.awt.BorderLayout.new
       @frame.add(self, java.awt.BorderLayout::CENTER)
       @frame.pack
-      graphics_env.set_full_screen_window @frame
+      display.set_full_screen_window @frame
       @frame.set_location(0, 0)
       @frame.show
-      self.init
       self.request_focus
     end
 
 
     def display_in_a_window
-      @frame = JFrame.new(@title)
+      @frame = javax.swing.JFrame.new(@title)
       @frame.add(self)
-      @frame.setSize(@width, @height + 22)
-      @frame.setDefaultCloseOperation(JFrame::EXIT_ON_CLOSE)
-      @frame.setResizable(false)
+      @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)
       @frame.show
-      self.init
     end
 
 
     def display_in_an_applet
-      JRUBY_APPLET.set_size(@width, @height)
       JRUBY_APPLET.background_color = nil
       JRUBY_APPLET.double_buffered = false
       JRUBY_APPLET.add self
@@ -348,7 +395,6 @@ module Processing
       # Add the callbacks to peacefully expire.
       JRUBY_APPLET.on_stop { self.stop }
       JRUBY_APPLET.on_destroy { self.destroy }
-      self.init
     end
     
     
@@ -356,7 +402,7 @@ module Processing
     # accessible to javascript as the 'ruby' variable. From javascript,
     # you can call evalScriptlet() to run code against the sketch.
     def make_accessible_to_the_browser
-      return unless library_loaded?('net') && online?
+      return unless library_loaded?('net')
       field = java.lang.Class.for_name("org.jruby.JRubyApplet").get_declared_field("runtime")
       field.set_accessible true
       ruby = field.get(JRUBY_APPLET)