lacci 0.3.0 → 0.5.0

data/lib/shoes/drawable.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-
+require_relative 'margin_helper'
 class Shoes
   # Shoes::Drawable
   #
@@ -15,7 +15,7 @@ class Shoes
     include Shoes::Colors
 
     # All Drawables have these so they go in Shoes::Drawable and are inherited
-    @shoes_events = ["parent", "destroy", "prop_change"]
+    @shoes_events = ["parent", "destroy", "prop_change", "hover", "leave", "motion"]
 
     class << self
       attr_accessor :drawable_classes
@@ -43,7 +43,8 @@ class Shoes
       end
 
       def drawable_class_by_name(name)
-        drawable_classes.detect { |k| k.dsl_name == name.to_s }
+        name = name.to_s
+        drawable_classes.detect { |k| k.dsl_name == name }
       end
 
       def is_widget_class?(name)
@@ -59,7 +60,8 @@ class Shoes
 
         return value if h[:validator].nil?
 
-        h[:validator].call(value)
+        # Pass both the property name and value to the validator block
+        h[:validator].call(value,prop_name)
       end
 
       # Return a list of Shoes events for this class.
@@ -67,18 +69,65 @@ class Shoes
       # @return Array[String] the list of event names
       def get_shoes_events
         if @shoes_events.nil?
-          raise UnknownEventsForClass, "Drawable type #{self.class} hasn't defined its list of Shoes events!"
+          raise Shoes::Errors::UnknownEventsForClassError, "Drawable type #{self} hasn't defined its list of Shoes events!"
         end
 
         @shoes_events
       end
 
+      # Return whether Shoes events have already been registered for this class
+      #
+      # @return [Boolean] true if events have been registered, false if not
+      def registered_shoes_events?
+        !@shoes_events.nil?
+      end
+
       # Set the list of Shoes event names that are allowed for this class.
       #
       # @param args [Array] an array of event names, which will be coerced to Strings
       # @return [void]
       def shoes_events(*args)
-        @shoes_events ||= args.map(&:to_s) + self.superclass.get_shoes_events
+        if @shoes_events
+          raise Shoes::Errors::DoubleRegisteredShoesEventError, "Registering shoes events #{args.inspect} for class #{self} but already registered events as #{@shoes_events.inspect}!"
+        end
+        @shoes_events = args.map(&:to_s) + self.superclass.get_shoes_events
+      end
+
+      # Require supplying these Shoes style values as positional arguments to
+      # initialize. Initialize will get the arg list, then set the specified styles
+      # if args are given for them. @see opt_init_args for additional non-required
+      # init args.
+      #
+      # @param args [Array<String,Symbol>] an array of Shoes style names
+      # @return [void]
+      def init_args(*args)
+        raise Shoes::Errors::BadArgumentListError, "Positional init args already set for #{self}!" if @required_init_args
+        @required_init_args = args.map(&:to_s)
+      end
+
+      # Allow supplying these Shoes style values as optional positional arguments to
+      # initialize after the mandatory args. @see init_args for setting required
+      # init args.
+      #
+      # @param args [Array<String,Symbol>] an array of Shoes style names
+      # @return [void]
+      def opt_init_args(*args)
+        raise Shoes::Errors::BadArgumentListError, "Positional init args already set for #{self}!" if @opt_init_args
+        @opt_init_args = args.map(&:to_s)
+      end
+
+      # Return the list of style names for required init args for this class
+      #
+      # @return [Array<String>] the array of style names as strings
+      def required_init_args
+        @required_init_args ||= [] # TODO: eventually remove the ||= here
+      end
+
+      # Return the list of style names for optional init args for this class
+      #
+      # @return [Array<String>] the array of style names as strings
+      def optional_init_args
+        @opt_init_args ||= []
       end
 
       # Assign a new Shoes Drawable ID number, starting from 1.
@@ -125,24 +174,56 @@ class Shoes
       # Shoes styles in Shoes Linkables are automatically sync'd with the display side objects.
       # If a block is passed to shoes_style, that's the validation for the property. It should
       # convert a given value to a valid value for the property or throw an exception.
-      def shoes_style(name, &validator)
+      #
+      # If feature is non-nil, it's the feature that an app must request in order to see this
+      # property.
+      #
+      # @param name [String,Symbol] the style name
+      # @param feature [Symbol,NilClass] the feature that must be defined for an app to request this style, or nil
+      # @block if block is given, call it to map the given style value to a valid value, or raise an exception
+      def shoes_style(name, feature: nil, &validator)
         name = name.to_s
 
         return if linkable_properties_hash[name]
 
-        linkable_properties << { name: name, validator: }
+        linkable_properties << { name: name, validator:, feature: }
         linkable_properties_hash[name] = true
       end
 
-      # Add these names as Shoes styles
-      def shoes_styles(*names)
-        names.each { |n| shoes_style(n) }
+      # Add these names as Shoes styles with the given validator and feature, if any
+      def shoes_styles(*names, feature: nil, &validator)
+        names.each { |n| shoes_style(n, feature:, &validator) }
       end
 
-      def shoes_style_names
-        parent_prop_names = self != Shoes::Drawable ? self.superclass.shoes_style_names : []
+      # Query what feature, if any, is required to use a specific shoes_style.
+      # If no specific feature is needed, nil will be returned.
+      def feature_for_shoes_style(style_name)
+        style_name = style_name.to_s
+        lp = linkable_properties.detect { |prop| prop[:name] == style_name }
+        return lp[:feature] if lp
 
-        parent_prop_names | linkable_properties.map { |prop| prop[:name] }
+        # If we get to the top of the superclass tree and we didn't find it, it's not here
+        if self.class == ::Shoes::Drawable
+          raise Shoes::Errors::NoSuchStyleError, "Can't find information for style #{style_name.inspect}!"
+        end
+
+        super
+      end
+
+      # Return a list of shoes_style names with the given features. If with_features is nil,
+      # return them with a list of features for the current Shoes::App. For the list of
+      # styles available with no features requested, pass nil to with_features.
+      def shoes_style_names(with_features: nil)
+        # No with_features given? Use the ones requested by this Shoes::App
+        with_features ||= @app.features
+        parent_prop_names = self != Shoes::Drawable ? self.superclass.shoes_style_names(with_features:) : []
+
+        if with_features == :all
+          subclass_props = linkable_properties
+        else
+          subclass_props = linkable_properties.select { |prop| !prop[:feature] || with_features.include?(prop[:feature]) }
+        end
+        parent_prop_names | subclass_props.map { |prop| prop[:name] }
       end
 
       def shoes_style_hashes
@@ -155,33 +236,188 @@ class Shoes
         linkable_properties_hash[name.to_s] ||
           (self != Shoes::Drawable && superclass.shoes_style_name?(name))
       end
+
+      # Current_app is set every time a drawable is created - we don't want to keep a default
+      # long because it's possible for apps to alternate who is creating. So make sure it's
+      # not kept long, and used up when used once.
+
+      def with_current_app(app)
+        old_cur_app = @current_app
+        @current_app = app
+        ret = yield
+        @current_app = old_cur_app
+        ret
+      end
+
+      def use_current_app
+        cur_app = @current_app
+        @current_app = nil
+        cur_app
+      end
     end
 
+    # Every Shoes drawable has positioning properties
+    shoes_styles :top, :left, :width, :height
+
+    # Margins around drawable
+    shoes_styles :margin, :margin_top, :margin_bottom, :margin_left, :margin_right
+
+    # Padding around drawable
+    shoes_styles :padding, :padding_top, :padding_bottom, :padding_left, :padding_right
+
     # Shoes uses a "hidden" style property for hide/show
     shoes_style :hidden
 
     attr_reader :debug_id
 
+    # These styles can be set to a current per-slot value and inherited from parent slots.
+    # Their value is set at drawable-create time.
+    DRAW_CONTEXT_STYLES = [:fill, :stroke, :strokewidth, :rotate, :transform, :translate]
+
+    include MarginHelper
+
     def initialize(*args, **kwargs)
-      log_init("Shoes::#{self.class.name}")
+      kwargs = margin_parse(kwargs)
+      log_init("Shoes::#{self.class.name}") unless @log
 
-      default_styles = Shoes::Drawable.drawable_default_styles[self.class]
+      # Grab the current app, mark it as used
+      @app = self.is_a?(Shoes::App) ? self : Drawable.use_current_app
+
+      # First, get the list of allowed and disallowed styles for the given features
+      # and make sure no disallowed styles were given.
+
+      app_features = @app.features
+      this_app_styles = self.class.shoes_style_names(with_features: @app.features).map(&:to_sym)
+      not_this_app_styles = self.class.shoes_style_names(with_features: :all).map(&:to_sym) - this_app_styles
+
+      bad_styles = kwargs.keys & not_this_app_styles
+      unless bad_styles.empty?
+        features_needed = bad_styles.map { |s| self.class.feature_for_shoes_style(s) }.uniq
+        raise Shoes::Errors::UnsupportedFeatureError, "The style(s) #{bad_styles.inspect} are only defined for applications that request specific features: #{features_needed.inspect} (you requested #{app_features.inspect})!"
+      end
 
-      self.class.shoes_style_names.each do |prop|
-        prop_sym = prop.to_sym
-        if kwargs.key?(prop_sym)
-          val = self.class.validate_as(prop, kwargs[prop_sym])
-          instance_variable_set("@" + prop, val)
-        elsif default_styles.key?(prop_sym)
-          val = self.class.validate_as(prop, default_styles[prop_sym])
-          instance_variable_set("@" + prop, val)
+      # Next, check positional arguments and make sure the correct number and type
+      # were passed and match positional args with style names.
+
+      supplied_args = kwargs.keys
+
+      req_args = self.class.required_init_args
+      opt_args = self.class.optional_init_args
+      pos_args = req_args + opt_args
+      if req_args != ["any"]
+        if args.size > pos_args.size
+          raise Shoes::Errors::BadArgumentListError, "Too many arguments given for #{self.class}#initialize! #{args.inspect}"
+        end
+
+        if args.size == 0
+          # It's fine to use keyword args instead, but we should make sure they're actually there
+          needed_args = req_args.map(&:to_sym) - kwargs.keys
+          unless needed_args.empty?
+            raise Shoes::Errors::BadArgumentListError, "Keyword arguments for #{self.class}#initialize should also supply #{needed_args.inspect}! #{args.inspect}"
+          end
+        elsif args.size < req_args.size
+          raise Shoes::Errors::BadArgumentListError, "Too few arguments given for #{self.class}#initialize! #{args.inspect}"
         end
+
+        # Set each positional argument
+        args.each.with_index do |val, idx|
+          style_name = pos_args[idx]
+          next if style_name.nil? || style_name == "" # It's possible to have non-style positional args
+
+          val = self.class.validate_as(style_name, args[idx])
+          instance_variable_set("@#{style_name}", val)
+          supplied_args << style_name.to_sym
+        end
+      end
+
+      this_drawable_styles = self.class.shoes_style_names(with_features: @app.features).map(&:to_sym)
+      dc = @app.current_draw_context || {}
+
+      # Styles not passed as arguments can come from the draw context
+
+      # What styles are in the draw context, are used by this drawable, and weren't
+      # given as positional or keyword arguments?
+      draw_context_styles = (DRAW_CONTEXT_STYLES & this_drawable_styles) - supplied_args
+      unless draw_context_styles.empty?
+        draw_context_styles.each do |style|
+          dc_val = dc[style.to_s]
+          next if dc_val.nil?
+
+          val = self.class.validate_as(style, dc[style.to_s])
+          instance_variable_set("@#{style}", val)
+          supplied_args << style
+        end
+      end
+
+      # Styles that were *not* passed should be set to defaults
+
+      default_styles = Shoes::Drawable.drawable_default_styles[self.class]
+
+      # No arg specified for a property with a default value? Set it to default.
+      (default_styles.keys - supplied_args).each do |key|
+        val = self.class.validate_as(key, default_styles[key])
+        instance_variable_set("@#{key}", val)
+      end
+
+      # If we have a keyword arg for a style, set it as specified.
+      (this_drawable_styles & kwargs.keys).each do |key|
+        val = self.class.validate_as(key, kwargs[key])
+        instance_variable_set("@#{key}", val)
+      end
+
+      # We'd like to avoid unexpected keywords. But we're not disciplined enough to
+      # raise an error by default yet. Non-style keywords passed to Drawable#initialize
+      # are deprecated at this point, but I need to hunt down the last of them
+      # and prevent them.
+      unexpected = (kwargs.keys - this_drawable_styles)
+      unless unexpected.empty?
+        STDERR.puts "Unexpected non-style keyword(s) in #{self.class} initialize: #{unexpected.inspect}"
       end
 
       super(linkable_id: Shoes::Drawable.allocate_drawable_id)
       Shoes::Drawable.register_drawable_id(self.linkable_id, self)
 
       generate_debug_id
+
+      parent = @app.current_slot
+      if self.class.expects_parent?
+        set_parent(parent, notify: false)
+      end
+
+      unless self.class.registered_shoes_events?
+        # No Shoes events declared and we're creating an instance?
+        # Default to no class-specific events.
+        self.class.shoes_events
+      end
+
+      # Binding the motion events here isn't perfect.
+      # What about drawables like SubscriptionItem that
+      # have no motion events? With the current Lacci
+      # implementation, the answer is that those events
+      # will never be sent. Calling .hover on one will
+      # be useless, harmless, and allowed. If you want
+      # to make it disallowed, you can do something like
+      # define a SubscriptionItem#hover that raises an
+      # exception instead.
+
+      bind_self_event("hover") do
+        @hover&.call
+      end
+
+      bind_self_event("leave") do
+        @leave&.call
+      end
+
+      bind_self_event("motion") do |x, y|
+        @motion&.call(x, y)
+      end
+    end
+
+    def self.expects_parent?
+      return false if [::Shoes::App, ::Shoes::DocumentRoot].include?(self)
+      return false if self < ::Shoes::TextDrawable
+
+      true
     end
 
     # Calling stack.app or drawable.app will execute the block
@@ -196,8 +432,8 @@ class Shoes
     # @return [Shoes::App] the Shoes app
     # @yield the block to call with the Shoes App as self
     def app(&block)
-      Shoes::App.instance.with_slot(self, &block) if block_given?
-      Shoes::App.instance
+      @app.with_slot(self, &block) if block_given?
+      @app
     end
 
     private
@@ -223,13 +459,14 @@ class Shoes
     private
 
     def validate_event_name(event_name)
-      unless self.class.get_shoes_events.include?(event_name.to_s)
-        raise Shoes::UnregisteredShoesEvent, "Drawable #{self.inspect} tried to bind Shoes event #{event_name}, which is not in #{evetns.inspect}!"
+      events = self.class.get_shoes_events
+      unless events.include?(event_name.to_s)
+        raise Shoes::Errors::UnregisteredShoesEventError, "Drawable #{self.inspect} tried to bind Shoes event #{event_name}, which is not in #{events.inspect}!"
       end
     end
 
     def bind_self_event(event_name, &block)
-      raise(Shoes::Errors::NoLinkableIdError, "Drawable has no linkable_id! #{inspect}") unless linkable_id
+      raise(Shoes::Errors::NoSuchLinkableIdError, "Drawable has no linkable_id! #{inspect}") unless linkable_id
 
       validate_event_name(event_name)
 
@@ -250,8 +487,8 @@ class Shoes
       send_shoes_event(*args, **kwargs, event_name:, target: linkable_id)
     end
 
-    def shoes_style_values
-      all_property_names = self.class.shoes_style_names
+    def shoes_style_values(with_features: @app.features)
+      all_property_names = self.class.shoes_style_names(with_features:)
 
       properties = {}
       all_property_names.each do |prop|
@@ -292,10 +529,11 @@ class Shoes
       klass_name = self.class.name.delete_prefix("Scarpe::").delete_prefix("Shoes::")
 
       is_widget = Shoes::Drawable.is_widget_class?(klass_name)
+      parent_id = @parent&.linkable_id
 
       # Should we send an event so this can be discovered from someplace other than
       # the DisplayService?
-      ::Shoes::DisplayService.display_service.create_display_drawable_for(klass_name, self.linkable_id, shoes_style_values, is_widget:)
+      ::Shoes::DisplayService.display_service.create_display_drawable_for(klass_name, self.linkable_id, shoes_style_values, parent_id:, is_widget:)
     end
 
     public
@@ -303,11 +541,17 @@ class Shoes
     attr_reader :parent
     attr_reader :destroyed
 
-    def set_parent(new_parent)
+    # Set the Drawable's parent drawable. Notify the display service
+    # that the parent has changed unless instructed not to.
+    # We don't notify when first creating the Drawable. The create
+    # event that is first sent will include the parent.
+    def set_parent(new_parent, notify: true)
       @parent&.remove_child(self)
       new_parent&.add_child(self)
       @parent = new_parent
-      send_shoes_event(new_parent.linkable_id, event_name: "parent", target: linkable_id)
+      return unless notify
+
+      send_shoes_event(new_parent&.linkable_id, event_name: "parent", target: linkable_id)
     end
 
     # Removes the element from the Shoes::Drawable tree and removes all event subscriptions
@@ -336,6 +580,28 @@ class Shoes
       self.hidden = !self.hidden
     end
 
+    # Set the hover handler. Not every drawable may do something useful with this.
+    #
+    # @yield A block to be called when the cursor moves to be over the drawable.
+    def hover(&block)
+      @hover = block
+    end
+
+    # Set the leave handler. Not every drawable may do something useful with this.
+    #
+    # @yield A block to be called when the cursor moves to be off of the drawable.
+    def leave(&block)
+      @leave = block
+    end
+
+    # Set the motion handler, called with x and y coordinates as params.
+    # Not every drawable may do something useful with this.
+    #
+    # @yield A block to be called when the cursor moves around over the drawable.
+    def motion(&block)
+      @motion = block
+    end
+
     # We use method_missing to auto-create Shoes style getters and setters.
     def method_missing(name, *args, **kwargs, &block)
       name_s = name.to_s
@@ -344,7 +610,7 @@ class Shoes
         prop_name = name_s[0..-2]
         if self.class.shoes_style_name?(prop_name)
           self.class.define_method(name) do |new_value|
-            raise(Shoes::Errors::NoLinkableIdError, "Trying to set Shoes styles in an object with no linkable ID! #{inspect}") unless linkable_id
+            raise(Shoes::Errors::NoSuchLinkableIdError, "Trying to set Shoes styles in a #{self.class} with no linkable ID!") unless linkable_id
 
             new_value = self.class.validate_as(prop_name, new_value)
             instance_variable_set("@" + prop_name, new_value)
@@ -357,7 +623,7 @@ class Shoes
 
       if self.class.shoes_style_name?(name_s)
         self.class.define_method(name) do
-          raise(Shoes::Errors::NoLinkableIdError, "Trying to get Shoes styles in an object with no linkable ID! #{inspect}") unless linkable_id
+          raise(Shoes::Errors::NoSuchLinkableIdError, "Trying to get Shoes styles in an object with no linkable ID! #{inspect}") unless linkable_id
 
           instance_variable_get("@" + name_s)
         end
@@ -376,5 +642,29 @@ class Shoes
 
       super
     end
+
+    def self.convert_to_integer(value, attribute_name)
+      begin
+        value = Integer(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+
+    def self.convert_to_float(value, attribute_name)
+      begin
+        value = Float(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
   end
 end

data/lib/shoes/drawables/arc.rb

@@ -13,37 +13,15 @@ class Shoes
       shoes_style(prop) { |val| convert_to_float(val, prop) }
     end
 
-    def initialize(*args)
-      @draw_context = Shoes::App.instance.current_draw_context
-
+    init_args :left, :top, :width, :height, :angle1, :angle2
+    def initialize(*args, **kwargs)
       super
-      self.left, self.top, self.width, self.height, self.angle1, self.angle2 = args
-
-      create_display_drawable
-    end
 
-    def self.convert_to_integer(value, attribute_name)
-      begin
-        value = Integer(value)
-        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+      @draw_context = @app.current_draw_context
 
-        value
-      rescue ArgumentError
-        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
-        raise Shoes::Errors::InvalidAttributeValueError, error_message
-      end
+      create_display_drawable
     end
 
-    def self.convert_to_float(value, attribute_name)
-      begin
-        value = Float(value)
-        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
 
-        value
-      rescue ArgumentError
-        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
-        raise Shoes::Errors::InvalidAttributeValueError, error_message
-      end
-    end
   end
 end

data/lib/shoes/drawables/arrow.rb

@@ -9,33 +9,13 @@ class Shoes
       shoes_style(prop) { |val| val.is_a?(Hash) ? val : convert_to_integer(val, prop) }
     end
 
-    def initialize(*args)
-      @draw_context = Shoes::App.instance.current_draw_context
-
+    init_args :left, :top, :width
+    def initialize(*args, **kwargs)
       super
 
-      if args.length == 1 && args[0].is_a?(Hash)
-        options = args[0]
-        self.left = options[:left]
-        self.top = options[:top]
-        self.width = options[:width]
-      else
-        self.left, self.top, self.width = args
-      end
+      @draw_context = @app.current_draw_context
 
       create_display_drawable
     end
-
-    def self.convert_to_integer(value, attribute_name)
-      begin
-        value = Integer(value)
-        raise Shoes::Errors::InvalidAttributeValueError, "Negative number '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
-
-        value
-      rescue ArgumentError
-        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
-        raise Shoes::Errors::InvalidAttributeValueError, error_message
-      end
-    end
   end
 end

data/lib/shoes/drawables/border.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Border < Shoes::Drawable
+    # Shoes style with verification or value mapping:
+    # shoes_style(:left) { |val| convert_to_integer(val, "left") }
+
+    shoes_styles :stroke, :strokewidth  # Write your shoes styles here
+
+    shoes_style(:strokewidth) { |val| convert_to_integer(val, "strokewidth") }
+    shoes_style(:curve) { |val| convert_to_integer(val, "curve") }
+
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:stroke] = :black
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:strokewidth] = 1
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:curve] = 0
+    
+    opt_init_args :stroke, :strokewidth, :curve
+    def initialize(*args, **kwargs)
+      super
+      @draw_context = @app.current_draw_context
+
+      create_display_drawable
+    end
+
+    private
+
+  end
+end

data/lib/shoes/drawables/button.rb

@@ -2,10 +2,10 @@
 
 class Shoes
   class Button < Shoes::Drawable
-    include Shoes::Log
     shoes_styles :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size, :tooltip
-    shoes_events :click, :hover
+    shoes_events :click
 
+    init_args :text
     # Creates a new Button object.
     #
     # @param text [String] The text displayed on the button.
@@ -32,25 +32,16 @@ class Shoes
     #       )
     #     }
     #   end
-    def initialize(text, width: nil, height: nil, top: nil, left: nil, color: nil, padding_top: nil, padding_bottom: nil, size: 12, text_color: nil,
-      font_size: nil, tooltip: nil, &block)
-
-      log_init("Button")
-
+    def initialize(*args, **kwargs, &block)
       # Properties passed as positional args, not keywords, don't get auto-set
-      @text = text
       @block = block
 
       super
 
-      # Bind to a handler named "click"
+      # Bind block to a handler named "click"
       bind_self_event("click") do
         @log.debug("Button clicked, calling handler") if @block
-        @block&.call
-      end
-
-      bind_self_event("hover") do
-        @hover&.call
+        @block&.call if @block
       end
 
       create_display_drawable
@@ -62,12 +53,5 @@ class Shoes
     def click(&block)
       @block = block
     end
-
-    # Set the hover handler
-    #
-    # @yield A block to be called when the cursor moves to be over the button.
-    def hover(&block)
-      @hover = block
-    end
   end
 end