add on method for registering blocks

examples updated

lib/voicemeeter/base.rb

@@ -3,7 +3,7 @@ module Voicemeeter
     # Base class for Remote types
     include Logging
     include Worker
-    include Events::Callback
+    include Events::Director
     prepend Util::Cache
 
     attr_reader :kind, :midi, :event, :delay, :cache

lib/voicemeeter/event.rb

@@ -1,28 +1,26 @@
 module Voicemeeter
   module Events
-    module Callback
-      def callbacks
-        @callbacks ||= []
+    module Director
+      def observers
+        @observers ||= {}
+      end
+
+      def on(event, method = nil, &block)
+        (observers[event] ||= []) << (block || method)
       end
 
       def register(cbs)
         cbs = [cbs] unless cbs.respond_to? :each
-        cbs.each { |cb| callbacks << cb unless callbacks.include? cb }
+        cbs.each { |cb| on(cb.name[3..].to_sym, cb) }
       end
 
       def deregister(cbs)
         cbs = [cbs] unless cbs.respond_to? :each
-        callbacks.reject! { |cb| cbs.include? cb }
+        cbs.each { |cb| observers[cb.name[3..].to_sym]&.reject! { |o| cbs.include? o } }
       end
 
-      private def trigger(event)
-        callbacks.each do |callback|
-          if callback.is_a? Method
-            callback.call if callback.name == "on_#{event}".to_sym
-          elsif callback.respond_to? :on_update
-            callback.on_update event
-          end
-        end
+      def fire(event)
+        observers[event]&.each { |block| block.call }
       end
     end
 

lib/voicemeeter/worker.rb

@@ -30,15 +30,15 @@ module Voicemeeter
       Thread.new do
         Thread.current.name = "worker"
         while (event = que.pop)
-          trigger :pdirty if event == :pdirty && pdirty?
-          trigger :mdirty if event == :mdirty && mdirty?
-          trigger :midi if event == :midi && get_midi_message
+          fire :pdirty if event == :pdirty && pdirty?
+          fire :mdirty if event == :mdirty && mdirty?
+          fire :midi if event == :midi && get_midi_message
           if event == :ldirty && ldirty?
             cache[:strip_comp] = cache[:strip_level].zip(cache[:strip_buf]).map { |a, b| a != b }
             cache[:bus_comp] = cache[:bus_level].zip(cache[:bus_buf]).map { |a, b| a != b }
             cache[:strip_level] = cache[:strip_buf]
             cache[:bus_level] = cache[:bus_buf]
-            trigger :ldirty
+            fire :ldirty
           end
         end
         logger.debug "closing #{Thread.current.name} thread"