glimr 0.1.0

data/lib/glimr/widgets/container.rb

@@ -0,0 +1,84 @@
+require 'glimr/widget'
+
+
+module GlimR
+
+  class Container < Widget
+
+    touching_accessor :scroll_x, :scroll_y, :content
+    attr_reader :content_view
+
+    def default_config
+      super.merge(
+        :scroll_x => 0,
+        :scroll_y => 0,
+        :width => 200,
+        :height => 100,
+        :fit_to_children => false
+      )
+    end
+
+    def initialize(*a, &b)
+      @content_view = Viewport.new(
+        :x => 0, :y => 0, :width => 1, :height => 1
+      )
+      @mirror_event = method(:mirror_event).to_proc
+      super
+      self.content = @content if @content
+      @content_view.on_layout(@mirror_event)
+      attach @content_view
+    end
+
+    def mirror_event(o,e)
+      process_event e
+    end
+
+    def content= c
+      @content_view.detach @content if @content
+      @content.remove_event_listener(:layout, @mirror_event) if @content
+      @content = c
+      @content_view.attach @content if @content
+      @content.add_event_listener(:layout, @mirror_event) if @content
+    end
+
+    def scroll_x=(x)
+      @scroll_x = x
+      if @content
+        case x
+        when Float
+          @content.x = -x*(@content.width-@width).to_i
+        else
+          @content.x = -x
+        end
+      end
+    end
+
+    def scroll_y=(y)
+      @scroll_y = y
+      if @content
+        case y
+        when Float
+          @content.y = -y*(@content.height-@height).to_i
+        else
+          @content.y = -y
+        end
+      end
+    end
+
+    def scroll
+      [@scroll_x, @scroll_y]
+    end
+
+    def scroll= s
+      self.scroll_x, self.scroll_y = *s
+    end
+
+    def layout
+      super
+      @content_view.width = @width
+      @content_view.height = @height
+    end
+
+  end
+
+end

data/lib/glimr/widgets/image.rb

@@ -0,0 +1,82 @@
+require 'glimr/widget'
+
+
+module GlimR
+
+
+  # Image is a quad matching a texture's dimensions.
+  class Image < Widget
+
+    def self.load(filename)
+      image = new
+      image.load(filename)
+      image
+    end
+
+    def self.load_theme(filename)
+      load(GlimR.theme + filename)
+    end
+
+    attr_accessor :image, :bound
+
+    def default_config
+      super.merge(
+        :fit_children => false,
+        :image => nil
+      )
+    end
+
+    def initialize(*a,&b)
+      super
+      if @image
+        load(@image)
+      end
+    end
+
+    def texture= t
+      super
+      update_geometry
+    end
+
+    def load(filename,update_geo=true)
+      @texture.load(filename)
+      update_geometry if update_geo
+    end
+
+    def load_theme(filename,update_geo=true)
+      load(GlimR.theme + filename, update_geo)
+    end
+
+    def update_geometry
+      @geometry.vertices = create_vertices
+      @geometry.normals = create_normals
+      @geometry.colors = create_colors
+      @geometry.texcoords = create_texcoords
+    end
+
+    def create_colors
+      nil
+    end
+
+    def create_vertices
+      size_changing do
+        @min_width = @width = @texture.width
+        @min_height = @height = @texture.height
+      end
+      [0,0,0, @texture.width,0,0, @texture.width,@texture.height,0, 0,@texture.height,0]
+    end
+
+    def create_normals
+      [0,0,1, 0,0,1, 0,0,1, 0,0,1]
+    end
+
+    def create_texcoords
+      hb = @texture.height / @texture.bound.to_f
+      wb = @texture.width / @texture.bound.to_f
+      [0,0, wb,0, wb,hb, 0,hb]
+    end
+
+  end
+
+
+end

data/lib/glimr/widgets/label.rb

@@ -0,0 +1,91 @@
+require 'glimr/widgets/image'
+require 'sdl'
+SDL::TTF.init
+
+
+module GlimR
+
+  class << self
+    attr_accessor :label_font, :label_size, :label_color
+  end
+
+  self.label_font = GlimR.theme + 'font.ttf'
+  self.label_size = 12
+  self.label_color = [0,0,0,1]
+
+  class Label < Image
+
+    touching_accessor :font, :size, :text, :valign, :align, :color
+
+    def default_config
+      super.merge(
+        :valign => :center,
+        :align => :center,
+        :font => GlimR.label_font,
+        :size => GlimR.label_size,
+        :width => 0, :height => 0,
+        :color => GlimR.label_color
+      )
+    end
+
+    def initialize(a,&b)
+      txt = a[:text]
+      a.delete(:text)
+      super(a, &b)
+      self.text = txt if txt
+    end
+
+    def text= t
+      @text = t.to_s
+      sdl_font = SDL::TTF.open(font, size)
+      lines = @text.split("\n")
+      w,h = 0,0
+      lines.each{|line|
+        nw,nh = sdl_font.text_size(line)
+        w = nw if nw > w
+      }
+      h = lines.size * (sdl_font.line_skip+1)
+
+      texture.width = w
+      texture.height = h
+      rmask = 0xff000000
+      gmask = 0x00ff0000
+      bmask = 0x0000ff00
+      amask = 0x000000ff
+      mask = SDL::Surface.new(
+          SDL::SWSURFACE|SDL::SRCALPHA,
+          w, h, 32,
+          amask,bmask,gmask,rmask)
+      mask.fill_rect(0,0, w,h, [0,0,0,255])
+      lines.each_with_index{|line,i|
+        sdl_font.draw_blended_utf8(
+          mask, line,
+          0, i*(sdl_font.line_skip+1),
+          255, 255, 255
+        )
+      }
+      image = SDL::Surface.new(
+          SDL::SWSURFACE|SDL::SRCALPHA,
+          w, h, 32,
+          amask,bmask,gmask,rmask)
+      image.fill_rect(0,0,w,h, color.map{|i|(i*255).to_i})
+      texture.mode = TEXTURE_2D
+      texture.pixels = as_alpha(image.pixels, mask.pixels)
+      @width = texture.width
+      @height = texture.height
+      @bound = texture.bound
+      update_geometry
+    end
+
+    def as_alpha(pixels, alpha)
+      i = 3
+      while i < pixels.size
+        pixels[i] = alpha[i-1]
+        i += 4
+      end
+      pixels
+    end
+
+  end
+
+end

data/lib/glimr/widgets/layout.rb

@@ -0,0 +1,227 @@
+require 'glimr/widget'
+
+
+module GlimR
+
+
+  # A Layout is a Widget that layouts its child widgets.
+  #
+  # Layouts come in two breeds: the horizontal layout and
+  # the vertical layout. A horizontal layout (or HLayout)
+  # arranges its children in a row, while a vertical layout
+  # (a.k.a. VLayout) arranges them in a column.
+  #
+  # A layout has two alignment attributes, the #align and the
+  # #valign. Align determines where to put the children
+  # on the horizontal axis, and valign does the same on the
+  # vertical axis.
+  #
+  # Align value :left aligns the left border of the layouted widgets and
+  # pushes them to the left border of the layout.
+  # Using :right as align does the same, except for the right border.
+  # The :center align aligns the centerline of the widgets with the layout's
+  # centerline. The default align is :left.
+  #
+  # Valign takes three values as well: :top, :bottom, and :middle. The default
+  # is :top, and aligns the top border of the widgets with the top border of
+  # the layout. To align to the bottom border, use :bottom. The :middle valign
+  # aligns the vertical midpoint of the widgets with the layout's vertical
+  # midpoint.
+  #
+  # Item spacing controls the amount of space between the layouted widgets.
+  # The default item spacing is 2.
+  #
+  # A Layout fits its children by default and doesn't expand to
+  # maximum width or height.
+  #
+  class Layout < Widget
+
+    attr_accessor :item_spacing, :direction
+
+    def default_config
+      super.merge(
+        :item_spacing => 2,
+        :direction => :horizontal,
+        :fit_children => true
+      )
+    end
+
+    def children_change
+      @free_width = @free_height = nil
+      layout
+    end
+
+    # If direction is vertical, sets width equal to the largest child + padding.
+    # If direction is horizontal, sets width to sum of children widths + padding + item spacing.
+    def fit_width!
+      return super if direction == :vertical
+      self.width = layoutable_children.inject(padding_left+padding_right-item_spacing){|s,c|
+        s + c.full_width + item_spacing
+      } unless layoutable_children.empty?
+    end
+
+    # If direction is horizontal, sets height equal to the largest child + padding.
+    # If direction is vertical, sets height to sum of children heights + padding + item spacing.
+    def fit_height!
+      return super if direction == :horizontal
+      self.height = layoutable_children.inject(padding_top+padding_left-item_spacing){|s,c|
+        s + c.full_height + item_spacing
+      } unless layoutable_children.empty?
+    end
+
+    def layout
+      return if @layouting
+      c = layoutable_children
+      return if c.empty?
+      @layouting = true
+      size_changing do
+        @free_width = @free_height = nil
+        @id ||= 0
+        @id += 1
+        c.each{|ch|
+          ch.width = free_width-ch.margin_left-ch.margin_right if ch.expand_width
+          ch.height = free_height-ch.margin_top-ch.margin_bottom if ch.expand_height
+        }
+        fit_to_children! if fit_children?
+        if @direction == :horizontal
+          horiz_tile(c)
+        else
+          vert_tile(c)
+        end
+      end
+      @layouting = false
+    end
+
+    def item_spacing= s
+      @item_spacing = s
+      layout
+    end
+
+    def direction= d
+      @direction = d
+      layout
+    end
+
+    # Horizontally tile objects inside self.
+    def horiz_tile(objs)
+      objs_width = objs.inject(-@item_spacing){|s,o|
+        s + o.full_width + @item_spacing
+      }
+      x = case @align
+          when :left
+            @padding_left
+          when :right
+            @padding_left + inner_width - objs_width
+          when :center, :middle
+            @padding_left + (inner_width - objs_width) / 2
+          end
+      ih = inner_height
+      objs.each{|obj|
+        obj.x = x + obj.margin_left
+        obj.y = case @valign
+                when :top
+                  @padding_top
+                when :bottom
+                  @padding_top + ih - obj.full_height
+                when :center, :middle
+                  @padding_top + (ih - obj.full_height) / 2
+                end
+        obj.z = 1
+        x += obj.full_width + @item_spacing
+      }
+    end
+
+    # Vertically tile objects inside self.
+    def vert_tile(objs)
+      objs_height = objs.inject(-@item_spacing){|s,o|
+        s + o.full_height + @item_spacing
+      }
+      y = case @align
+          when :left
+            @padding_top
+          when :right
+            @padding_top + inner_height - objs_height
+          when :center, :middle
+            @padding_top + (inner_height - objs_height) / 2
+          end
+      iw = inner_width
+      objs.each{|obj|
+        obj.y = y + obj.margin_top
+        obj.x = case @align
+                when :left
+                  @padding_left
+                when :right
+                  @padding_left + iw - obj.full_width
+                when :center, :middle
+                  @padding_left + (iw - obj.full_width) / 2
+                end
+        obj.z = 1
+        y += obj.full_height + @item_spacing
+      }
+    end
+
+    def free_width
+      @free_width ||= calculate_free_width
+    end
+
+    def free_height
+      @free_height ||= calculate_free_height
+    end
+
+    def calculate_free_width
+      return inner_width if @direction == :vertical
+      objs = layoutable_children
+      fit_width_objs, constant_width_objs = objs.partition{|o| o.expand_width }
+      if fit_width_objs.empty?
+        0.0
+      else
+        const_width = constant_width_objs.inject(0){|cw, o|
+          cw + o.full_width
+        } + (objs.size - 1) * @item_spacing
+        [0.0, (inner_width - const_width) / fit_width_objs.size].max
+      end
+    end
+
+    def calculate_free_height
+      return inner_height if @direction == :horizontal
+      objs = layoutable_children
+      fit_height_objs, constant_height_objs = objs.partition{|o| o.expand_height}
+      if fit_height_objs.empty?
+        0.0
+      else
+        const_height = constant_height_objs.inject(0){|cw, o|
+          cw + o.full_height
+        } + (objs.size - 1) * @item_spacing
+        [0.0, (inner_height - const_height) / fit_height_objs.size].max
+      end
+    end
+
+  end
+
+
+  class HLayout < Layout
+
+    def default_config
+      super.merge(:direction => :horizontal)
+    end
+
+  end
+
+
+  class VLayout < Layout
+
+    def default_config
+      super.merge(:direction => :vertical)
+    end
+
+  end
+
+
+#   class OverLayout < Layout
+#   end
+#
+#
+#   class FreeLayout < Layout
+#   end
+
+end