shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/common/background_element.rb

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

data/lib/shoes/common/changeable.rb

@@ -1,34 +0,0 @@
-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

@@ -1,17 +0,0 @@
-class Shoes
-  module Common
-    module Clickable
-      def click(&blk)
-        @gui.click &blk
-      end
-
-      def release(&blk)
-        @gui.release &blk
-      end
-
-      def clickable_options(opts)
-        click(&opts[:click]) if opts[:click]
-      end
-    end
-  end
-end

data/lib/shoes/common/common_methods.rb

@@ -1,70 +0,0 @@
-# -*- coding: utf-8 -*-
-class Shoes
-  # Methods common to Shoes gui elements.
-  #
-  # Classes that include this module must expose:
-  #
-  # gui_container - the "real" framework implementation object
-  module CommonMethods
-
-    # Hides the element, so that it can't be seen. See also #show and #toggle.
-    def hide
-      @hidden = false
-      toggle
-    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 = true
-      toggle
-    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
-      @gui.toggle
-      self
-    end
-
-    # 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
-
-    def remove
-      @parent.contents.delete self if @parent
-      @gui.clear if @gui
-    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

data/lib/shoes/common/fill.rb

@@ -1,21 +0,0 @@
-class Shoes
-  module Common
-    # Methods for objects with fill
-    #
-    # @note Including classes must provide `#style`
-    module Fill
-      DEFAULTS = {
-        :fill   => Shoes::COLORS[:black]
-      }
-
-      def fill
-        style[:fill]
-      end
-
-      def fill=(color)
-        style[:fill] = color
-      end
-    end
-  end
-end
-

data/lib/shoes/common/registration.rb

@@ -1,33 +0,0 @@
-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
-
-      def main_app
-        @main_app
-      end
-
-      # Registers the first app as the main app
-      def register_main_app(app)
-        @main_app ||= app
-      end
-    end
-  end
-end

data/lib/shoes/common/state.rb

@@ -1,18 +0,0 @@
-class Shoes
-  module Common
-    module State
-      def state
-        @state
-      end
-
-      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/stroke.rb

@@ -1,28 +0,0 @@
-class Shoes
-  module Common
-    # Methods for objects with stroke
-    #
-    # @note Including classes must provide `#style`
-    module Stroke
-      DEFAULTS = {
-        :stroke => Shoes::COLORS[:black]
-      }
-
-      def stroke
-        style[:stroke]
-      end
-
-      def stroke=(color)
-        style[:stroke] = color
-      end
-
-      def strokewidth
-        style[:strokewidth]
-      end
-
-      def strokewidth=(width)
-        style[:strokewidth] = width
-      end
-    end
-  end
-end

data/lib/shoes/common/style.rb

@@ -1,34 +0,0 @@
-class Shoes
-  module Common
-    # Style methods.
-    #
-    # Including classes must have instance variable `@style`
-    module Style
-      # Adds style, or just returns current style if no argument
-      #
-      # Returns the updated style
-      def style(new_styles = nil)
-        update_style(new_styles) if need_to_update_style?(new_styles)
-        @style
-      end
-
-      private
-      def update_style(new_styles)
-        normalized_style = StyleNormalizer.new.normalize new_styles
-        @style.merge! normalized_style
-      end
-
-      def need_to_update_style?(new_styles)
-        new_styles && style_changed?(new_styles)
-      end
-
-      # check necessary because update_style trigger 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

@@ -1,16 +0,0 @@
-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/configuration.rb

@@ -1,96 +0,0 @@
-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?
-          raise "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
-        raise ArgumentError, "#{shoes_object} does not have a backend class defined for #{backend}" unless self.backend.const_defined?(class_name)
-        self.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(self.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

data/lib/shoes/dialog.rb

@@ -1,27 +0,0 @@
-class Shoes
-  class Dialog
-    def initialize
-      @gui = Shoes.backend::Dialog.new
-    end
-
-    def alert(msg = '')
-      @gui.alert msg
-    end
-
-    def confirm(msg = '')
-      @gui.confirm msg
-    end
-    
-    def dialog_chooser title, folder=false
-      @gui.dialog_chooser title, folder
-    end
-
-    def ask msg, args
-      @gui.ask msg, args
-    end
-
-    def ask_color title
-      @gui.ask_color title
-    end
-  end
-end

data/lib/shoes/dimension.rb

@@ -1,237 +0,0 @@
-class Shoes
-  class Dimension
-    attr_reader :parent
-    attr_accessor :absolute_start
-    protected :parent # we shall not mess with parent,see #495
-
-    # in case you wonder about the -1... it is used to adjust the right and
-    # bottom values. Because right is not left + width but rather left + width -1
-    # Let me give you an example:
-    # Say left is 20 and we have a width of 100 then the right must be 119,
-    # because you have to take pixel number 20 into account so 20..119 is 100
-    # while 20..120 is 101. E.g.:
-    # (20..119).size => 100
-    PIXEL_COUNTING_ADJUSTMENT = -1
-
-    def initialize(parent = nil, start_as_center = false)
-      @parent          = parent
-      @start_as_center = start_as_center
-    end
-
-    def start
-      value = basic_start_value
-      value = adjust_start_for_center(value) if start_as_center?
-      value
-    end
-
-    def end
-      @end || report_relative_to_parent_end
-    end
-
-    def extent
-      result = @extent
-      if @parent
-        result = calculate_relative(result) if is_relative?(result)
-        result = calculate_negative(result) if is_negative?(result)
-      end
-      result
-    end
-
-    def extent=(value)
-      @extent = value
-      @extent = parse_from_string @extent if is_string? @extent
-      @extent
-    end
-
-    def absolute_end
-      return absolute_start if extent.nil?
-      absolute_start + extent + PIXEL_COUNTING_ADJUSTMENT
-    end
-
-    def element_extent
-      my_extent = extent
-      if my_extent.nil?
-        nil
-      else
-        extent - (margin_start + margin_end)
-      end
-    end
-    
-    def element_extent=(value)
-      self.extent = if value.nil?
-                      nil
-                    else
-                      margin_start + value + margin_end
-                    end
-    end
-
-    def element_start
-      return nil if absolute_start.nil?
-      absolute_start + margin_start + displace_start
-    end
-
-    def element_end
-      return nil if element_start.nil? || element_extent.nil?
-      element_start + element_extent + PIXEL_COUNTING_ADJUSTMENT
-    end
-
-    def absolute_start_position?
-      not @start.nil?
-    end
-
-    def absolute_end_position?
-      not @end.nil?
-    end
-
-    def absolute_position?
-      absolute_start_position? || absolute_end_position?
-    end
-
-    def positioned?
-      absolute_start
-    end
-
-    def in_bounds?(value)
-      (absolute_start <= value) && (value <= absolute_end)
-    end
-
-    # For... reasons it is important to have the value of the instance variable
-    # set to nil if it's not modified and then return a default value on the
-    # getter... reason being that for ParentDimensions we need to be able to
-    # figure out if a value has been modified or if we should consulte the
-    # parent value - see ParentDimension implementation
-    [:margin_start, :margin_end, :displace_start].each do |method|
-      define_method method do
-        instance_variable_name = '@' + method.to_s
-        instance_variable_get(instance_variable_name) || 0
-      end
-    end
-
-    def self.define_int_parsing_writer(name)
-      define_method "#{name}=" do |value|
-        instance_variable_set("@#{name}", parse_int_value(value))
-      end
-    end
-
-    %w(start end margin_start margin_end displace_start).each do |method|
-      define_int_parsing_writer method
-    end
-
-    private
-    def basic_start_value
-      value = @start
-      value = calculate_relative value if is_relative?(value)
-      value = report_relative_to_parent_start if value.nil?
-      value
-    end
-
-    def is_relative?(result)
-      # as the value is relative to the parent values bigger than one don't
-      # make much sense and are problematic. E.g. through calculations users
-      # might end up with values like 5.14 meaning 5 pixel which would get
-      # interpreted as 514% of the parent
-      # Also check for existance of parent because otherwise relative
-      # calculation makes no sense
-      result.is_a?(Float) && result <= 1 && @parent
-    end
-
-    def calculate_relative(result)
-      (result * @parent.element_extent).to_i
-    end
-
-    def is_string?(result)
-      result.is_a?(String)
-    end
-
-    def is_negative?(result)
-      result && result < 0
-    end
-
-    def calculate_negative(result)
-      @parent.element_extent + result
-    end
-
-    PERCENT_REGEX = /(-?\d+(\.\d+)*)%/
-
-    def parse_from_string(result)
-      match = result.gsub(/\s+/, "").match(PERCENT_REGEX)
-      if match
-        match[1].to_f / 100.0
-      elsif valid_integer_string?(result)
-        int_from_string(result)
-      else
-        nil
-      end
-    end
-
-    def parse_int_value(input)
-      if input.is_a?(Integer) || input.is_a?(Float)
-        input
-      elsif valid_integer_string?(input)
-        int_from_string(input)
-      else
-        nil
-      end
-    end
-
-    def int_from_string(result)
-      (result.gsub(' ', '')).to_i
-    end
-
-    NUMBER_REGEX = /^-?\s*\d+/
-
-    def valid_integer_string?(input)
-      input.is_a?(String) && input.match(NUMBER_REGEX)
-    end
-
-    def report_relative_to_parent_start
-      if element_start && parent.element_start
-        element_start - parent.element_start
-      else
-        nil
-      end
-    end
-
-    def report_relative_to_parent_end
-      if element_end && parent.element_end
-        parent.element_end - element_end
-      else
-        nil
-      end
-    end
-
-    def start_as_center?
-      @start_as_center
-    end
-
-    def adjust_start_for_center(value)
-      my_extent = extent
-      if my_extent && my_extent > 0
-        value - my_extent / 2
-      else
-        nil
-      end
-    end
-  end
-
-  class ParentDimension < Dimension
-    SIMPLE_DELEGATE_METHODS = [:extent, :absolute_start, :margin_start,
-                               :margin_end, :start]
-
-    SIMPLE_DELEGATE_METHODS.each do |method|
-      define_method method do
-        if value_modified? method
-          super
-        else
-          parent.public_send(method)
-        end
-      end
-    end
-
-    private
-    def value_modified?(method)
-      instance_variable = ('@' + method.to_s).to_sym
-      instance_variable_get(instance_variable)
-    end
-  end
-end