ctioga2 0.3 → 0.4

data/lib/ctioga2/git-fools-svn.rb

@@ -1,7 +0,0 @@
-# Automatically generated file.
-module CTioga2
-
-
-   Version::register_svn_info('$Revision: 312$', 
-                              '$Date: Mon Apr 16 21:55:21 2012 +0000$')
-end

data/lib/ctioga2/graphics/elements/redirecting-container.rb~

@@ -1,123 +0,0 @@
-# containers.rb: drawables that contains other drawables
-# copyright (c) 2006, 2007, 2008, 2009 by 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 (in the COPYING file).
-
-
-require 'ctioga2/utils'
-require 'ctioga2/log'
-
-module CTioga2
-
-  Version::register_svn_info('$Revision$', '$Date$')
-
-  module Graphics
-
-    module Elements
-      
-      # A Container is a drawable object that contains several others, its
-      # #elements.
-      class Container < TiogaElement
-
-        # All drawable Element contained in this object. It may
-        # contain other Container subobjects.
-        attr_accessor :elements
-
-        # The subframe position of this element with respect to its
-        # parent. It is a Types::Box object.
-        attr_accessor :subframe
-
-        # A reference to the RootObject
-        attr_accessor :root_object
-
-        # The Legends::LegendArea dedicated to the display of the
-        # legend of this object and its children, or _nil_ if the
-        # parent should handle the display.
-        attr_accessor :legend_area
-
-        # The Legends::LegendStorage that holds all the legends of the
-        # object
-        attr_accessor :legend_storage
-
-        # Creates an empty new Container with the given _parent_.
-        def initialize(parent = nil, root = nil)
-          @parent = parent
-          
-          # elements to be given to tioga
-          @elements = []
-
-          # By default the frame takes up all the space.
-          @subframe = Types::MarginsBox.new(0, 0, 0, 0)
-
-          @root_object = root
-
-          @legend_storage = Legends::LegendStorage.new
-
-          # By default, don't display legends.
-          @legend_area = nil
-        end
-
-        # Returns the number of child elements
-        def size
-          return @elements.size
-        end
-
-        # Sometimes, the value of the subframe is _nil_ and determined
-        # during the plot. This function is guaranteed to return the
-        # correct value. It takes a reference to a FigureMaker object.
-        def actual_subframe(t)
-          return @subframe
-        end
-
-        # Adds an element
-        def add_element(element)
-          element.parent = self
-          @elements << element
-          
-          # If the element has a curve_style, we add it as a
-          # CurveLegend
-          if element.respond_to?(:curve_style) and 
-              element.curve_style.has_legend?
-            add_legend_item(Legends::CurveLegend.new(element.curve_style))
-          elsif element.is_a? Container
-            add_legend_item(element)
-          end
-
-          # We call LocationStyle#finalize! if possible
-          if(self.respond_to?(:style) and element.respond_to?(:location))
-            element.location.finalize!(self.style)
-          end
-        end
-
-
-        # Adds a legend item to the #associated_legend_storage
-        def add_legend_item(item)
-          @legend_storage.add_item(item)
-        end
-
-        # \todo provide coordinate conversion facilities...
-
-        protected 
-
-        # Creates the appropriate subfigure and draws all its elements
-        # within.
-        def real_do(t)
-          t.subfigure(@subframe.to_frame_margins(t)) do 
-            for el in @elements
-              el.do(t)
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/ctioga2/metabuilder/types/generic.rb~

@@ -1,225 +0,0 @@
-# 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$', '$Date$')
-
-
-  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
-
-
-      # A choice between different symbols based on regular expressions.
-      class REListParameter < Type
-
-        type_name :re_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.
-          @re_hash = type[:list].dup
-        end
-        
-        def type_name
-          return 'relist'
-        end
-        
-        def string_to_type_internal(str)
-          for k,v in @re_hash
-            if str =~ /^\s*#{k}\s*$/
-              return v
-            end
-          end
-          raise IncorrectInput, "Invalid input: #{str} should match " +
-            @re_hash.keys.map {|s| s.to_s}.join(',')
-        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*/
-          @separator_out = '|'
-        end
-
-        def type_name
-          return 'set'
-        end
-
-        def string_to_type_internal(str)
-          multiply = nil
-          if str =~ /(.*)\*\s*(\d+)\s*$/
-            multiply = $2.to_i
-            str = $1
-          end
-          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|
-              array << Utils::mix_objects(e,s, i * fact)
-            end
-          else
-            array = super
-          end
-          if multiply
-            # Seems that I've finally managed to understand what zip
-            # is useful for !
-            array = array.zip(*([array]*(multiply-1))).flatten(1)
-          end
-          return array
-        end
-
-      end
-
-    end
-  end
-end