shoes-core 4.0.0.pre3

data/lib/shoes/common/background_element.rb

@@ -0,0 +1,9 @@
+class Shoes
+  module Common
+    module BackgroundElement
+      def takes_up_space?
+        false
+      end
+    end
+  end
+end

data/lib/shoes/common/changeable.rb

@@ -0,0 +1,34 @@
+class Shoes
+  module Common
+    # Changeable elements are elements that receive `change' events.
+    # These are ListBox, EditBox and EditLine. To have your code respond
+    # to these events, either pass a block in when creating the element,
+    # or call #change on the element with a block.
+    module Changeable
+      # Add an extra change event listener block
+      #
+      # @yield The block to execute on a change event
+      def change(&blk)
+        add_change_listener(blk)
+      end
+
+      # The GUI backend needs to call this when an actual change happens in
+      # the backend.
+      def call_change_listeners
+        change_listeners.each do |listener|
+          listener.call(self)
+        end
+      end
+
+      private
+
+      def change_listeners
+        @change_listeners ||= []
+      end
+
+      def add_change_listener(callable)
+        change_listeners << callable
+      end
+    end
+  end
+end

data/lib/shoes/common/clickable.rb

@@ -0,0 +1,24 @@
+class Shoes
+  module Common
+    module Clickable
+      attr_accessor :pass_coordinates
+
+      def click(&blk)
+        @gui.click blk
+      end
+
+      def release(&blk)
+        @gui.release blk
+      end
+
+      def register_click(blk = nil)
+        click(&@style[:click]) if @style[:click]
+        click(&blk) if blk
+      end
+
+      def pass_coordinates?
+        @pass_coordinates
+      end
+    end
+  end
+end

data/lib/shoes/common/inspect.rb

@@ -0,0 +1,14 @@
+class Shoes
+  module Common
+    module Inspect
+      def to_s
+        "(#{self.class.name})"
+      end
+
+      # Object hex representation from https://github.com/michaeldv/awesome_print
+      def inspect
+        "(#{self.class.name}:#{'0x%08x' % (object_id * 2)})"
+      end
+    end
+  end
+end

data/lib/shoes/common/positioning.rb

@@ -0,0 +1,30 @@
+class Shoes
+  module Common
+    module Positioning
+      # Moves an element to a specific pixel position. The element is still in the slot,
+      # but will no longer be stacked or flowed with the other stuff in the slot.
+      def move(left, top)
+        self.left = left
+        self.top  = top
+        self
+      end
+
+      # NOT part of the public interface e.g. no Shoes APP should use this
+      # however we need it from the Slot code to position elements
+      def _position(left, top)
+        self.absolute_left = left
+        self.absolute_top  = top
+        gui.update_position if gui && gui.respond_to?(:update_position)
+      end
+
+      # displace(left: a number, top: a number) » self
+      # Displacing an element moves it.  But without changing the layout around it.
+      def displace(left, top)
+        self.displace_left = left
+        self.displace_top = top
+        gui.update_position
+        self
+      end
+    end
+  end
+end

data/lib/shoes/common/registration.rb

@@ -0,0 +1,31 @@
+class Shoes
+  module Common
+    module Registration
+      def apps
+        @apps ||= []
+        @apps.dup
+      end
+
+      def register(app)
+        register_main_app app
+        apps && @apps << app
+      end
+
+      def unregister(app)
+        apps && @apps.delete(app)
+      end
+
+      def unregister_all
+        @main_app = nil
+        @apps = []
+      end
+
+      attr_reader :main_app
+
+      # Registers the first app as the main app
+      def register_main_app(app)
+        @main_app ||= app
+      end
+    end
+  end
+end

data/lib/shoes/common/remove.rb

@@ -0,0 +1,10 @@
+class Shoes
+  module Common
+    module Remove
+      def remove
+        parent.remove_child self if parent
+        gui.remove if gui && gui.respond_to?(:remove)
+      end
+    end
+  end
+end

data/lib/shoes/common/state.rb

@@ -0,0 +1,16 @@
+class Shoes
+  module Common
+    module State
+      attr_reader :state
+
+      def state=(value)
+        @state = value
+        @gui.enabled value.nil?
+      end
+
+      def state_options(opts)
+        self.state = opts[:state]
+      end
+    end
+  end
+end

data/lib/shoes/common/style.rb

@@ -0,0 +1,160 @@
+# The general Style module handles the many optional styles that may be passed
+# to shoes elements upon creates as well as the fact that they can later on be
+# altered through the #style method.
+#
+# Relies upon:
+#   @app - a reference to the Shoes applications
+class Shoes
+  module Common
+    module Style
+      DEFAULT_STYLES = {
+        fill:        Shoes::COLORS[:black],
+        rotate:      0,
+        stroke:      Shoes::COLORS[:black],
+        strokewidth: 1
+      }
+
+      STYLE_GROUPS = {
+        art_styles:           [:cap, :click, :fill, :rotate, :stroke, :strokewidth, :transform, :translate],
+        common_styles:        [:displace_left, :displace_top, :hidden],
+        dimensions:           [:bottom, :height, :left, :margin,
+                               :margin_bottom, :margin_left, :margin_right,
+                               :margin_top, :right, :top, :width],
+        text_block_styles:    [:align, :click, :emphasis, :family, :fill, :font,
+                               :justify, :kerning, :leading, :rise, :size, :stretch,
+                               :strikecolor, :strikethrough, :stroke, :undercolor,
+                               :underline, :weight, :wrap],
+      }
+
+      # Adds styles, or just returns current style if no argument
+      def style(new_styles = nil)
+        update_style(new_styles) if need_to_update_style?(new_styles)
+        update_dimensions if styles_with_dimensions?
+        @style
+      end
+
+      def style_init(arg_styles, new_styles = {})
+        default_element_styles = {}
+        default_element_styles = self.class::STYLES if defined? self.class::STYLES
+
+        create_style_hash
+        merge_app_styles
+        @style.merge!(default_element_styles)
+        @style.merge!(@app.element_styles[self.class]) if @app.element_styles[self.class]
+        @style.merge!(new_styles)
+        @style.merge!(arg_styles)
+        @style = StyleNormalizer.new.normalize(@style)
+      end
+
+      def create_style_hash
+        @style = {}
+        supported_styles.each do |key|
+          @style[key] = nil
+        end
+      end
+
+      def merge_app_styles
+        @app.style.each do |key, val|
+          @style[key] = val if supported_styles.include? key
+        end
+      end
+
+      module StyleWith
+        def style_with(*styles)
+          @supported_styles = []
+
+          unpack_style_groups(styles)
+          define_reader_methods
+          define_writer_methods
+        end
+
+        def unpack_style_groups(styles)
+          styles.each do |style|
+            if STYLE_GROUPS[style]
+              STYLE_GROUPS[style].each { |group_style| support_style group_style }
+            else
+              support_style style
+            end
+          end
+
+          supported_styles = @supported_styles
+
+          define_method("supported_styles") do
+            supported_styles
+          end
+        end
+
+        def define_reader_methods
+          needs_readers = @supported_styles.reject do |style|
+            self.method_defined?(style)
+          end
+
+          needs_readers.map(&:to_sym).each do |style|
+            define_method style do
+              @style[style]
+            end
+          end
+        end
+
+        def define_writer_methods
+          needs_writers = @supported_styles.reject do |style|
+            self.method_defined?("#{style}=")
+          end
+
+          needs_writers.map(&:to_sym).each do |style_key|
+            define_method "#{style_key}=" do |new_style|
+              send("style", style_key.to_sym => new_style)
+            end
+          end
+        end
+
+        private
+        def support_style group_style
+          @supported_styles << group_style
+        end
+      end # end of StyleWith module
+
+      def self.included(klass)
+        klass.extend StyleWith
+      end
+
+      private
+
+      def update_style(new_styles)
+        normalized_style = StyleNormalizer.new.normalize(new_styles)
+        set_dimensions(new_styles)
+        click(&new_styles[:click]) if new_styles.key?(:click)
+        @style.merge! normalized_style
+      end
+
+      # if dimension is set via style, pass info on to the dimensions setter
+      def set_dimensions(new_styles)
+        new_styles.each do |key, value|
+          send("#{key}=", value) if STYLE_GROUPS[:dimensions].include?(key)
+        end
+      end
+
+      def update_dimensions # so that @style hash matches actual values
+        STYLE_GROUPS[:dimensions].each do |style|
+          @style[style] = send(style) if self.respond_to? style
+        end
+      end
+
+      def styles_with_dimensions?
+        STYLE_GROUPS[:dimensions].any? { |dimension| @style.key? dimension }
+      end
+
+      def need_to_update_style?(new_styles)
+        new_styles && style_changed?(new_styles)
+      end
+
+      # check necessary because update_style triggers a redraw in the redrawing
+      # aspect and we want to avoid unnecessary redraws
+      def style_changed?(new_styles)
+        new_styles.each_pair.any? do |key, value|
+          @style[key] != value
+        end
+      end
+    end
+  end
+end

data/lib/shoes/common/style_normalizer.rb

@@ -0,0 +1,16 @@
+class Shoes
+  module Common
+    class StyleNormalizer
+      include Color::DSLHelpers
+      def normalize(orig_style)
+        normalized_style = {}
+        [:fill, :stroke].each do |s|
+          if orig_style[s]
+            normalized_style[s] = pattern(orig_style[s])
+          end
+        end
+        orig_style.merge(normalized_style)
+      end
+    end
+  end
+end

data/lib/shoes/common/ui_element.rb

@@ -0,0 +1,11 @@
+class Shoes
+  module Common
+    module UIElement
+      include Common::Inspect
+      include Common::Visibility
+      include Common::Positioning
+      include Common::Remove
+      include DimensionsDelegations
+    end
+  end
+end

data/lib/shoes/common/visibility.rb

@@ -0,0 +1,41 @@
+class Shoes
+  module Common
+    module Visibility
+      # Hides the element, so that it can't be seen. See also #show and #toggle.
+      def hide
+        @hidden = true
+        update_visibility
+      end
+
+      def hidden?
+        @hidden
+      end
+
+      alias_method :hidden, :hidden?
+
+      def visible?
+        !hidden?
+      end
+
+      # Reveals the element, if it is hidden. See also #hide and #toggle.
+      def show
+        @hidden = false
+        update_visibility
+      end
+
+      # Hides an element if it is shown. Or shows the element, if it is hidden.
+      # See also #hide and #show.
+      def toggle
+        @hidden = !@hidden
+        update_visibility
+      end
+
+      private
+
+      def update_visibility
+        gui.update_visibility
+        self
+      end
+    end
+  end
+end

data/lib/shoes/configuration.rb

@@ -0,0 +1,96 @@
+class Shoes
+  class Configuration
+    class << self
+      def reset
+        @logger = nil
+        @logger_instance = nil
+      end
+
+      def backend
+        @backend ||= Shoes.load_backend(backend_name)
+      end
+
+      def backend_name
+        @backend_name ||= ENV.fetch('SHOES_BACKEND', default_backend).to_sym
+      end
+
+      def default_backend
+        if caller.any? { |path| path =~ /rspec/ }
+          :mock
+        else
+          :swt
+        end
+      end
+
+      # The Shoes backend to use. Can only be set once.
+      #
+      # @param [Symbol] backend The backend's name
+      # @return [Module] The backend's root module
+      # @example
+      #   Shoes::Configuration.backend = :swt # => Shoes::Swt
+      def backend=(name)
+        unless @backend.nil?
+          fail "Can't switch backend to Shoes::#{name.capitalize}, Shoes::#{backend_name.capitalize} backend already loaded."
+        end
+        @backend_name ||= name
+      end
+
+      # Finds the appropriate backend class for the given Shoes object
+      #
+      # @param [Object] shoes_object A Shoes object
+      # @return [Object] An appropriate backend class
+      # @example
+      #   Shoes.configuration.backend_class(shoes_button) # => Shoes::Swt::Button
+      def backend_class(shoes_object)
+        class_name = shoes_object.class.name.split("::").last
+        fail ArgumentError, "#{shoes_object} does not have a backend class defined for #{backend}" unless backend.const_defined?(class_name)
+        backend.const_get(class_name)
+      end
+
+      # Creates an appropriate backend object, passing along additional arguments
+      #
+      # @param [Object] shoes_object A Shoes object
+      # @return [Object] An appropriate backend object
+      # @example
+      #   Shoes.configuration.backend_for(button, args) # => <Shoes::Swt::Button:0x12345678>
+      def backend_for(shoes_object, *args)
+        backend_factory(shoes_object).call(shoes_object, *args)
+      end
+
+      # Experimental replacement for #backend_for
+      def backend_with_app_for(shoes_object, *args, &blk)
+        backend_factory(shoes_object).call(shoes_object, shoes_object.app.gui, *args, &blk)
+      end
+
+      def backend_factory(shoes_object)
+        klass = backend_class(shoes_object)
+        klass.respond_to?(:create) ? klass.method(:create) : klass.method(:new)
+      end
+
+      def logger=(value)
+        @logger = value
+        @logger_instance = nil
+      end
+
+      def logger
+        @logger ||= :ruby
+      end
+
+      def logger_instance
+        @logger_instance ||= Shoes::Logger.get(logger).new
+      end
+    end
+  end
+end
+
+def Shoes.configuration
+  Shoes::Configuration
+end
+
+def Shoes.backend_for(shoes_object, *args, &blk)
+  Shoes::Configuration.backend_with_app_for(shoes_object, *args, &blk)
+end
+
+def Shoes.backend
+  Shoes.configuration.backend
+end