ctioga2 0.0

data/lib/ctioga2/metabuilder/types/dates.rb

@@ -0,0 +1,43 @@
+# dates.rb: a Type to deal with dates
+# Copyright (C) 2006, 2009 Vincent Fourmond
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+require 'time'
+require 'ctioga2/utils'
+
+module CTioga2
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module MetaBuilder
+
+    # The module Types should be used for all subclasses of Type, to
+    # keep the place clean and tidy.
+    module Types
+
+      # A combination date/time
+      class DateTimeParameter < Type
+
+        type_name :date_time, 'date', Time.new
+
+        def string_to_type_internal(str)
+          return Time.parse(str)
+        end
+
+      end
+    end
+
+  end
+end

data/lib/ctioga2/metabuilder/types/lists.rb

@@ -0,0 +1,188 @@
+# lists.rb : Different Types to deal with types where
+# you can choose among several possibilities
+# Copyright (C) 2006, 2009 Vincent Fourmond
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+require 'ctioga2/utils'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+
+  module MetaBuilder
+
+    # The module Types should be used for all subclasses of
+    # Type, to keep the place clean and tidy.
+    module Types
+
+      # A regular expression matching true
+      TRUE_RE = /^\s*(true|yes|on)\s*$/i
+
+      # A regular expression matching false
+      FALSE_RE = /^\s*(false|no(ne)?|off)\s*$/i
+
+
+      # A boolean parameter
+      class BooleanParameter < Type
+
+        type_name :boolean
+        
+        def type_name
+          return 'bool'
+        end
+
+        # Yes, this *really* is a boolean !
+        def boolean?
+          return true
+        end
+        
+        def string_to_type_internal(str)
+          if str == true or str =~ TRUE_RE
+            return true
+          else
+            return false
+          end
+        end
+
+        def type_to_string_internal(val)
+          if val
+            return "true"
+          else
+            return "false"
+          end
+        end
+
+        # Booleans are a special case for option parser, as they
+        # are handled completely differently
+        def option_parser_long_option(name, biniou = nil)
+          return "--[no-]#{name}"
+        end
+      end
+
+      # A list of symbols. A hash :list must be provided that states
+      # the correspondance between the legal symbols that can be
+      # accepted by this parameter and their "english" name.
+      # This parameter can typically be used to prompt the user
+      # for different choices.
+      class ListParameter < Type
+
+        type_name :list
+
+        def initialize(type)
+          super
+          raise "type must have a :list key" unless type.has_key?(:list)
+          # We make a copy for our own purposes.
+          @hash = type[:list].dup
+        end
+        
+        def type_name
+          return 'list'
+        end
+        
+        def string_to_type_internal(str)
+          if @hash.has_key?(str.to_sym)
+            return str.to_sym
+          else
+            raise IncorrectInput, "Invalid input: #{str} should be one of " +
+              @hash.keys.map {|s| s.to_s}.join(',')
+          end
+        end
+
+        def type_to_string_internal(val)
+          return val.to_s
+        end
+      end
+
+      # An array of identical elements of type specified by :subtype. Defaults
+      # to String
+      class ArrayParameter < Type
+        type_name :array
+
+        def initialize(type)
+          super
+          # We make a copy for our own purposes.
+          subtype = type[:subtype] || {:type => :string}
+          @subtype = Type.get_type(subtype)
+          @separator = /\s*,\s*/
+          @separator_out = ','
+        end
+
+        def type_name
+          return 'array'
+        end
+
+        def string_to_type_internal(str)
+          ary = str.split(@separator)
+          return ary.map do |a|
+            @subtype.string_to_type(a)
+          end
+        end
+
+        def type_to_string_internal(val)
+          return val.map do |a|
+            @subtype.type_to_string(a)
+          end.join(@separator_out)
+        end
+      end
+
+      # A Type used for sets for Graphics::Styles::CircularArray
+      # objects.
+      #
+      # TODO: write a gradient stuff !!!
+      class SetParameter < ArrayParameter
+        type_name :set
+
+        def initialize(type)
+          super
+          @separator = /\s*\|\s*/
+          @sepatarot_out = '|'
+        end
+
+        def type_name
+          return 'set'
+        end
+
+        def string_to_type_internal(str)
+          if str =~ /^\s*gradient:(.+)--(.+),(\d+)\s*$/
+            s,e,nb = $1, $2, $3.to_i
+            s,e = @subtype.string_to_type(s),@subtype.string_to_type(e)
+            fact = if nb > 1
+                 1.0/(nb - 1)     # The famous off-by one...
+               else
+                 warn "Incorrect gradient number: #{nb}"
+                 1.0
+               end
+            array = []
+            nb.times do |i|
+              a = []
+              f = i * fact
+              e.each_index do |c|
+                a << s[c] * (1 - f) + e[c] * f
+              end
+              array << a
+            end
+            return array
+          else
+            return super
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ctioga2/metabuilder/types/numbers.rb

@@ -0,0 +1,97 @@
+# numbers.rb : Different Types to deal with numbers
+# Copyright (C) 2006 Vincent Fourmond
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+require 'ctioga2/utils'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module MetaBuilder
+
+    # The module Types should be used for all subclasses of
+    # Type, to keep the place clean and tidy.
+    module Types
+
+      # An integer
+      class IntegerParameter < Type
+
+        type_name :integer, 'number', 0
+
+        def string_to_type_internal(str)
+          return Integer(str)
+        end
+
+      end
+
+      # A float
+      class FloatParameter < Type
+
+        type_name :float, 'number', 0.0
+
+        def string_to_type_internal(str)
+          return Float(str)
+        end
+
+      end
+
+      # A Float Range.
+      class FloatRangeParameter < Type
+
+        RANGE_RE = /([^:]+):([^:]+)/
+
+        type_name :float_range, 'range'
+        
+        def string_to_type_internal(str)
+          raise IncorrectInput, "#{str} is not a valid range" unless 
+            str =~ RANGE_RE
+          s,e = Float($1), Float($2)
+          return Range.new(s,e)
+        end
+
+        def type_to_string_internal(value)
+          return "#{value.first.to_s}:#{value.last.to_s}"
+        end
+        
+      end
+
+      # Returns a [ start, end ] array where elements are either Float
+      # or _nil_.
+      class PartialFloatRangeType < Type
+
+        RANGE_RE = /([^:]+)?:([^:]+)?/
+
+        type_name :partial_float_range, 'range'
+        
+        def string_to_type_internal(str)
+          raise IncorrectInput, "#{str} is not a valid range" unless 
+            str =~ RANGE_RE
+          s,e = ($1 ? Float($1) : nil), ($2 ? Float($2) : nil)
+          return [s, e]
+        end
+
+        def type_to_string_internal(value)
+          return "#{value.first.to_s}:#{value.last.to_s}"
+        end
+        
+      end
+
+    end
+
+  end
+end

data/lib/ctioga2/metabuilder/types/strings.rb

@@ -0,0 +1,93 @@
+# strings.rb : Different Types to deal with strings
+# Copyright (C) 2006 Vincent Fourmond
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+require 'ctioga2/utils'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+
+  module MetaBuilder
+
+    # The module Types should be used for all subclasses of
+    # Type, to keep the place clean and tidy.
+    module Types
+
+      # A String
+      class StringParameter < Type
+
+        type_name :string
+        
+        def type_name
+          return 'text'
+        end
+        
+        def string_to_type(str)
+          return str
+        end
+      end
+
+      # A piece of text representing the path to a file.
+      class FileParameter < StringParameter
+
+        type_name :file
+        
+        # The file filters, Qt style.
+        attr_reader :filter
+
+        def initialize(type)
+          super(type)
+          @filter = @type[:filter]
+        end
+
+        def type_name
+          return 'file'
+        end
+
+      end
+
+      # A String or a regular expression
+      class StringOrRegexpParameter < Type
+
+        type_name :string_or_regexp
+        
+        def type_name
+          return 'regexp'
+        end
+        
+        def string_to_type(str)
+          if str =~ /^\/(.*)\/$/
+            return Regexp.new($1)
+          else
+            return str
+          end
+        end
+
+        def type_to_string(val)
+          if val.is_a? String
+            return val
+          else
+            return "/#{val}/"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ctioga2/metabuilder/types/styles.rb

@@ -0,0 +1,178 @@
+# styles.rb : Different Types to deal with various style arguments.
+# Copyright (C) 2006, 2009 Vincent Fourmond
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+require 'ctioga2/utils'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 96 $', '$Date: 2009-06-27 20:56:17 +0200 (Sat, 27 Jun 2009) $')
+
+  module MetaBuilder
+    module Types
+
+      # A color for use with Tioga, ie an [red, green, blue] array
+      # of values between 0 and 1.0. It accepts HTML-like colors, or
+      # three comma-separated values between 0 and 1.
+      class TiogaColorType < Type
+        
+        type_name :tioga_color, 'color'
+        
+        def string_to_type_internal(str)
+          if str =~ /^\s*#([0-9a-fA-F]{6})\s*$/
+              value =  $1.scan(/../).map {
+              |i| i.to_i(16)/255.0 
+            }
+          elsif str =~ /^\s*#([0-9a-fA-F]{3})\s*$/
+              value =  $1.scan(/../).map {
+              |i| i.to_i(16)/15.0 
+            }
+          else 
+            value = str.split(/\s*,\s*/).map do |s|
+              s.to_f
+            end
+          end
+          if value.size != 3
+            raise IncorrectInput, "You need exactly three values to make up a color"
+          end
+          return value
+        end
+      end
+
+      # A line style for Tioga. It will be represented as:
+      # 
+      #  a,b,c,d,...:e
+      #  
+      # This creates a line style of:
+      # 
+      #  [[a,b,c,d,...],e]
+      #  
+      # If the :e is omitted 0 is used.
+      class LineStyleType < Type
+        
+        type_name :tioga_line_style, 'line_style'
+        
+        def string_to_type_internal(str)
+          specs = str.split(/\s*,\s*/)
+          if specs.last =~ /:(.*)$/
+            phase = $1.to_f
+            specs.last.gsub!(/:.*$/,'')
+          else
+            phase = 0
+          end
+          p specs
+          return [ specs.map { |s| s.to_f }, phase]
+        end
+      end
+
+      # A marker Type for Tioga. Input as
+      # 
+      #  a,b(,c)?
+      #  
+      class MarkerType < Type
+        
+        type_name :tioga_marker, 'marker'
+        
+        def string_to_type_internal(str)
+          specs = str.split(/\s*,\s*/)
+          if specs.size == 2
+            return [specs[0].to_i, specs[1].to_i]
+          elsif specs.size == 3
+            return [specs[0].to_i, specs[1].to_i, specs[2].to_f]
+          else
+            raise IncorrectInput, "You need two or three values to make a marker"
+          end
+        end
+      end
+
+      # The type of edges/axis
+      class AxisType < Type
+
+        include Tioga::FigureConstants
+
+        ValidTypes = {
+          /hidden|off/i => AXIS_HIDDEN,
+          /line/i => AXIS_LINE_ONLY, 
+          /ticks/i => AXIS_WITH_TICKS_ONLY,
+          /major/i => AXIS_WITH_MAJOR_TICKS_ONLY, 
+          /major-num/i => AXIS_WITH_MAJOR_TICKS_AND_NUMERIC_LABELS,
+          /full/i => AXIS_WITH_TICKS_AND_NUMERIC_LABELS
+        }
+        
+        type_name :tioga_axis_type, 'axis_type'
+        
+        def string_to_type_internal(str)
+          for k,v in ValidTypes
+            if str =~ /^\s*#{k}\s*/
+                return v
+            end
+          end
+          raise IncorrectInput, "Not an axis type: #{str}"
+        end
+      end
+
+      # Justification (horizontal alignement)
+      class JustificationType < Type
+
+        include Tioga::FigureConstants
+
+        ValidTypes = {
+          /l(eft)?/i => LEFT_JUSTIFIED,
+          /c(enter)?/i => CENTERED,
+          /r(ight)?/ => RIGHT_JUSTIFIED
+        }
+        
+        type_name :tioga_justification, 'halign'
+        
+        def string_to_type_internal(str)
+          for k,v in ValidTypes
+            if str =~ /^\s*#{k}\s*/
+                return v
+            end
+          end
+          raise IncorrectInput, "Not a justification: #{str}"
+        end
+      end
+
+      # Vertical alignement
+      class AlignmentType < Type
+
+        include Tioga::FigureConstants
+
+        type_name :tioga_align, 'valign'
+        
+        ValidTypes = {
+          /t(op)?/i => ALIGNED_AT_TOP,
+          /c(enter)|m(idheight)/i => ALIGNED_AT_MIDHEIGHT,
+          /B|Baseline|baseline/ => ALIGNED_AT_BASELINE,
+          /b(ottom)?/ => ALIGNED_AT_BOTTOM
+        }
+        
+        
+        def string_to_type_internal(str)
+          for k,v in ValidTypes
+            if str =~ /^\s*#{k}\s*/
+                return v
+            end
+          end
+          raise IncorrectInput, "Not a vertical alignment: #{str}"
+        end
+      end
+
+    end
+  end
+end