reight 0.1.6 → 0.1.8

data/lib/reight/app/navigator.rb

@@ -32,14 +32,15 @@ class Reight::Navigator
 
   def key_pressed()
     index = [F1, F2, F3, F4, F5].index(key_code)
-    app_buttons[index].click if index
+    app_buttons[index]&.click if index
   end
 
   def window_resized()
-    [app_buttons, history_buttons, edit_buttons].flatten.map(&:sprite).each do |sp|
-      sp.w = sp.h = Reight::App::NAVIGATOR_HEIGHT
-      sp.y = 0
-    end
+    [app_buttons, history_buttons, edit_buttons]
+      .flatten.map(&:sprite).each do |sp|
+        sp.w = sp.h = Reight::App::NAVIGATOR_HEIGHT
+        sp.y = 0
+      end
 
     space = Reight::App::SPACE
     x     = space
@@ -47,20 +48,23 @@ class Reight::Navigator
     app_buttons.map {_1.sprite}.each do |sp|
       sp.x = x + 1
       x    = sp.right
+    end.tap do
+      x += space unless _1.empty?
     end
-    x += space
 
     history_buttons.map {_1.sprite}.each do |sp|
       sp.x = x + 1
       x    = sp.right
+    end.tap do
+      x += space unless _1.empty?
     end
-    x += space unless history_buttons.empty?
 
     edit_buttons.map {_1.sprite}.each do |sp|
       sp.x = x + 1
       x    = sp.right
+    end.tap do
+      x += space unless _1.empty?
     end
-    x += space unless edit_buttons.empty?
 
     message.sprite.tap do |sp|
       sp.x     = x + space
@@ -73,72 +77,54 @@ class Reight::Navigator
   private
 
   def app_buttons()
-    @app_buttons ||= [
-      Reight::Button.new(name: 'Run',           icon: @app.icon(0, 0, 8)) {
-        switch_app Reight::Runner
-      },
-      Reight::Button.new(name: 'Sprite Editor', icon: @app.icon(1, 0, 8)) {
-        switch_app Reight::SpriteEditor
-      },
-      Reight::Button.new(name: 'Map Editor',    icon: @app.icon(2, 0, 8)) {
-        switch_app Reight::MapEditor
-      },
-      Reight::Button.new(name: 'Sound Editor',  icon: @app.icon(3, 0, 8)) {
-        switch_app Reight::SoundEditor
-      },
-      Reight::Button.new(name: 'Music Editor',  icon: @app.icon(4, 0, 8)) {
-        switch_app Reight::MusicEditor
-      },
-    ]
+    @app_buttons ||= r8.apps.map.with_index {|app, index|
+      Reight::Button.new(name: app.label, icon: app.icon(index, 0, 8)) {
+        r8.current = app
+      }
+    }
   end
 
   def history_buttons()
-    @history_buttons ||= history_buttons? ? [
-      Reight::Button.new(name: 'Undo', icon: @app.icon(3, 1, 8)) {
+    @history_buttons ||= [].tap do |buttons|
+      next unless @app.respond_to? :undo
+      buttons << Reight::Button.new(name: 'Undo', icon: @app.icon(3, 1, 8)) {
         @app.undo flash: false
       }.tap {|b|
         b.enabled? {@app.history.can_undo?}
-      },
-      Reight::Button.new(name: 'Redo', icon: @app.icon(4, 1, 8)) {
+      }
+      buttons << Reight::Button.new(name: 'Redo', icon: @app.icon(4, 1, 8)) {
         @app.redo flash: false
       }.tap {|b|
         b.enabled? {@app.history.can_redo?}
       }
-    ] : []
+    end
   end
 
   def edit_buttons()
-    @edit_buttons ||= edit_buttons? ? [
-      Reight::Button.new(name: 'Cut',   icon: @app.icon(0, 1, 8)) {
+    @edit_buttons ||= [].tap do |buttons|
+      next unless @app.respond_to? :paste
+      buttons << Reight::Button.new(name: 'Cut',   icon: @app.icon(0, 1, 8)) {
         @app.cut   flash: false
       }.tap {|b|
         b.enabled? {@app.can_cut?}
-      },
-      Reight::Button.new(name: 'Copy',  icon: @app.icon(1, 1, 8)) {
+      }
+      buttons << Reight::Button.new(name: 'Copy',  icon: @app.icon(1, 1, 8)) {
         @app.copy  flash: false
       }.tap {|b|
         b.enabled? {@app.can_copy?}
-      },
-      Reight::Button.new(name: 'Paste', icon: @app.icon(2, 1, 8)) {
+      }
+      buttons << Reight::Button.new(name: 'Paste', icon: @app.icon(2, 1, 8)) {
         @app.paste flash: false
       }.tap {|b|
         b.enabled? {@app.can_paste?}
-      },
-    ] : []
+      }
+    end
   end
 
-  def history_buttons? = @app.respond_to? :undo
-  def    edit_buttons? = @app.respond_to? :cut
-
   def message()
     @message ||= Message.new
   end
 
-  def switch_app(klass)
-    app        = r8.apps.find {_1.class == klass}
-    r8.current = app if app
-  end
-
 end# Navigator
 
 
@@ -159,7 +145,7 @@ class Reight::Navigator::Message
   end
 
   def sprite()
-    @sprite ||= Sprite.new.tap do |sp|
+    @sprite ||= RubySketch::Sprite.new.tap do |sp|
       sp.draw do
         next unless @text
         fill 100

data/lib/reight/app/runner.rb

@@ -1,117 +1,148 @@
-using Reight
+class Reight::Runner < Reight::App
 
+  include Xot::Inspectable
 
-class Reight::Runner < Reight::App
+  ROOT_CONTEXT   = Reight::CONTEXT__
 
   TEMPORARY_HASH = {}
 
+  def label = 'Run'
+
+  def setup()
+    navigator.visible = false
+  end
+
   def activated()
-    super
     run force: true
-    @context.call_activated__
+    @context.call_activated__ {|&b| call_event(ignore_pause: true, &b)}
+    super
   end
 
   def deactivated()
     super
-    @context.call_deactivated__
+    @context.call_deactivated__ {|&b| call_event(ignore_pause: true, &b)}
     pause
+    cleanup
   end
 
   def draw()
-    push do
-      @context&.call_draw__ unless paused?
+    return unless @context
+    @initial_resize ||= true.tap do
+      call_event {@context.size ROOT_CONTEXT.width, ROOT_CONTEXT.height}
+    end
+    @context.call_draw__ {|push: true, &b| call_event(push: push, &b)}
+    if canvasFrame = @context.canvasFrame__
+      ROOT_CONTEXT.background 0
+      ROOT_CONTEXT.image @context, *canvasFrame
+    else
+      ROOT_CONTEXT.image @context, 0, 0
     end
     super
   end
 
   def key_pressed()
     super
-    @context&.key_pressed unless paused?
+    call_event {@context.key_pressed}
   end
 
   def key_released()
     super
-    @context&.key_released unless paused?
+    call_event {@context.key_released}
   end
 
   def key_typed()
     super
-    @context&.key_typed unless paused?
+    call_event {@context.key_typed}
   end
 
   def mouse_pressed()
     super
-    @context&.mouse_pressed unless paused?
+    call_event {@context.mouse_pressed}
   end
 
   def mouse_released()
     super
-    @context&.mouse_released unless paused?
+    call_event {@context.mouse_released}
   end
 
   def mouse_moved()
     super
-    @context&.mouse_moved unless paused?
-    navigator.visible = mouse_y < NAVIGATOR_HEIGHT
+    navigator.visible = ROOT_CONTEXT.mouse_y < NAVIGATOR_HEIGHT if r8.edit?
+    call_event {@context.mouse_moved}
   end
 
   def mouse_dragged()
     super
-    @context&.mouse_dragged unless paused?
+    call_event {@context.mouse_dragged}
   end
 
   def mouse_clicked()
     super
-    @context&.mouse_clicked unless paused?
+    call_event {@context.mouse_clicked}
   end
 
   def double_clicked()
     super
-    @context&.double_clicked unless paused?
+    call_event {@context.double_clicked}
   end
 
   def mouse_wheel()
     super
-    @context&.mouse_wheel unless paused?
+    call_event {@context.mouse_wheel}
   end
 
   def touch_started()
     super
-    @context&.touch_started unless paused?
+    call_event {@context.touch_started}
   end
 
   def touch_ended()
     super
-    @context&.touch_ended unless paused?
+    call_event {@context.touch_ended}
   end
 
   def touch_moved()
     super
-    @context&.touch_moved unless paused?
+    call_event {@context.touch_moved}
   end
 
   def window_moved()
     super
-    @context&.window_moved
+    call_event(ignore_pause: true) {@context.window_moved}
   end
 
   def window_resized()
     super
-    @context&.window_resized
+    call_event(ignore_pause: true) {@context.window_resized}
   end
 
   private
 
+  def call_event(push: true, ignore_pause: false, &block)
+    if @context
+      @context.beginDraw__
+      @context.push if push
+      block.call unless paused?
+    end
+  rescue ScriptError, StandardError => e
+    puts e.full_message
+  ensure
+    if @context
+      @context.pop if push
+      @context.endDraw__
+    end
+  end
+
   def running? = @context && !@paused
 
   def paused?  = @context && @paused
 
   def run(force: false)
     return pause false if paused? && !force
-    cleanup
     backup_global_vars
     @context = create_context
     @paused  = false
+    Processing::Context.setContext__ @context
     begin_wrapping_user_classes @context
     eval_user_script @context, project.code_paths.zip(project.codes).to_h
   end
@@ -121,9 +152,12 @@ class Reight::Runner < Reight::App
   end
 
   def cleanup()
-    remove_world @context.sprite_world__ if @context
+    ROOT_CONTEXT.remove_world @context.spriteWorld__ if @context
+    Processing::Context.setContext__ nil
     @context = nil
     end_wrapping_user_classes
+    clear_all_timers
+    project.clear_all_sprites
     restore_global_vars
     GC.enable
     GC.start
@@ -131,55 +165,56 @@ class Reight::Runner < Reight::App
 
   def create_context()
     klass = Class.new do
-      def project        = @project__
+      include Reight::Context
 
-      def sprite_world__ = @sprite_world__ ||= SpriteWorld.new(pixels_per_meter: 5)
-
-      def call_activated__()
-        add_world sprite_world__
-        activated
+      def call_activated__(&caller)
+        add_world spriteWorld__
+        caller.call {activated}
       end
 
-      def call_deactivated__()
-        deactivated
-        remove_world sprite_world__
+      def call_deactivated__(&caller)
+        caller.call {deactivated}
+        remove_world spriteWorld__
         @background_cleared__ = false
       end
 
-      def call_draw__()
-        unless @setup_done__
-               @setup_done__ = true
-          setup
-        end
-        unless @background_cleared__
-               @background_cleared__ = true
-          background 100, 100, 100
-        end
-        draw
+      def call_draw__(&caller)
+        @setup_done__         ||= true.tap {caller.call(push: false) {setup}}
+        @background_cleared__ ||= true.tap {caller.call {background 100}}
+        caller.call {draw}
       end
 
-      def createSprite(...) = sprite_world__.createSprite(...)
-      def addSprite(...)    = sprite_world__.addSprite(...)
-      def removeSprite(...) = sprite_world__.removeSprite(...)
-      def gravity(...)      = sprite_world__.gravity(...)
-    end
-    Processing.to_snake_case__(
-      %i[activated deactivated] + Processing::EVENT_NAMES__
-    ).each do |camel, snake|
-      klass.class_eval <<~END
-        def #{camel}(&block)
-          if block
-            @#{camel}_block__ = block
-          else
-            @#{camel}_block__&.call
+      def inspect()
+        "#<#{self.class.name}:0x#{object_id}>"
+      end
+
+      methods = (instance_methods - Object.instance_methods)
+        .reject {_1.end_with? '__'}
+      Processing.to_snake_case__(methods).each do |camel, snake|
+        alias_method snake, camel if snake != camel
+      end
+
+      Processing.to_snake_case__(
+        %i[activated deactivated] + Processing::EVENT_NAMES__
+      ).each do |camel, snake|
+        class_eval <<~END
+          def #{camel}(&block)
+            if block
+              @#{camel}_block__ = block
+            else
+              @#{camel}_block__&.call
+            end
           end
-        end
-      END
-      klass.alias_method snake, camel if snake != camel
-    end
-    klass.new.tap do |context|
-      context.instance_variable_set :@project__, project
+        END
+        alias_method snake, camel if snake != camel
+      end
+
+      Processing.funcs__(ROOT_CONTEXT).each do |func|
+        next if method_defined? func
+        define_method(func) {|*a, **k, &b| ROOT_CONTEXT.__send__ func, *a, **k, &b}
+      end
     end
+    klass.new(ROOT_CONTEXT, project)
   end
 
   def begin_wrapping_user_classes(context)
@@ -207,27 +242,17 @@ class Reight::Runner < Reight::App
 
   def create_user_class_wrapper(context)
     Module.new.tap do |wrapper|
-      wrap_methods context, wrapper
-    end
-  end
-
-  def wrap_methods(context, klass)
-    klass.define_method :respond_to_missing? do |name, include_private = false|
-      context.respond_to?(name, false) || super(name, include_private)
-    end
-    klass.define_method :method_missing do |name, *args, **kwargs, &block|
-      if context.respond_to? name
-        klass.define_method(name) {|*a, **k, &b| context.public_send name, *a, **k, &b}
-        context.public_send name, *args, **kwargs, &block
-      else
-        super name, *args, **kwargs, &block
+      wrapper.define_method :respond_to_missing? do |name, include_private = false|
+        context.respond_to?(name, false) || super(name, include_private)
+      end
+      wrapper.define_method :method_missing do |name, *args, **kwargs, &block|
+        if context.respond_to? name
+          wrapper.define_method(name) {|*a, **k, &b| context.public_send name, *a, **k, &b}
+          context.public_send name, *args, **kwargs, &block
+        else
+          super name, *args, **kwargs, &block
+        end
       end
-    end
-    Processing.to_snake_case__(%i[
-      project createSprite addSprite removeSprite gravity
-    ]).each do |camel, snake|
-      klass.define_method(camel) {|*a, **k, &b| context.public_send camel, *a, **k, &b}
-      klass.alias_method snake, camel if snake != camel
     end
   end
 
@@ -237,19 +262,23 @@ class Reight::Runner < Reight::App
       ::Reight::Runner::TEMPORARY_HASH[:params] => {context:, codes:}
       codes.each {|path, code| context.instance_eval code, path if code}
     END
+  rescue ScriptError, StandardError => e
+    puts e.full_message
   ensure
     TEMPORARY_HASH.delete :params
   end
 
+  EXCLUDE_GLOBAL_VARS = [:$FILENAME]
+
   def backup_global_vars()
-    @global_vars = global_variables
+    @global_vars = (global_variables - EXCLUDE_GLOBAL_VARS)
       .each.with_object({}) {|name, hash| hash[name] = eval name.to_s}
       .freeze
   end
 
   def restore_global_vars()
     return unless @global_vars
-    global_variables
+    (global_variables - EXCLUDE_GLOBAL_VARS)
       .map    {|name| [name, eval(name.to_s)]}
       .select {|name, value| value != nil && @global_vars[name] == nil}
       .each   {|name, value| global_var_set name, nil}
@@ -267,4 +296,12 @@ class Reight::Runner < Reight::App
     TEMPORARY_HASH.delete :value
   end
 
+  def clear_all_timers()
+    prefix = Reight::Context::TIMER_PREFIX__
+    ROOT_CONTEXT.instance_eval do
+      @timers__      .delete_if {|id| id in [prefix, _]}
+      @firingTimers__.delete_if {|id| id in [prefix, _]}
+    end
+  end
+
 end# Runner

data/lib/reight/app/sound/brush.rb

@@ -0,0 +1,32 @@
+class Reight::SoundEditor::Brush < Reight::SoundEditor::Tool
+
+  def initialize(app, &block)
+    super app, icon: app.icon(1, 2, 8), &block
+    set_help left: name, right: 'Pick Tone'
+  end
+
+  def brush(x, y, button)
+    canvas.put x, y
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    canvas.begin_editing
+    brush x, y, button
+  end
+
+  def canvas_released(x, y, button)
+    return unless button == LEFT
+    canvas.end_editing
+  end
+
+  def canvas_dragged(x, y, button)
+    return unless button == LEFT
+    brush x, y, button
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_tone x, y if button == RIGHT
+  end
+
+end# Brush