cura 0.0.1

data/lib/cura/attributes/has_orientation.rb

@@ -0,0 +1,53 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `orientation` attribute to objects, which can be :vertical or :horizontal.
+    module HasOrientation
+      
+      include HasAttributes
+      
+      def initialize(attributes={})
+        @orientation = :vertical unless instance_variable_defined?(:@orientation)
+        
+        super
+      end
+      
+      # Get the orientation of this object.
+      # 
+      # @return [Symbol]
+      attr_reader :orientation
+      
+      # Set the orientation of this object.
+      # Must be :vertical or :horizontal.
+      # 
+      # @param [#to_sym] value
+      # @return [Symbol]
+      def orientation=(value)
+        value = value.to_sym
+        raise ArgumentError, "orientation must be one of :vertical or :horizontal" unless [:vertical, :horizontal].include?(value)
+        
+        @orientation = value
+      end
+      
+      # Check if this object's orientation is set to :horizontal.
+      # 
+      # @return [Boolean]
+      def horizontal?
+        orientation == :horizontal
+      end
+      
+      # Check if this object's orientation is set to :vertical.
+      # 
+      # @return [Boolean]
+      def vertical?
+        orientation == :vertical
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_relative_coordinates.rb

@@ -0,0 +1,39 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_ancestry"
+  require "cura/attributes/has_coordinates"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `absolute_x` and `absolute_y` attributes, which are relative to it's parent.
+    module HasRelativeCoordinates
+      
+      include HasAncestry
+      include HasCoordinates
+      
+      def initialize(attributes={})
+        @absolute_x = 0
+        @absolute_y = 0
+        
+        super
+      end
+      
+      # Get the absolute X coordinate of this object.
+      #
+      # @return [Integer]
+      def absolute_x
+        parent? && parent.respond_to?(:absolute_x) ? @x + parent.offsets.left + parent.absolute_x : @x
+      end
+      
+      # Get the absolute Y coordinate of this object.
+      #
+      # @return [Integer]
+      def absolute_y
+        parent? && parent.respond_to?(:absolute_y) ? @y + parent.offsets.top + parent.absolute_y : @y
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_root.rb

@@ -0,0 +1,104 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+  
+  require "cura/component/group"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `root` attribute to an object, which defaults to a Component::Group.
+    module HasRoot
+      
+      include Attributes::HasAttributes
+      
+      def initialize(attributes={})
+        @root = Component::Group.new(parent: self)
+        
+        super
+      end
+      
+      # @method root
+      # Get root component for this object.
+      #
+      # @return [Component::Group]
+      
+      # @method root=(component)
+      # Set root component for this object.
+      #
+      # @param [Component::Group] component
+      # @return [Component::Group]
+      
+      attribute(:root) { |component| set_root(component) }
+      
+      # Delegates -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+      
+      # Get the children of this object.
+      #
+      # @return [<Component>]
+      def children(recursive=false)
+        @root.children(recursive)
+      end
+      
+      # Add a child to this object's root component.
+      #
+      # @param [Component] component
+      # @return [Component]
+      def add_child(component)
+        @root.add_child(component)
+      end
+      
+      # Add multiple children to this object's root component.
+      #
+      # @param [<Component>] children
+      # @return [<Component>]
+      def add_children(*children)
+        @root.add_children(*children)
+      end
+      
+      # Remove a child from object's root component at the given index.
+      #
+      # @param [Integer] index
+      # @return [Component]
+      def delete_child_at(index)
+        @root.delete_child_at(index)
+      end
+      
+      # Remove a child from this object's root component.
+      #
+      # @param [Component] component
+      # @return [Component]
+      def delete_child(component)
+        @root.delete_child(component)
+      end
+      
+      # Remove all children from object's root component.
+      #
+      # @return [HasChildren]
+      def delete_children
+        @root.delete_children
+      end
+    
+      # Determine if this object's root component has children.
+      #
+      # @return [Boolean]
+      def children?
+        @root.children?
+      end
+      
+      protected
+      
+      def set_root(component)
+        raise TypeError, "root must be a Component::Group" unless component.is_a?(Component::Group)
+        
+        @root.parent = nil unless @root.nil?
+        @root = component
+        @root.parent = self
+        
+        @root
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_side_attributes.rb

@@ -0,0 +1,95 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  module Attributes
+    
+    # Adds the `top`, `right`, `bottom`, `left`, `width`, and `height` attributes to objects.
+    module HasSideAttributes
+      
+      include HasAttributes
+      
+      # @method top
+      # Get the top attribute.
+      #
+      # @return [Integer]
+      
+      # @method top=(value)
+      # Set the top attribute.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:top) { |value| validate_size_attribute(value) }
+      
+      # @method right
+      # Get the right attribute.
+      #
+      # @return [Integer]
+      
+      # @method right=(value)
+      # Set the right attribute.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:right) { |value| validate_size_attribute(value) }
+      
+      # @method bottom
+      # Get the bottom attribute.
+      #
+      # @return [Integer]
+      
+      # @method bottom=(value)
+      # Set the bottom attribute.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:bottom) { |value| validate_size_attribute(value) }
+      
+      # @method left
+      # Get the left attribute.
+      #
+      # @return [Integer]
+      
+      # @method left=(value)
+      # Set the left attribute.
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:left) { |value| validate_size_attribute(value) }
+      
+      def initialize(attributes={})
+        @top = 0 unless instance_variable_defined?(:@top)
+        @right = 0 unless instance_variable_defined?(:@right)
+        @bottom = 0 unless instance_variable_defined?(:@bottom)
+        @left = 0 unless instance_variable_defined?(:@left)
+        
+        unless attributes.respond_to?(:to_hash) || attributes.respond_to?(:to_h)
+          attributes = { top: attributes, right: attributes, bottom: attributes, left: attributes } # Set all side attributes to the argument given
+        end
+        
+        super
+      end
+      
+      # Get the total height of the attributes.
+      #
+      # @return [Integer]
+      def height
+        @top + @bottom
+      end
+      
+      # Get the total width of the attributes.
+      #
+      # @return [Integer]
+      def width
+        @left + @right
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/attributes/has_windows.rb

@@ -0,0 +1,70 @@
+if Kernel.respond_to?(:require)
+  require "cura/window"
+end
+
+module Cura
+  module Attributes
+    
+    # Allows an object to have windows.
+    # TODO: Lots of code is the same as HasChildren
+    module HasWindows
+      
+      def initialize(*arguments)
+        @windows = []
+        
+        super
+      end
+      
+      # Get the windows of this object.
+      attr_reader :windows
+      
+      # Add a window to this object.
+      #
+      # @param [Window] window
+      # @return [Window]
+      def add_window(window)
+        raise TypeError, "window must be a Cura::Window" unless window.is_a?(Window)
+        
+        @windows << window
+        
+        window
+      end
+      
+      # Remove a window from this object's windows at the given index.
+      #
+      # @param [#to_i] index
+      # @return [Window]
+      def delete_window_at(index)
+        @windows.delete_at(index.to_i)
+      end
+      
+      # Remove a window from this object's windows.
+      #
+      # @param [Window] window
+      # @return [Window]
+      def delete_window(window)
+        raise TypeError, "window must be a Cura::Window" unless window.is_a?(Window)
+        index = @windows.index(window)
+        
+        delete_window_at(index)
+      end
+      
+      # Remove all windows.
+      def delete_windows
+        (0...@windows.count).to_a.each { |index| delete_window_at(index) }
+      end
+      
+      protected # TODO: These should be protected?
+      
+      def update_windows
+        windows.each(&:update)
+      end
+      
+      def draw_windows
+        windows.each(&:draw)
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/borders.rb

@@ -0,0 +1,16 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_initialize"
+  require "cura/attributes/has_side_attributes"
+end
+
+module Cura
+  
+  # The border side attributes of a component.
+  class Borders
+    
+    include Attributes::HasInitialize
+    include Attributes::HasSideAttributes
+    
+  end
+  
+end

data/lib/cura/color.rb

@@ -0,0 +1,330 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_initialize"
+  require "cura/attributes/has_attributes"
+end
+
+module Cura
+  
+  # Colors.
+  class Color
+    
+    include Attributes::HasInitialize
+    include Attributes::HasAttributes
+    
+    class << self
+      
+      # The default color to be overidden by adapters.
+      # Usually, for TUI's to use the terminal theme's colors.
+      # TODO: Remove.
+      def default
+        super
+      end
+      
+      def black
+        new
+      end
+      
+      def white
+        new(255, 255, 255)
+      end
+      
+      def red
+        new(255, 0, 0)
+      end
+      
+      def green
+        new(0, 255, 0)
+      end
+      
+      def blue
+        new(0, 0, 255)
+      end
+      
+    end
+    
+    def initialize(r=0, g=0, b=0, a=255)
+      if r.respond_to?(:to_h)
+        super(r.to_h)
+      else
+        @red   = r
+        @green = g
+        @blue  = b
+        @alpha = a
+      end
+      
+      @lab = rgb_to_lab([@red, @green, @blue]) # TODO: Update on rgb setters?
+    end
+    
+    # @method red
+    # Get the red channel of this color.
+    #
+    # @return [Integer]
+    
+    # @method red=(value)
+    # Set the red channel of this color.
+    #
+    # @param [#to_i] value
+    # @return [Integer]
+    
+    # @method green
+    # Get the green channel of this color.
+    #
+    # @return [Integer]
+    
+    # @method green=(value)
+    # Set the green channel of this color.
+    #
+    # @param [#to_i] value
+    # @return [Integer]
+    
+    # @method blue=(value)
+    # Get the blue channel of this color.
+    #
+    # @return [Integer]
+    
+    # @method blue=(value)
+    # Set the blue channel of this color.
+    #
+    # @param [#to_i] value
+    # @return [Integer]
+    
+    # @method alpha
+    # Get the alpha channel of this color.
+    #
+    # @return [Integer]
+    
+    # @method alpha=(value)
+    # Set the alpha channel of this color.
+    #
+    # @param [#to_i] value
+    # @return [Integer]
+    
+    [:red, :green, :blue, :alpha].each do |channel|
+      attribute(channel) { |value| convert_and_constrain_value(value) }
+    end
+    
+    attr_reader :lab
+    
+    def -(other)
+      delta_e_2000(@lab, other.lab)
+    end
+
+    def <=>(other)
+      self.hsl[0] <=> other.hsl[0]
+    end
+    
+    # Determing if this color is equivalent to another object.
+    #
+    # @param [Object] other
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Color) ? matches_color?(other) : super
+    end
+    
+    def hsl
+      @hsl ||= rgb_to_hsl(@rgb)
+    end
+
+    def yiq
+      @yiq ||= rgb_to_yiq(@rgb)
+    end
+    
+    def to_a
+      [@red, @green, @blue, @alpha]
+    end
+    
+    def hex
+      to_a.each_with_object("") { |part, memo| memo << "%02x" % part }
+    end
+    
+    protected
+    
+    def matches_color?(other)
+      @alpha == other.alpha && @red == other.red && @green == other.green && @blue && other.blue
+    end
+    
+    # Convert the input to an Integer and constrain in or between 0 and 255.
+    def convert_and_constrain_value(value)
+      value = value.to_i
+      
+      [255, [0, value].max].min
+    end
+
+    # source: http://www.easyrgb.com/index.php?X=MATH&H=02#text2
+    def rgb_to_xyz(color)
+      r, g, b = color.map do |v|
+          v /= 255.0
+          if v > 0.04045
+              v = ((v + 0.055 ) / 1.055)**2.4
+          else
+              v = v / 12.92
+          end
+          v *= 100
+      end
+
+      #Observer = 2°, Illuminant = D65
+      x = r * 0.4124 + g * 0.3576 + b * 0.1805
+      y = r * 0.2126 + g * 0.7152 + b * 0.0722
+      z = r * 0.0193 + g * 0.1192 + b * 0.9505
+
+      return [x, y, z]
+    end
+
+    def xyz_to_lab(color)
+      f = lambda { |t|
+        return t**(1.0/3) if t > (6.0 / 29)**3
+        return (1.0 / 3) * ((29.0 / 6)**2) * t + (4.0 / 29)
+      }
+
+      x, y, z = color
+      xn, yn, zn = rgb_to_xyz([255, 255, 255])
+      l = 116 * f.call(y/yn) - 16
+      a = 500 * (f.call(x/xn) - f.call(y/yn))
+      b = 200 * (f.call(y/yn) - f.call(z/zn))
+
+      return [l, a, b]
+    end
+
+    def rgb_to_lab(rgb_val)
+      xyz_to_lab rgb_to_xyz rgb_val
+    end
+
+    def rgb_to_hsl(rgb_val)
+      r, g, b = rgb_val.map { |v| v / 255.0 }
+
+      min, max = [r, g, b].minmax
+      delta = max - min
+
+      lig = (max + min) / 2.0
+
+      if delta == 0
+         hue = 0
+         sat = 0
+      else
+         sat = if lig < 0.5
+                 delta / (0.0 + (max + min))
+               else
+                 delta / (2.0 - max - min)
+               end
+
+         delta_r = (((max - r) / 6.0 ) + (delta / 2.0)) / delta
+         delta_g = (((max - g) / 6.0 ) + (delta / 2.0)) / delta
+         delta_b = (((max - b) / 6.0 ) + (delta / 2.0)) / delta
+
+         hue = case max
+               when r then delta_b - delta_g
+               when g then (1.0/3) + delta_r - delta_b
+               when b then (2.0/3) + delta_g - delta_r
+               end
+
+         hue += 1 if hue < 0
+         hue -= 1 if hue > 1
+      end
+
+      [360 * hue, 100 * sat, 100 * lig]
+    end
+
+    def rgb_to_yiq(rgb_val)
+      r, g, b = rgb_val
+
+      y = 0.299*r + 0.587*g + 0.114*b
+      i = 0.569*r - 0.275*g - 0.321*b
+      q = 0.212*r - 0.523*g + 0.311*b
+
+      [y, i, q]
+    end
+
+    def rad_to_deg(v)
+      (v * 180) / Math::PI
+    end
+
+    def deg_to_rad(v)
+      (v * Math::PI) / 180
+    end
+    
+    def lab_to_hue(a, b)
+      bias = 0
+      return 0 if (a >= 0 && b == 0)
+      return 180 if (a <  0 && b == 0)
+      return 90 if (a == 0 && b > 0)
+      return 270 if (a == 0 && b < 0)
+
+      bias = case
+      when a > 0 && b > 0 then 0
+      when a < 0 then 180
+      when a > 0 && b < 0 then 360
+      end
+
+      rad_to_deg(Math.atan(b / a)) + bias
+    end
+    
+    def delta_e_2000(lab1, lab2)
+      l1, a1, b1 = lab1
+      l2, a2, b2 = lab2
+      kl, kc, kh = [1, 1, 1]
+
+      xC1 = Math.sqrt(a1**2 + b1**2)
+      xC2 = Math.sqrt(a2**2 + b2**2)
+      xCX = (xC1 + xC2) / 2
+      xGX = 0.5 * (1 - Math.sqrt(xCX**7 / (xCX**7 + 25**7)))
+      xNN = (1 + xGX) * a1
+      xC1 = Math.sqrt(xNN**2 + b1**2)
+      xH1 = lab_to_hue(xNN, b1)
+      xNN = (1 + xGX) * a2
+      xC2 = Math.sqrt(xNN**2 + b2**2)
+      xH2 = lab_to_hue(xNN, b2)
+      xDL = l2 - l1
+      xDC = xC2 - xC1
+      if (xC1 * xC2) == 0
+        xDH = 0
+      else
+        xNN = (xH2 - xH1).round(12)
+        if xNN.abs <= 180
+          xDH = xH2 - xH1
+        else
+          if xNN > 180
+            xDH = xH2 - xH1 - 360
+          else
+            xDH = xH2 - xH1 + 360
+          end
+        end
+      end
+      xDH = 2 * Math.sqrt(xC1 * xC2) * Math.sin(deg_to_rad(xDH / 2.0))
+      xLX = (l1 + l2) / 2.0
+      xCY = (xC1 + xC2) / 2.0
+      if xC1 * xC2 == 0
+        xHX = xH1 + xH2
+      else
+        xNN = (xH1 - xH2).round(12).abs
+        if xNN > 180
+          if xH2 + xH1 < 360
+            xHX = xH1 + xH2 + 360
+          else
+            xHX = xH1 + xH2 - 360
+          end
+        else
+          xHX = xH1 + xH2
+        end
+        xHX /= 2.0
+      end
+      xTX = 1 - 0.17 * Math.cos(deg_to_rad(xHX - 30)) + 0.24 *
+                       Math.cos(deg_to_rad(2 * xHX)) + 0.32 *
+                       Math.cos(deg_to_rad(3 * xHX + 6)) - 0.20 *
+                       Math.cos(deg_to_rad(4 * xHX - 63 ))
+      xPH = 30 * Math.exp(-((xHX - 275) / 25.0) * ((xHX  - 275) / 25.0))
+      xRC = 2 * Math.sqrt(xCY**7 / (xCY**7 + 25**7))
+      xSL = 1 + ((0.015 * ((xLX - 50) * (xLX - 50))) /
+            Math.sqrt(20 + ((xLX - 50) * (xLX - 50))))
+      xSC = 1 + 0.045 * xCY
+      xSH = 1 + 0.015 * xCY * xTX
+      xRT = -Math.sin(deg_to_rad(2 * xPH)) * xRC
+      xDL = xDL / (kl * xSL)
+      xDC = xDC / (kc * xSC)
+      xDH = xDH / (kh * xSH)
+
+      Math.sqrt(xDL**2 + xDC**2 + xDH**2 + xRT * xDC * xDH)
+    end
+    
+  end
+  
+end