ruby-processing.rb

# Ruby-Processing is for Code Art.
# Send suggestions, ideas, and hate-mail to jashkenas [at] gmail.com
# Also, send samples and libraries.
#
# This class is a thin wrapper around Processing's PApplet.
# Most of the code here is for interfacing with Swing, 
# web applets, going fullscreen, and drawing sliders.
#
# - omygawshkenas

require 'java'
require 'fileutils'

RUBY_PROCESSING_ROOT = File.expand_path(File.dirname(__FILE__)) unless defined?(RUBY_PROCESSING_ROOT)
SKETCH_PATH = File.dirname($0) unless defined?(SKETCH_PATH)

module Processing 

  # Conditionally load core.jar
  require "#{RUBY_PROCESSING_ROOT}/core.jar" unless Object.const_defined?(:JRUBY_APPLET)  
  include_package "processing.core"

  class App < PApplet
    include Math

    include_class "javax.swing.JFrame"

    # Alias some methods for familiarity for Shoes coders.
    attr_accessor :frame, :title
    alias_method :oval, :ellipse
    alias_method :stroke_width, :stroke_weight
    alias_method :rgb, :color
    alias_method :gray, :color

    # Watch the definition of these methods, to make sure 
    # that Processing is able to call them during events.
    METHODS_TO_WATCH_FOR = { 
      :mouse_pressed => :mousePressed,
      :mouse_dragged => :mouseDragged,
      :mouse_clicked => :mouseClicked,
      :mouse_moved   =>   :mouseMoved, 
      :mouse_released => :mouseReleased,
      :key_pressed => :keyPressed,
      :key_released => :keyReleased,
      :key_typed => :keyTyped 
    }


    def self.method_added(method_name)
      if METHODS_TO_WATCH_FOR.keys.include?(method_name)
        alias_method METHODS_TO_WATCH_FOR[method_name], method_name
      end
    end


    # Class methods that we should make available in the instance.
    [:map, :pow, :norm, :lerp, :second, :minute, :hour, :day, :month, :year, 
     :sq, :constrain, :dist, :blend_color].each do |meth|
      method = <<-EOS
        def #{meth}(*args)
          self.class.#{meth}(*args)
        end
      EOS
      eval method
    end
    

    def self.current=(app); @current_app = app; end
    def self.current; @current_app; end


    # Detect if we're online or not.
    def self.online?
      @online ||= Object.const_defined?(:JRUBY_APPLET)
    end
    def online?; self.class.online?; end


    # Detect if a library has been loaded (for conditional loading)
    @@loaded_libraries = Hash.new(false)
    def self.library_loaded?(folder)
      @@loaded_libraries[folder.to_sym]
    end
    def library_loaded?(folder); self.class.library_loaded?(folder); end


    # For pure ruby libs.
    # The library should have an initialization ruby file 
    # of the same name as the library folder.
    def self.load_ruby_library(folder)
      unless @@loaded_libraries[folder.to_sym]
        online? ? prefix = "" : prefix = "library/"
        @@loaded_libraries[folder.to_sym] = require "#{prefix}#{folder}/#{folder}"
      end
      return @@loaded_libraries[folder.to_sym]
    end


    # Loading libraries which include native code needs to 
    # hack the Java ClassLoader, so that you don't have to 
    # futz with your PATH. But it's probably bad juju.
    def self.load_java_library(folder)
      unless @@loaded_libraries[folder.to_sym]
        if online? # Applets preload all the java libraries.
          @@loaded_libraries[folder.to_sym] = true if JRUBY_APPLET.get_parameter("archive").match(%r(#{folder}))
        else
          base = "library#{File::SEPARATOR}#{folder}#{File::SEPARATOR}"
          jars = Dir.glob("#{base}*.jar")
          base2 = "#{base}library#{File::SEPARATOR}"
          jars = jars + Dir.glob("#{base2}*.jar")
          jars.each {|jar| require jar }
          return false if jars.length == 0
          # Here goes...
          sep = java.io.File.pathSeparator
          path = java.lang.System.getProperty("java.library.path")
          new_path = base + sep + base + "library" + sep + path
          java.lang.System.setProperty("java.library.path", new_path)
          field = java.lang.Class.for_name("java.lang.ClassLoader").get_declared_field("sys_paths")
          if field
            field.accessible = true
            field.set(java.lang.Class.for_name("java.lang.System").get_class_loader, nil)
          end
          @@loaded_libraries[folder.to_sym] = true
        end
      end
      return @@loaded_libraries[folder.to_sym]
    end


    def self.has_slider(*args)
      raise "has_slider has been replaced with a nicer control_panel library. Check it out."
    end


    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


    def initialize(options = {})
      super()
      $app = App.current = self
      set_sketch_path
      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 = P2D
      determine_how_to_display options
    end


    def inspect
      "#<Processing::App:#{self.class}:#{@title}>"
    end
    
    
    # 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')
      field.set_value(Java.ruby_to_java(self), path || SKETCH_PATH)
    end


    def display_full_screen(graphics_env)
      @frame = java.awt.Frame.new
      mode = graphics_env.display_mode
      @width, @height = mode.get_width, mode.get_height
      gc = graphics_env.get_default_configuration
      @frame.set_undecorated 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
      @frame.set_location(0, 0)
      @frame.show
      self.init
      self.request_focus
    end


    def display_in_a_window
      @frame = JFrame.new(@title)
      @frame.add(self)
      @frame.setSize(@width, @height + 22)
      @frame.setDefaultCloseOperation(JFrame::EXIT_ON_CLOSE)
      @frame.setResizable(false)
      @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
      JRUBY_APPLET.validate
      # Add the callbacks to peacefully expire.
      JRUBY_APPLET.on_stop { self.stop }
      JRUBY_APPLET.on_destroy { self.destroy }
      self.init
    end


    # Tests to see which display method should run.
    def determine_how_to_display(options)
      if online? # Then display it in an applet.
        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.
        display_in_a_window
      end
    end


    # There's just so many functions in Processing,
    # Here's a convenient way to look for them.
    def find_method(method_name)
      reg = Regexp.new("#{method_name}", true)
      self.methods.sort.select {|meth| reg.match(meth)}
    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.
    def buffer(buf_width=width, buf_height=height, renderer=@render_mode)
      buf = create_graphics(buf_width, buf_height, renderer)
      buf.begin_draw
      yield buf
      buf.end_draw
      buf
    end


    # A nice method to run a given block for a grid.
    # Lifted from action_coding/Nodebox.
    def grid(cols, rows, col_size=1, row_size=1)
      (0..cols*rows).map do |i|
        x = col_size * (i % cols)
        y = row_size * i.div(cols)
        yield x, y
      end
    end


    # Fix java conversion problems getting the last key
    def key
      field = java_class.declared_field 'key'
      app = Java.ruby_to_java self
      field.value app
    end


    # From ROP. Turns a color hash-string into hexadecimal, for Processing.
    def hex(value)
      value[1..-1].hex + 0xff000000
    end


    # Fields that should be made accessible as under_scored.
    def mouse_x;      mouseX;       end
    def mouse_y;      mouseY;       end
    def pmouse_x;     pmouseX;      end
    def pmouse_y;     pmouseY;      end
    def frame_count;  frameCount;   end
    def mouse_button; mouseButton;  end
    def key_code;     keyCode;      end


    def mouse_pressed?
      Java.java_to_primitive(java_class.field("mousePressed").value(java_object))
    end


    def key_pressed?
      Java.java_to_primitive(java_class.field("keyPressed").value(java_object))
    end


    def close
      Processing::App.current = nil
      control_panel.remove if respond_to?(:control_panel) && !online?
      container = (@frame || JRUBY_APPLET)
      container.remove(self)
      self.destroy
      container.dispose
    end


    def quit
      java.lang.System.exit(0)
    end
    
    
    private
    
    # When the net library is included, we make the Ruby interpreter
    # 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?
      field = java.lang.Class.for_name("org.jruby.JRubyApplet").get_declared_field("runtime")
      field.set_accessible true
      ruby = field.get(JRUBY_APPLET)
      window = Java::netscape.javascript.JSObject.get_window(JRUBY_APPLET)
      window.set_member('ruby', ruby)
    end

  end
end