glimr 0.1.0

data/lib/glimr/widget.rb

@@ -0,0 +1,87 @@
+require 'glimr/renderer/model'
+require 'glimr/layoutable'
+
+
+module GlimR
+
+  class Widget < Model
+  include Layoutable
+
+    touching_accessor :model, :locked
+    attr_accessor :focused
+
+    attr_reader :hover
+
+    def self.for(*args,&block)
+      GlimR.for(*args,&block)
+    end
+
+    def initialize(*args, &block)
+      @buttons_down = {}
+      super
+      on_mouse_over(:mouse_over)
+      on_mouse_out(:mouse_out)
+      on_mouse_down(:mouse_down)
+      on_mouse_up(:mouse_up)
+      on_mouse_move(:mouse_move)
+      on_key_down(:key_down)
+      on_key_up(:key_up)
+      on_click(:click)
+      on_activate(:activate)
+      on_focus(:focus)
+      on_blur(:blur)
+      on_lock(:lock)
+      on_unlock(:unlock)
+    end
+
+    def mouse_over(o, event)
+      @hover = true
+    end
+
+    def mouse_out(o, event)
+      @hover = false
+    end
+
+    def mouse_down(o, event)
+      focus(o,event) unless focused and event.button == :left
+    end
+
+    def mouse_up(o, event)
+      blur(o,event) if focused and !@hover and event.button == :left
+    end
+
+    def mouse_move(o, event)
+    end
+
+    def key_down(o, event)
+    end
+
+    def key_up(o, event)
+    end
+
+    def click(o, event)
+    end
+
+    def activate(o, event)
+    end
+
+    def focus(o, event)
+      self.focused = true
+    end
+
+    def blur(o, event)
+      self.focused = false
+    end
+
+    def lock(o, event)
+      self.locked = true
+    end
+
+    def unlock(o, event)
+      self.locked = false
+    end
+
+  end
+
+
+end # GlimR

data/lib/glimr/widgets.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+
+
+module GlimR
+
+  class << self
+    attr_accessor :widgets, :theme
+
+    def for(model, arg_hash = {}, &block)
+      widgets[model.class].new(arg_hash.merge(:model => model), &block)
+    end
+  end
+
+  self.widgets = {}
+  self.theme = Pathname.new(__FILE__).dirname + "default_theme"
+
+end
+
+
+require 'glimr/widget'
+
+require 'glimr/widgets/layout'
+
+require 'glimr/widgets/image'
+require 'glimr/widgets/stretchable_image'
+require 'glimr/widgets/label'
+require 'glimr/widgets/button'
+require 'glimr/widgets/checkbox'
+require 'glimr/widgets/radiogroup'
+
+require 'glimr/widgets/container'
+
+require 'glimr/widgets/scrollbar'
+require 'glimr/widgets/scrollable_container'
+require 'glimr/widgets/list'
+
+require 'glimr/widgets/text_editor'

data/lib/glimr/widgets/button.rb

@@ -0,0 +1,277 @@
+require 'glimr/widgets/label'
+require 'glimr/widgets/stretchable_image'
+
+
+module GlimR
+
+  class EmptyButton < Widget
+
+    @@image_cache ||= {}
+
+    def self.load_image(img_name)
+      @@image_cache[img_name] ||= Texture.load(GlimR.theme + img_name)
+    end
+
+    touching_accessor :label_down_offset
+
+    def default_config
+      super.merge(
+        :fit_children => false,
+        :align => :center,
+        :valign => :middle,
+        :label_down_offset => [0,2],
+        :up_background => nil,
+        :down_background => nil,
+        :up_cover => nil,
+        :down_cover => nil,
+        :up_hover_indicator => nil,
+        :down_hover_indicator => nil,
+        :up_focus_indicator => nil,
+        :down_focus_indicator => nil
+      )
+    end
+
+    attr_accessor :background, :label, :cover, :hover_indicator
+    attr_accessor :up_background, :down_background, :up_cover, :down_cover
+    attr_reader :down
+
+    def initialize(*args, &block)
+      @image_cache = {}
+      super(*args, &nil)
+      self.background = @up_background
+      @min_width = @background_model.width
+      @min_height = @background_model.height
+      self.label = @label
+      self.background = @up_background
+      self.cover = @up_cover
+      self.hover_indicator = @up_hover_indicator
+      self.focus_indicator = @up_focus_indicator
+      on_activate(&block) if block_given?
+    end
+
+    def load_image(img_name, z)
+      i = @image_cache[[img_name,z]] ||= (
+        tex = self.class.load_image(img_name)
+        img = StretchableImage.new
+        img.texture = tex
+        img.z = z
+        img
+      )
+      i.set_dimensions(@width, @height) unless i.width == @width and i.height == @height
+      i
+    end
+
+    def mouse_down(o,e)
+      super
+      if not @down and e.button == :left
+        @down = true
+        button_down
+      end
+    end
+
+    def mouse_up(o,e)
+      super
+      if @down and e.button == :left
+        dispatch_event(Event.new(:activate)) if @hover
+        @down = false
+        button_up
+      end
+    end
+
+    def key_down(o,e)
+      super
+      if @focused
+        case e.key
+        when 13
+          @down = true
+          button_down
+        end
+      end
+    end
+
+    def key_up(o,e)
+      super
+      if @focused and @down
+        case e.key
+        when 13
+          dispatch_event(Event.new(:activate))
+          @down = false
+          button_up
+        end
+      elsif @down and (e.key == 13)
+        @down = false
+        button_up
+      end
+    end
+
+    def mouse_out(o,e)
+      super
+      @hover_indicator_model.visible = false if @hover_indicator_model
+      button_up if @down
+    end
+
+    def mouse_over(o,e)
+      super
+      @hover_indicator_model.visible = true if @hover_indicator_model
+      button_down if @down
+    end
+
+    def button_down
+      self.background = @down_background
+      self.cover = @down_cover
+      self.hover_indicator = @down_hover_indicator
+      self.focus_indicator = @down_focus_indicator
+      self.label_model = @down_label_model
+      dispatch_event Event.new(:down)
+    end
+
+    def button_up
+      self.background = @up_background
+      self.cover = @up_cover
+      self.hover_indicator = @up_hover_indicator
+      self.focus_indicator = @up_focus_indicator
+      self.label_model = @up_label_model
+      dispatch_event Event.new(:up)
+    end
+
+    def focused= f
+      super
+      @focus_indicator_model.visible = f if @focus_indicator_model
+    end
+
+    def label= new_label
+      @label = new_label
+      case @label
+      when Layoutable
+        @up_label_model = @label
+        @down_label_model = @label
+      when nil
+        @up_label_model = @down_label_model = nil
+      else
+        l = Label.new(:text => @label)
+        @up_label_model = Label.new(
+          :text => @label
+        )
+        @down_label_model = Label.new(
+          :text => @label,
+          :margin_left => @label_down_offset[0],
+          :margin_top => @label_down_offset[1]
+        )
+      end
+      if @up_label_model
+        size_changing {
+          self.width = @up_label_model.width + padding_left + padding_right
+          self.height = @up_label_model.height + padding_top + padding_bottom
+        }
+      end
+      self.label_model = @up_label_model
+    end
+
+    def label_model= new_label_model
+      return if new_label_model == @label_model
+      @label_model.detach_self if @label_model
+      @label_model = new_label_model
+      attach @label_model if @label_model
+    end
+
+    def background= new_bg
+      return if @background == new_bg
+      @background_model.detach_self if @background_model
+      @background_model = case new_bg
+                    when Layoutable
+                      new_bg
+                    when String, Pathname
+                      load_image(new_bg, -1)
+                    when nil
+                      new_bg
+                    else
+                      raise "Bad background"
+                    end
+      if @background_model
+        attach @background_model
+      end
+    end
+
+    def cover= new_cover
+      return if @cover == new_cover
+      @cover_model.detach_self if @cover_model
+      @cover_model = case new_cover
+                when Layoutable
+                  new_cover
+                when String, Pathname
+                  load_image(new_cover, 1)
+                when nil
+                  new_cover
+                else
+                  raise "Bad cover"
+                end
+      if @cover_model
+        attach @cover_model
+      end
+    end
+
+    def focus_indicator= new_focus_indicator
+      return if @focus_indicator == new_focus_indicator
+      @focus_indicator_model.detach_self if @focus_indicator_model
+      @focus_indicator_model =  case new_focus_indicator
+                          when Layoutable
+                            new_focus_indicator
+                          when String, Pathname
+                            load_image(new_focus_indicator, 3)
+                          when nil
+                            new_focus_indicator
+                          else
+                            raise "Bad focus indicator"
+                          end
+      if @focus_indicator_model
+        @focus_indicator_model.visible = focused
+        attach @focus_indicator_model
+      end
+    end
+
+    def hover_indicator= new_hover_indicator
+      return if @hover_indicator == new_hover_indicator
+      @hover_indicator_model.detach_self if @hover_indicator_model
+      @hover_indicator_model =  case new_hover_indicator
+                          when Layoutable
+                            new_hover_indicator
+                          when String, Pathname
+                            load_image(new_hover_indicator, 2)
+                          when nil
+                            new_hover_indicator
+                          else
+                            raise "Bad hover indicator"
+                          end
+      if @hover_indicator_model
+        @hover_indicator_model.visible = @hover
+        attach @hover_indicator_model
+      end
+    end
+
+  end
+
+
+  class Button < EmptyButton
+
+    def default_config
+      super.merge(
+        :up_background => "button_bg.png",
+        :down_background => "button_bg_down.png",
+        :padding_left => 12,
+        :padding_right => 12,
+        :padding_top => 4,
+        :padding_bottom => 4,
+        :up_cover => "button_cover.png",
+        :down_cover => "button_cover_down.png",
+        :up_hover_indicator => "button_focus.png",
+        :down_hover_indicator => "button_focus.png",
+        :up_focus_indicator => "button_focus.png",
+        :down_focus_indicator => "button_focus.png"
+      )
+    end
+
+  end
+
+
+end
+

data/lib/glimr/widgets/checkbox.rb

@@ -0,0 +1,82 @@
+require 'glimr/widgets/button'
+require 'glimr/widgets/layout'
+
+
+module GlimR
+
+  class Checkbox < HLayout
+
+    attr_accessor :label
+    ivar_accessor_delegate :@button, :state
+
+    def default_config
+      super.merge(
+        :button => CheckboxButton.new,
+        :valign => :center,
+        :label => ""
+      )
+    end
+
+    def initialize(*a, &b)
+      super
+      @label_model = Label.new(:text => @label)
+      self.state = @state if @state
+      @button.on_activate{|o,e|
+        dispatch_event(Event.new(
+          :change, {:source => self, :state => state}
+        ))
+      }
+      attach @button, @label_model
+    end
+
+    def label=(l)
+      @label = l
+      @label_model.text = l
+    end
+
+  end
+
+
+  class CheckboxButton < EmptyButton
+
+    attr_accessor :state
+
+    def default_config
+      super.merge(
+        :state => false,
+        :up_background => "checkbox_bg.png",
+        :down_background => "checkbox_checked_bg.png",
+        :margin => 2,
+        :label_down_offset => [0,0]
+      )
+    end
+
+    def initialize(*a, &b)
+      super
+      if @state
+        @state = false
+        self.state = true
+      end
+    end
+
+    def activate(o,e)
+      self.state = !state
+    end
+
+    def toggle
+      @up_background, @down_background = @down_background, @up_background
+      @up_cover, @down_cover = @down_cover, @up_cover
+      @up_label_model, @down_label_model = @down_label_model, @up_label_model
+      button_up
+    end
+
+    def state= s
+      if (!@state) != (!s) # convert both to boolean
+        @state = s
+        toggle
+      end
+    end
+
+  end
+
+end