fidgit 0.0.2alpha

data/lib/fidgit/elements/packer.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Fidgit
+  # Container that auto-packs elements.
+  #
+  # @abstract
+  class Packer < Container
+    attr_reader :spacing_h, :spacing_v
+
+    # @param (see Container#initialize)
+    #
+    # @option (see Container#initialize)
+    def initialize(options = {})
+      options = {
+      }.merge! options
+
+      @spacing_h = options[:spacing_h] || options[:spacing] || default(:spacing_h)
+      @spacing_v = options[:spacing_v] || options[:spacing] || default(:spacing_v)
+
+      super(options)
+    end
+
+    protected
+    # Recalculate the size of the container.
+    # Should be overridden by any descendant that manages the positions of its children.
+    def layout
+      # This assumes that the container overlaps all the children.
+
+      # Move all children if we have moved.
+      @children.each.with_index do |child, index|
+        child.x = padding_left + x
+        child.y = padding_top + y
+      end
+
+      # Make us as wrap around the largest child.
+      rect.width = (@children.map {|c| c.width }.max || 0) + padding_left + padding_right
+      rect.height = (@children.map {|c| c.height }.max || 0) + padding_top + padding_bottom
+
+      super
+    end
+  end
+end

data/lib/fidgit/elements/radio_button.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Fidgit
+  class RadioButton < Button
+    attr_reader :group, :value
+
+    event :changed
+
+    def checked?; @checked; end
+
+    # @param (see Button#initialize)
+    # @param [Object] value
+    #
+    # @option (see Button#initialize)
+    # @option options [Boolean] :checked
+    def initialize(text, value, options = {}, &block)
+      options = {
+        checked: false,
+        checked_border_color: default(:checked, :border_color),
+      }.merge! options
+
+      @checked = options[:checked]
+      @value = value
+
+      super(text, options)
+
+      @checked_border_color = options[:checked_border_color].dup
+      @unchecked_border_color = border_color
+      add_to_group
+
+      @border_color = (checked? ? @checked_border_color : @unchecked_border_color).dup
+    end
+
+    def clicked_left_mouse_button(sender, x, y)
+      super
+      check
+      nil
+    end
+
+    # Check the button and update its group. This may uncheck another button in the group if one is selected.
+    def check
+      return if checked?
+
+      @checked = true
+      @group.value = value
+      @border_color = @checked_border_color.dup
+      publish :changed, @checked
+
+      nil
+    end
+
+    # Uncheck the button and update its group.
+    def uncheck
+      return unless checked?
+
+      @checked = false
+      @group.value = value
+      @border_color = @unchecked_border_color.dup
+      publish :changed, @checked
+
+      nil
+    end
+
+    protected
+    def parent=(parent)
+      @group.remove_button self if @parent
+      super(parent)
+      add_to_group if parent
+      parent
+    end
+
+    protected
+    def add_to_group
+      container = parent
+      while container and not container.is_a? Group
+        container = container.parent
+      end
+
+      raise "#{self.class.name} must be placed inside a group element" unless container
+
+      @group = container
+      @group.add_button self
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/scroll_area.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module Fidgit
+  # A basic scrolling area. It is not managed in any way (use ScrollWindow for that).
+  class ScrollArea < Container
+    # @return [VerticalPacker] The content shown within this ScrollArea
+    attr_reader :content
+
+    def offset_x; x - @content.x; end
+    def offset_y; y - @content.y; end
+
+    def offset_x=(value)
+      @content.x = x - [[@content.width - width, value].min, 0].max
+    end
+
+    def offset_y=(value)
+      @content.y = y - [[@content.height - height, value].min, 0].max
+    end
+
+    # @option options [Number] :offset (0)
+    # @option options [Number] :offset_x (value of :offset option)
+    # @option options [Number] :offset_y (value of :offset option)
+    # @option options [Element] :owner The owner of the content, such as the scroll-window containing the content.
+    def initialize(options = {})
+      options = {
+        offset: 0,
+        owner: nil,
+      }.merge! options
+
+      @owner = options[:owner]
+
+      super(options)
+
+      @content = VerticalPacker.new(parent: self, padding: 0)
+
+      self.offset_x = options[:offset_x] || options[:offset]
+      self.offset_y = options[:offset_y] || options[:offset]
+    end
+
+    def hit_element(x, y)
+      # Only pass on mouse events if they are inside the window.
+      if hit?(x, y)
+        @content.hit_element(x, y) || self
+      else
+        nil
+      end
+    end
+
+    def recalc
+      super
+      # Always recalc our owner if our content resizes, even though our size can't change even if the content changes
+      # (may encourage ScrollWindow to show/hide scroll-bars, for example)
+      @owner.recalc if @owner
+    end
+
+    protected
+    def draw_foreground
+      $window.clip_to(*rect) do
+        @content.draw
+      end
+    end
+
+    protected
+    def post_init_block(&block)
+      case block.arity
+        when 1
+          yield @content
+        when 0
+          @content.instance_methods_eval &block
+        else
+          raise "block arity must be 0 or 1"
+      end
+    end
+  end
+end

data/lib/fidgit/elements/scroll_bar.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module Fidgit
+  # @abstract
+  class ScrollBar < Composite
+    class Handle < Element
+      event :begin_drag
+      event :update_drag
+      event :end_drag
+
+      def drag?(button); button == :left; end
+
+      def initialize(options = {})
+        super options
+
+        subscribe :begin_drag do |sender, x, y|
+          # Store position of the handle when it starts to drag.
+          @drag_start_pos = [x - self.x, y - self.y]
+        end
+
+        subscribe :update_drag do |sender, x, y|
+          parent.parent.handle_dragged_to x - @drag_start_pos[0], y - @drag_start_pos[1]
+        end
+
+        subscribe :end_drag do
+          @drag_start_pos = nil
+        end
+      end
+    end
+
+    def initialize(options = {})
+      options = {
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        rail_width: default(:rail_width),
+        rail_color: default(:rail_color),
+        handle_color: default(:handle_color),
+        owner: nil,
+      }.merge! options
+
+      @owner = options[:owner]
+      @rail_thickness = options[:rail_width]
+      @rail_color = options[:rail_color]
+
+      super options
+
+      @handle_container = Container.new(parent: self, width: options[:width], height: options[:height]) do
+        @handle = Handle.new(parent: self, x: x, y: y, background_color: options[:handle_color])
+      end
+    end
+  end
+
+  class HorizontalScrollBar < ScrollBar
+    attr_reader :owner
+
+    def initialize(options = {})
+      super options
+
+      @handle.height = height
+
+      @handle_container.subscribe :left_mouse_button do |sender, x, y|
+        distance = @owner.view_width
+        @owner.offset_x += (x > @handle.x)? +distance : -distance
+      end
+    end
+
+    def update
+      window = parent.parent
+
+      # Resize and re-locate the handles based on changes to the scroll-window.
+      content_width = window.content_width.to_f
+      @handle.width = (window.view_width * width) / content_width
+      @handle.x = x + (window.offset_x * width) / content_width
+    end
+
+    def draw_foreground
+      draw_rect x + padding_left, y + (height - @rail_thickness) / 2, width, @rail_thickness, z, @rail_color
+      super
+    end
+
+    def handle_dragged_to(x, y)
+      @owner.offset_x = @owner.content_width * ((x - self.x) / width.to_f)
+    end
+  end
+
+  class VerticalScrollBar < ScrollBar
+    def initialize(options = {})
+      super options
+
+      @handle.width = width
+
+      @handle_container.subscribe :left_mouse_button do |sender, x, y|
+        distance = @owner.view_height
+        @owner.offset_y += (y > @handle.y)? +distance : -distance
+      end
+    end
+
+    def update
+      window = parent.parent
+      content_height = window.content_height.to_f
+      @handle.height = (window.view_height * height) / content_height
+      @handle.y = y + (window.offset_y * height) / content_height
+    end
+
+    def draw_foreground
+      draw_rect x + (width - @rail_thickness) / 2, y + padding_top, @rail_thickness, height, z, @rail_color
+      super
+    end
+
+    def handle_dragged_to(x, y)
+      @owner.offset_y = @owner.content_height * ((y - self.y) / height.to_f)
+    end
+  end
+end

data/lib/fidgit/elements/scroll_window.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Fidgit
+  class ScrollWindow < Composite
+	  def content; @view.content; end
+	
+    def offset_x; @view.offset_x; end
+    def offset_x=(value); @view.offset_x = value; end
+    def offset_y; @view.offset_y; end
+    def offset_y=(value); @view.offset_y = value; end
+
+    def view_width; @view.width; end
+    def view_height; @view.height; end
+    def content_width; @view.content.width; end
+    def content_height; @view.content.height; end
+	
+	def width=(value); super(value); end
+	def height=(value); super(value); end
+
+    def initialize(options = {})
+      options = {
+        scroll_bar_thickness: default(:scroll_bar_thickness),
+      }.merge! options
+
+      super(options)
+
+      @grid = pack :grid, num_columns: 2, padding: 0, spacing: 0 do
+        @view = scroll_area(owner: self, width: options[:width], height: options[:height])
+        @spacer = label '', padding: 0, width: 0, height: 0
+      end
+
+      @scroll_bar_v = VerticalScrollBar.new(owner: self, width: options[:scroll_bar_thickness], align_v: :fill)
+      @scroll_bar_h = HorizontalScrollBar.new(owner: self, height: options[:scroll_bar_thickness], align_h: :fill)
+    end
+
+    protected
+    def layout
+      # Prevent recursive layouts.
+      return if @in_layout
+
+      @in_layout = true
+
+      if @view
+        # Constrain the values of the offsets.
+        @view.offset_x = @view.offset_x
+        @view.offset_y = @view.offset_y
+
+        if content_height > view_height
+          unless @scroll_bar_v.parent
+            @view.send(:rect).width -= @scroll_bar_v.width
+            @grid.remove @spacer
+            @grid.insert 1, @scroll_bar_v
+          end
+        else
+          if @scroll_bar_v.parent
+            @view.send(:rect).width += @scroll_bar_v.width
+            @grid.remove @scroll_bar_v
+            @grid.insert 1, @spacer
+          end
+        end
+
+        if content_width > view_width
+          unless @scroll_bar_h.parent
+            @view.send(:rect).height -= @scroll_bar_h.height
+            @grid.add @scroll_bar_h
+          end
+        else
+          if @scroll_bar_h.parent
+            @view.send(:rect).height += @scroll_bar_h.height
+            @grid.remove @scroll_bar_h
+          end
+        end
+      end
+
+      super
+
+      @in_layout = false
+    end
+
+    protected
+    def post_init_block(&block)
+      case block.arity
+        when 1
+          yield @view.content
+        when 0
+          @view.content.instance_methods_eval &block
+        else
+          raise "block arity must be 0 or 1"
+      end
+    end
+  end
+end

data/lib/fidgit/elements/slider.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module Fidgit
+  class Slider < Composite
+    # @private
+    class Handle < Element
+      event :begin_drag
+      event :end_drag
+      event :update_drag
+
+      def drag?(button); button == :left; end
+
+      # @param (see Element#initialize)
+      #
+      # @option (see Element#initialize)
+      def initialize(options = {}, &block)
+        options = {
+          background_color: default(:background_color),
+          border_color: default(:border_color),
+        }.merge! options
+
+        super options
+
+        subscribe :begin_drag do |sender, x, y|
+          # Store position of the handle when it starts to drag.
+          @drag_start_pos = [x - self.x, y - self.y]
+        end
+
+        subscribe :update_drag do |sender, x, y|
+          parent.handle_dragged_to x - @drag_start_pos[0], y - @drag_start_pos[1]
+        end
+
+        subscribe :end_drag do
+          @drag_start_pos = nil
+        end
+      end
+    end
+
+    event :changed
+
+    attr_reader :value, :range
+
+    # @param (see Composite#initialize)
+    #
+    # @option (see Composite#initialize)
+    # @option options [Range] :range (0.0..1.0)
+    # @option options [Range] :value (minimum of :range)
+    def initialize(options = {}, &block)
+      options = {
+        range: 0.0..1.0,
+        height: 25,
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        groove_color: default(:groove_color),
+        handle_color: default(:handle_color),
+        groove_thickness: 5,
+      }.merge! options
+
+      @range = options[:range].dup
+      @groove_color = options[:groove_color].dup
+      @groove_thickness = options[:groove_thickness]
+      @continuous = @range.min.is_a?(Float) or @range.max.is_a?(Float)
+
+      super(options)
+
+      @handle = Handle.new(parent: self, width: (height / 2 - padding_left), height: height - padding_top + padding_bottom,
+                           background_color: options[:handle_color])
+
+      self.value = options.has_key?(:value) ? options[:value] : @range.min
+    end
+
+    def value=(value)
+      @value = @continuous ? value.to_f : value.round
+      @value = [[@value, @range.min].max, @range.max].min
+      @handle.x = x + padding_left + ((width - @handle.width) * (@value - @range.min) / (@range.max - @range.min).to_f)
+      publish :changed, @value
+
+      @value
+    end
+
+    def tip
+      tip = super
+      tip.empty? ? @value.to_s : "#{tip}: #{@value}"
+    end
+
+    def left_mouse_button(sender, x, y)
+      # In this case, x should be the centre of the handle after it has moved.
+      self.value = ((x - (@handle.width / 2) - self.x) / (width - @handle.width)) * (@range.max - @range.min) + @range.min
+      @mouse_down = true
+
+      nil
+    end
+
+    def handle_dragged_to(x, y)
+      # In this case, x is the left-hand side fo the handle.
+      self.value = ((x - self.x) / (width - @handle.width)) * (@range.max - @range.min) + @range.min
+    end
+
+    protected
+    # Prevent standard packing layout change.
+    def layout
+      nil
+    end
+
+    protected
+    def draw_background
+      super
+      # Draw a groove for the handle to move along.
+      draw_rect x + (@handle.width / 2), y + (height - @groove_thickness) / 2, width - @handle.width, @groove_thickness, z, @groove_color
+      nil
+    end
+
+    protected
+    # Use block as an event handler.
+    def post_init_block(&block)
+      subscribe :changed, &block
+    end
+  end
+end