aurita-gui 0.1.0

data/lib/aurita-gui/form/input_field.rb

@@ -0,0 +1,29 @@
+
+require('aurita-gui/form/form_field')
+
+module Aurita
+module GUI
+
+  # Usage: 
+  #
+  #   i = Input_Field.new(:name => :description, 
+  #                       :label => 'Description', 
+  #                       :value => 'Lorem ipsum dolor')
+  #
+  class Input_Field < Form_Field
+    def initialize(params, &block)
+      params[:tag]  = :input
+      params[:type] = :text unless params[:type]
+      if block_given? then
+        params[:value] = yield
+      end
+      super(params)
+    end
+    def element
+      HTML.input(@attrib)
+    end
+  end
+
+  
+end
+end

data/lib/aurita-gui/form/options_field.rb

@@ -0,0 +1,115 @@
+
+require('aurita-gui/form/form_field')
+
+module Aurita
+module GUI
+
+  # Abstract base class for all form elements containing
+  # options, like Select_Field, Radio_Field, Checkbox_Field
+  # or any custom implementation. 
+  #
+  # Usage: 
+  #
+  #   r = Radio_Field.new(:options => { 1 => 'first', 
+  #                                     2 => 'second', 
+  #                                     3 => 'third' },
+  #                       :label => 'Which one?', 
+  #                       :value => 1)
+  # Same as
+  #
+  #   r = Radio_Field(:option_range  => (1..3)
+  #                   :option_labels => ['First', 'Second', 'Third']
+  #                   :value => 1,
+  #                   :label => 'Which one?')
+  #
+  # Set a selected value using parameter :value
+  #
+  #   r = Radio_Field.new(:value => 42, :name => :amount, 
+  #                       :label => 'Select amount')
+  #   r.value = 23
+  #
+  # If there may be more than one selected field, e.g. for Checkbox_Field, 
+  # @value is an Array instance: 
+  #
+  #   c = Checkbox_Field.new(:value => [ 1, 3 ], 
+  #                          :options => { 1 => 'first', 2 => 'second', 3 => 'third' }, 
+  #                          :label => 'Choose')
+  #   c.value = [ 2, 3 ]
+  #
+  #
+  # There are many ways to define options: 
+  #
+  #   select = Select_Field.new(:name => :category, :label => 'Category') 
+  #   select.options = { 1 => 'first', 2 => 'second' } 
+  #   select.add_option(3 => 'third')
+  #   select[3] = HTML.option(:value => 4) { 'fourth' }
+  #   select[4] = { 5 => 'fifth' }
+  #
+  # 
+  #
+  class Options_Field < Form_Field
+
+    attr_accessor :options, :options_range, :options_labels, :value
+
+    def initialize(params, &block)
+      @options          = params[:options]
+      @options_range    = params[:options_range]
+      @options_labels   = params[:options_labels]
+      @options        ||= {}
+      @options_range  ||= []
+      @options_labels ||= []
+      @option_elements  = []
+      @value            = params[:value]
+      if block_given? then
+        yield.each { |option|
+          add_option(option)
+        }
+      elsif params[:options] then
+        add_option(params[:options])
+      end
+      params.delete(:options)
+      params.delete(:value) # Value is determined via selected value
+      params.delete(:options_range)
+      params.delete(:options_labels)
+      super(params)
+    end
+
+    def add_option(option={})
+      if option.kind_of? Array then
+        @option_elements += option
+      elsif option.kind_of? Hash then
+        @option_elements << options
+      elsif option.kind_of? Range then
+        @option_elements += option.to_a
+      end
+      # @option_elements << option
+    end
+
+    def options=(options)
+      if options.kind_of? Array then
+        @option_elements = options
+      elsif options.kind_of? Hash then
+        @option_elements = [ options ]
+      elsif options.kind_of? Range then
+        @option_elements = options.to_a
+      end
+    end
+
+    def [](index)
+      @option_elements[index]
+    end
+    def []=(index, option_element)
+      @option_elements[index] = option_element
+    end
+
+    def element
+      raise Form_Error.new('Method #element from Abstract class Options_Field has not been overloaded.')
+    end
+
+    def content
+      option_elements()
+    end
+  end
+  
+end
+end

data/lib/aurita-gui/form/radio_field.rb

@@ -0,0 +1,35 @@
+
+require('aurita-gui/form/options_field')
+
+module Aurita
+module GUI
+
+  class Radio_Field < Options_Field
+
+    def option_elements
+      options = []
+      @option_elements.each { |option| 
+        if option.kind_of? Hash then
+          option.each_pair { |k,v|
+            options << HTML.input(:type => :radio, :value => k, :name => @attrib[:name] ) { v }
+          }
+        elsif option.kind_of? Element then
+          option.name = @attrib[:name]
+          option.tag = :input
+          option.type = :radio
+          options << option
+        end
+      }
+      options
+    end
+
+    def element
+      HTML.ul(:class => :radio_options) { 
+        option_elements().map { |o| HTML.li() { o } } 
+      }
+    end
+
+  end
+  
+end
+end

data/lib/aurita-gui/form/select_field.rb

@@ -0,0 +1,34 @@
+
+require('aurita-gui/form/options_field')
+
+module Aurita
+module GUI
+
+  class Select_Field < Options_Field
+    def option_elements
+      options = []
+      @option_elements.each { |option| 
+        if option.kind_of? Hash then
+          option.each_pair { |k,v|
+            selected = (@value && k.to_s == @value.to_s)? true : nil
+            options << HTML.option(:value => k, :selected => selected) { v }
+          }
+        elsif option.kind_of? Element then
+          option.tag = :option
+          options << option
+        else 
+          selected = (@value && option.to_s == @value.to_s)? true : nil
+          options << HTML.option(:value => option, :selected => selected) { option }
+        end
+      }
+      options
+    end
+    def element
+      HTML.select(@attrib) { 
+        option_elements()
+      } 
+    end
+  end
+  
+end
+end

data/lib/aurita-gui/form/textarea_field.rb

@@ -0,0 +1,22 @@
+
+require('aurita-gui/form/form_field')
+
+module Aurita
+module GUI
+
+  class Textarea_Field < Form_Field
+    def initialize(params, &block)
+      params[:tag] = :textarea
+      # Move value parameter to @content: 
+      @content     = params[:value]
+      params.delete(:value)
+      super(params, &block)
+      @value       = @content
+    end
+    def element
+      HTML.textarea(@attrib) { @value }
+    end
+  end
+  
+end
+end

data/lib/aurita-gui/html.rb

@@ -0,0 +1,119 @@
+
+require('aurita-gui/element')
+
+module Aurita
+module GUI
+
+  #  Aurita::GUI::HTML is a convenient factory for 
+  #  Aurita::GUI::Element. Almost every class method 
+  #  is redirected to generate a correspoding 
+  #  Element instance. 
+  #
+  #  It implements an object-oriented, minimalistic 
+  #  generator for HTML code. 
+  #  For tags without enclosed content (i.e. without 
+  #  closing tag): 
+  #
+  #    HTML.br  
+  #    # --> '<br />'
+  #
+  #    HTML.hr(:class => 'divide')  
+  #    # --> '<hr class="divide" />'
+  #
+  #  This is effectively a wrapper for 
+  #
+  #    Element.new(:tag => :hr, :class => 'divide')
+  #
+  #  Enclosed content is passed in a block: 
+  #
+  #    HTML.a(:href => 'http://domain.com') { 'click me' }
+  #    # --> '<a href="http://domain.com">click me</a>'
+  #
+  class HTML
+
+    def self.br
+      '<br />'
+    end
+    
+    def self.render(meth_name, attrib_hash={}, &block)
+      raise ::Exception.new('Missing attributes for HTML.' << meth_name.inspect) unless attrib_hash
+      attrib_hash[:tag] = meth_name
+      label = yield if block_given?
+      label = label.to_s unless label.kind_of? String
+      attrib_hash[:content] = label
+      Element.new(attrib_hash)
+    end
+    
+    def self.a(attrib_hash={}, &block)
+      render(:a, attrib_hash, &block)
+    end
+
+    def self.method_missing(meth_name, attrib_hash={}, &block)
+      render(meth_name, attrib_hash, &block)
+    end
+
+  end
+
+  # A minimalistic generator for javascript calls. 
+  # Usage: 
+  #
+  #   my_element.onclick = Javascript.new("alert('an alert message');")
+  #
+  # or just: 
+  #  
+  #   my_element.onclick = Javascript.my_function('foo', 2, 'bar')
+  #   --> my_function('foo', 2, 'bar'); 
+  #
+  # For namespaces: 
+  #
+  #   my_element.onclick = Javascript[:Foo].my_function(1,2)
+  #   --> Foo.my_function('foo', 2, 'bar'); 
+  #
+  # Method #string renders the code passed in constructir, 
+  # enclosed in <script> tags: 
+  #
+  # Javascript.new("alert('message');").string
+  #   --> 
+  #   <script language="Javascript" type="text/javascript">
+  #   alert('message'); 
+  #   </script>
+  #
+  class Javascript
+    
+    def initialize(script)
+      @script = script
+    end
+    
+    # Renders script to a <script> block. 
+    def code_block
+      '<script language="Javascript" type="text/javascript">' << "\n" << 
+        @script + "\n" << 
+      '</script>'
+    end
+
+    def string
+      @script
+    end
+    alias to_s string
+
+    def self.[](namespace) 
+      return self.new(namespace.to_s + '.')
+    end
+
+    def self.method_missing(meth, *args)
+      args = args.collect { |arg|
+        if arg.instance_of? String then
+          '\'' << arg << '\''
+        else
+          arg
+        end
+      }
+      args_string = args.join(',')
+      meth.to_s << '(' << args_string + ');'
+    end
+    
+  end
+    
+end # module
+end # module
+

data/lib/aurita-gui/table.rb

@@ -0,0 +1,192 @@
+
+require('aurita-gui/html')
+
+module Aurita
+module GUI
+
+
+  # Usage: 
+  #
+  #   table = Table.new(:headers => [ 'user', 'phone', 'mobile', 'email' ])
+  #   table.add_row('fuchsto', '+49 89 123456', '+49 89 987654', 'fuchst@wortundform.de')
+  #
+  # A row element may be of type Aurita::GUI::Element. 
+  # In this case, method #string is invoked to render the cell. 
+  #
+  # More examples: 
+  #
+  #   t = Table.new(:headers => ['user', 'phone', 'email'], 
+  #                 :options => { :class => 'css_class', :id => 'test_table' })
+  #   t.add_row([ 'a','b','c' ])
+  #   t.add_row([ 'd','e','f' ])
+
+  #   t[0][0].value = 'foo'
+  #   t[0][0].value = 45
+  #   t[1][0].onclick = 'test();'
+  #   t[0][1] = HTML.a(:href => 'http://google.com') { 'google' }
+
+  #   t[0][1].value.href = 'other'
+  #   t[0][1].value.content = 'clickme'
+
+  #   puts t[0][1].value.string
+
+  #   t[0].class = 'highlighted'
+  #
+  class Table < Element
+
+    attr_accessor :columns, :headers, :rows, :template, :row_css_classes, :column_css_classes, :options
+
+    def initialize(params={}, &block)
+      @options       = params[:options]
+      @options[:tag] = 'table'
+      @headers       = params[:headers]
+      @num_columns   = params[:num_columns]
+      @num_columns   = @headers.length if (!@columns && @headers)
+      @columns       = []
+      @rows          = []
+      @row_css_classes      = params[:row_css_classes]
+      @row_css_classes    ||= []
+      @column_css_classes   = params[:column_css_classes]
+      @column_css_classes ||= []
+      super(@options, &block)
+    end
+
+    def add_row(row_data)
+      row = Table_Row.new(row_data, :parent => self)
+      @rows << row
+
+      # Add row content to columns
+      row_index = 0
+      @columns.each { |c|
+        c.add[row[row_index]]
+        row_index += 1
+      }
+    end
+
+    def string
+      @content = "\n" 
+      @content << HTML.tr { @headers.collect { |cell| HTML.th { cell } }.join }.string
+      @content << @rows.collect { |row| row.string }.join("\n")
+      super()
+    end
+    alias to_s string
+
+    def set_column_decorator(column_index, decorator)
+    end
+
+    def set_data(row_array)
+      row_array.each { |row|
+        @rows << Table_Row.new(row, :parent => self)
+      }
+    end
+
+    def cell(column, row)
+      @rows[row][column]
+    end
+
+    def [](row_index)
+      @rows[row_index]
+    end
+    def []=(row_index, row_data)
+      @rows[row_index] = row_data
+    end
+
+    def columns
+      Table_Column.new(@columns)
+    end
+
+  end
+
+  class Table_Row < Element
+    def initialize(cell_data, params={})
+      @cell_data = cell_data
+      @cells = []
+      @cell_data.each { |cell|
+        @cells << Table_Cell.new(cell, :parent => self)
+      }
+      params[:tag] = 'tr'
+      super(params)
+    end
+
+    def table
+      @params[:parent]
+    end
+
+    def [](column_index)
+      @cells[column_index]
+    end
+    def []=(column_index, cell_data)
+      @cells[column_index].value = cell_data
+    end
+
+    def string
+      @content = "\n" << @cells.collect { |c| c.string }.join()
+      super()
+    end
+
+    def inspect
+      '[' << @cells.collect { |c| c.value }.join(',') + ']'
+    end
+  end
+
+  # Virtual Element: There is no mapped HTML element
+  # for table columns. 
+  class Table_Column 
+    def initialize(cell_array)
+      @cells = cell_array
+    end
+    def [](row_index)
+      @cells[row_index]
+    end
+    def []=(row_index, cell_element)
+      @cells[row_index] = cell_element
+    end
+  end
+
+  # Accessor for a table cell. 
+  # Usage: 
+  #
+  #   cell = my_table[row][column]
+  #   cell.content = 'New cell content'
+  #   cell.class = 'table_cell_css_class'
+  #
+  class Table_Cell < Element
+
+    attr_accessor :value, :presentation_class
+
+    def initialize(cell_element, params={})
+      params[:tag] = 'td'
+      @presentation_class = false
+      super(params)
+      @value = cell_element
+      @content = cell_element
+    end
+
+    def value=(val)
+      @value = val
+      @content = val.to_s
+      if @presentation_class then
+        @content = @presentation_class.new(@value).string 
+      else
+        @content = @value.to_s 
+      end
+    end
+  
+    def set_presentation(presentation_class)
+      @presentation_class = presentation_class
+    end
+
+    def string
+      if @presentation_class then
+        @content = @presentation_class.new(@value).string 
+      else
+        @content = @value.to_s 
+      end
+      super()
+    end
+
+  end
+
+end
+end
+