ctioga 1.11.1

data/lib/CTioga/debug.rb

@@ -0,0 +1,199 @@
+# debug.rb, copyright (c) 2006 by Vincent Fourmond: 
+# The debugging functions for PlotMaker
+  
+# 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 'CTioga/log'
+
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 653 $', '$Date: 2007-11-15 21:58:42 +0100 (Thu, 15 Nov 2007) $')
+
+  # This module contains code to be included by PlotMaker for debugging.
+  # Even if it doesn't deserve a real module of it's own, it makes sense
+  # to have it separated anyway.
+  module Debug
+
+    include Tioga::FigureConstants
+    include Log
+
+    # These variables are scoped at the module level so
+    # that they are shared among all bits of code - as they can only be
+    # set in one place.
+    @@debug = false
+    @@debug_indent = 0
+    @@debug_indent_string = "  "
+
+    # The function to use to display debugging information.
+    # Checks if we are in debug mode.
+    def debug_puts(str)
+      if @@debug
+        debug @@debug_indent_string * @@debug_indent +
+          str
+      end
+    end
+
+    # A function using the hooks defined by Bill to display what is
+    # happenning inside Tioga
+    def debug_figmaker(t)
+      t.def_enter_context_function { 
+        debug_puts "Tioga: enter new context\t" + 
+        frames_str(t)
+        @@debug_indent += 1
+      }
+      t.def_exit_context_function { 
+        @@debug_indent -=1
+        debug_puts "Tioga: exit context\t" + frames_str(t)
+      }
+        
+      t.def_enter_show_plot_function { |bounds| 
+        debug_puts "Tioga: enter show_plot #{bounds[0]} #{bounds[1]} " +
+        "#{bounds[2]} #{bounds[3]}" 
+        @@debug_indent += 1
+      }
+        
+      t.def_exit_show_plot_function { |bounds| 
+        @@debug_indent -=1
+        debug_puts "Tioga: exit show_plot #{bounds[0]} #{bounds[1]} " +
+        "#{bounds[2]} #{bounds[3]}" 
+      }
+        
+      t.def_enter_subfigure_function { |margins| 
+        debug_puts "Tioga: enter subfigure #{margins[0]} #{margins[1]} " +
+        "#{margins[2]} #{margins[3]}" 
+        debug_puts "Tioga: frames " + frames_str(t)
+      }
+        
+      t.def_enter_subplot_function { |margins| 
+        debug_puts "Tioga: enter subplot #{margins[0]} #{margins[1]} " +
+        "#{margins[2]} #{margins[3]}" 
+        debug_puts "Tioga: frames " + frames_str(t)
+      }
+    end
+
+    def debug_patterns(t)
+      t.def_figure('Test_patterns') { 
+        setup_real_size_bop(t)
+        test_pattern(t) 
+      }
+      t.make_preview_pdf(t.figure_index('Test_patterns'))
+
+      t.def_figure('Test_patterns_right') { 
+        setup_real_size_bop(t)
+        test_pattern_right(t) 
+      }
+      t.make_preview_pdf(t.figure_index('Test_patterns_right'))
+    end
+
+    # This function is taken from Tioga; it is used to check the alignements
+    # of the TeX text and PDF image.
+    def test_pattern(t)
+      t.line_width = 1
+      t.stroke_frame
+      # we make it asymmetric to catch other kinds of problems
+      t.set_subframe('left' => 0.1 , 'right' => 0.05,
+                     'top' => 0.05, 'bottom' => 0.1)
+      centerx = t.bounds_xmin + 0.5 * t.bounds_width
+      chr_ht = t.default_text_height_dy
+      t.stroke_color = Red
+      t.line_width = 0.2
+      t.stroke_line(t.bounds_xmax, t.bounds_ymin, t.bounds_xmax, t.bounds_ymax)
+      t.stroke_line(centerx, t.bounds_ymin, centerx, t.bounds_ymax)
+      t.stroke_line(t.bounds_xmin, t.bounds_ymin, t.bounds_xmin, t.bounds_ymax)
+      y = t.bounds_ymin; dy = t.bounds_height / 10
+      scale = 0.85;
+      10.times do
+        t.stroke_line(t.bounds_xmin, y, t.bounds_xmax, y)
+        t.show_text('text'=>"Left", 'x'=> t.bounds_xmin, 'y' => y,
+                    'scale'=>0.5+scale, 'justification' => LEFT_JUSTIFIED)
+        t.show_text('text'=>"Center", 'x'=> centerx, 'y' => y,
+                    'scale'=>1.8-scale, 'justification' => CENTERED)
+        t.show_text('text'=>"Right", 'x'=> t.bounds_xmax, 'y' => y,
+                    'scale'=>0.5+scale, 'justification' => RIGHT_JUSTIFIED)
+        scale = scale - 0.1
+        y = y + dy
+      end 
+      t.stroke_line(t.bounds_xmin, t.bounds_ymax, t.bounds_xmax, t.bounds_ymax)
+      t.justification = CENTERED
+      t.show_text('text'=>"TeX and PDF Alignment Test Pattern",
+                  'side'=> TOP, 'pos' => 0.5, 'shift'=>0.3)
+      t.show_text('text'=>"Check for Proper Registration of Text and Graphics",
+                  'side'=>BOTTOM, 'pos' => 0.5, 'shift'=> 1.6, 'scale'=>0.4)
+      t.show_text(
+                  'text'=>'If needed, adjust by changing ' + 
+                  '{\sffamily FigureMaker.tex\_xoffset} ' +
+                  'and {\sffamily FigureMaker.tex\_yoffset}.',
+                  'side'=>BOTTOM, 'pos' => 0.5, 'shift'=> 3.9, 'scale'=>0.3)
+    end
+
+    # This function is taken from Tioga; it is used to check the alignements
+    # of the TeX text and PDF image.
+    def test_pattern_right(t)
+      t.line_width = 1
+#       t.stroke_frame
+      margin = 0.1
+      # we make it asymmetric to catch other kinds of problems
+      t.set_subframe('left' => 0.1 , 'right' => 0.05,
+                     'top' => 0.05, 'bottom' => 0.1)
+      centerx = t.bounds_xmin + 0.5 * t.bounds_width
+      chr_ht = t.default_text_height_dy
+      t.stroke_color = Red
+      t.line_width = 1
+      t.stroke_line(t.bounds_xmax, t.bounds_ymin, t.bounds_xmax, t.bounds_ymax)
+      t.stroke_line(centerx, t.bounds_ymin, centerx, t.bounds_ymax)
+
+      y = t.bounds_ymin; dy = t.bounds_height / 10
+      scale = 0.85;
+      10.times do
+        t.stroke_line(centerx, y, t.bounds_xmax, y)
+        t.show_text('text'=>"Left", 'x'=> t.bounds_xmin, 'y' => y,
+                    'scale'=>0.5+scale, 'justification' => LEFT_JUSTIFIED)
+        t.show_text('text'=>"Center", 'x'=> centerx, 'y' => y,
+                    'scale'=>1.8-scale, 'justification' => CENTERED)
+        t.show_text('text'=>"Right", 'x'=> t.bounds_xmax, 'y' => y,
+                    'scale'=>0.5+scale, 'justification' => RIGHT_JUSTIFIED)
+        scale = scale - 0.1
+        y = y + dy
+      end 
+      t.stroke_line(centerx, t.bounds_ymax, t.bounds_xmax, t.bounds_ymax)
+      t.justification = CENTERED
+      t.show_text('text'=>"TeX and PDF Alignment Test Pattern",
+                  'side'=> TOP, 'pos' => 0.5, 'shift'=>0.3)
+      t.show_text('text'=>"Check for Proper Registration of Text and Graphics",
+                  'side'=>BOTTOM, 'pos' => 0.5, 'shift'=> 1.6, 'scale'=>0.4)
+      t.show_text(
+                  'text'=>'If needed, adjust by changing ' + 
+                  '{\sffamily FigureMaker.tex\_xoffset} ' +
+                  'and {\sffamily FigureMaker.tex\_yoffset}.',
+                  'side'=>BOTTOM, 'pos' => 0.5, 'shift'=> 3.9, 'scale'=>0.3)
+    end
+
+    # Returns a string representing the 'options' of the FigureMaker object
+    # given.
+    def figmaker_options(t)
+      return '' unless @@debug
+      s = ""
+      for meth in t.methods.sort
+        if t.respond_to?((meth + '=').to_sym)
+          begin
+            s += "\n#{meth}: " + t.send(meth).to_s
+          rescue
+            # In case the method did need some arguments...
+          end
+        end
+      end
+      return s
+    end
+
+  end
+
+end

data/lib/CTioga/dimension.rb

@@ -0,0 +1,133 @@
+# dimension.rb: a class handling relative/absolute dimensions
+# copyright (c) 2007,2008 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 'CTioga/log'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 831 $', '$Date: 2008-08-19 14:23:54 +0200 (Tue, 19 Aug 2008) $')
+
+  # A class which represents a dimension, either absolute or
+  # relative.
+  class Dimension
+
+    # TODO: we should extend this class to provide a comprehensive
+    # way to specify the position of a point and provide coordinate
+    # conversions to frame (including in postscript points) and
+    # figure coordinates.
+
+    include Tioga::Utils
+
+    # The type of the dimension :
+    # * :abs means absolute
+    # * :rel is relative
+    attr_accessor :type
+
+    # The actual dimension. Its meaning depends on the
+    # value of type:
+    # * :abs : the value is in bp points
+    # * :rel : the value is a fraction of the corresponding size
+    #   in the given plot.
+    attr_accessor :value
+
+    # Creates a dimension. If the dimension contains a letter,
+    # it will be interpreted in terms of a TeX size.
+    # If it contains a percent - or nothing, it will be interpreted as
+    # a relative measure. If it is a float, it will be interpreted
+    # as a relative measure unless _type_ is not nil.
+    def initialize(spec, type = nil)
+      case spec
+      when /^\s*[\d.]+[a-zA-Z]+\s*$/
+        @type = :abs
+        @value = tex_dimension_to_bp(spec)
+      when /^\s*([\d.]+)\s*%\s*$/
+        @type = :rel
+        @value = $1.to_f * 0.01 # Value in percents
+      when Float
+        @value = spec
+        @type = type || :rel
+      when /^\s*([\d.]+)/
+        @value = spec.to_f
+        @type = type || :rel
+      end
+    end
+
+    # Converts self to a relative dimension. _frames_ is the frames
+    # of the current object (outer_frames) expressed in big points.
+    def to_relative(frames, side = :horizontal)
+      # The easy thing first:
+      return @value if @type == :rel
+      if side == :horizontal
+        return @value/((frames[1] - frames[0]).abs)
+      else
+        return @value/((frames[3] - frames[2]).abs)
+      end
+    end
+
+    # Converts self to an absolute dimension. _frames_ is the frames
+    # of the current object (outer_frames) expressed in big points.
+    def to_absolute(frames, side = :horizontal)
+      # The easy thing first:
+      return @value if @type == :abs
+      if side == :horizontal
+        return @value * ((frames[1] - frames[0]).abs)
+      else
+        return @value * ((frames[3] - frames[2]).abs)
+      end
+    end
+
+    # Scales the dimension by the given factor
+    def scale!(fact)
+      @value *= fact
+      return self
+    end
+
+
+    # Converts an absolute dimension in terms of a relative
+    # one, using the given frames.
+    def Dimension.absolute_to_relative(dimensions, frames)
+      ret_val = []
+      ret_val[0] = dimensions[0]/((frames[1] - frames[0]).abs)
+      ret_val[1] = dimensions[1]/((frames[1] - frames[0]).abs)
+      ret_val[2] = dimensions[2]/((frames[3] - frames[2]).abs)
+      ret_val[3] = dimensions[3]/((frames[3] - frames[2]).abs)
+      return ret_val
+    end
+
+    def self.update_extensions(extensions, new_ext)
+      4.times do |i|
+        extensions[i] = new_ext[i] unless  new_ext[i] < extensions[i]
+      end
+      return extensions
+    end
+  end
+
+  # A dimension that represents text sizes. Absolute has the same meaning,
+  # but relative values are relative to default_text_height_x/y
+  class TextDimension < Dimension
+    
+    # These two functions don't make any sense here
+    undef :to_relative, :to_absolute
+
+    # Converts the dimension to figure coordinates in the given direction
+    def to_figure(t, direction)
+      if @type == :rel
+        return @value * t.send("default_text_height_d#{direction.to_s}")
+      else
+        return t.send("convert_output_to_figure_d#{direction.to_s}", 
+                      @value * 10)
+      end
+    end
+  end
+
+end

data/lib/CTioga/elements.rb

@@ -0,0 +1,17 @@
+# elements.rb, copyright (c) 2006 by Vincent Fourmond: 
+# The class describing a Tioga element
+  
+# 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 'CTioga/elements/base'
+require 'CTioga/elements/curves'
+require 'CTioga/elements/containers'
+require 'CTioga/elements/tioga_primitives'

data/lib/CTioga/elements/base.rb

@@ -0,0 +1,84 @@
+# base.rb: basis of all plottable elements
+# copyright (c) 2006,2007,2008 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 'Dobjects/Dvector'
+require 'CTioga/debug'
+require 'CTioga/log'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 818 $', '$Date: 2008-06-23 23:20:47 +0200 (Mon, 23 Jun 2008) $')
+
+  # The base class for every single object that has to appear at one
+  # point as a command in the tioga plot. It provides only one function:
+  # do(f), which will be used by subclasses to do what they need.
+
+  class TiogaElement
+    include Debug
+    include Log
+
+    # The parent element.
+    attr_accessor :parent
+
+    # this function must be called with a FigureMaker object to
+    # draw the contents of the TiogaElement onto it. It calls
+    # the function real_do, which should be redefined by the
+    # children. You can redefine do too if you need another
+    # debugging output.
+    def do(f)
+      debug "plotting #{self.inspect}"
+      real_do(f)
+    end
+
+    # this function returns true if the object needs a CurveStyle parameter.
+    def need_style?
+      return false
+    end
+
+    # We plot everything but parent. If a prefix is given, it is prepended
+    # to all lines but the first (for indentation)
+    def inspect(prefix="")
+      ret = "#<#{self.class.name}:\n"
+      for i in instance_variables
+        next if i == "@parent"
+        var = instance_variable_get(i)
+        ret += "#{prefix}  - #{i} -> "
+        if var.is_a? TiogaElement
+          ret += "#{var.inspect("#{prefix}  ")}\n"
+        else
+          ret += "#{var.inspect}\n"
+        end
+      end
+      ret += "#{prefix}>"
+      return ret
+    end
+  end 
+  
+
+  # A class to represent a small function call to FigureMaker. Can represent
+  # basically anything.
+  class TiogaFuncall < TiogaElement
+
+    # _symbol_ is the symbol to be called, and the remainder will be used
+    # as arguments for the call.
+    def initialize(symbol, *args)
+      @symbol = symbol
+      @args = args
+    end
+    
+    def real_do(f)
+      f.send(@symbol, *@args)
+    end
+  end
+
+end

data/lib/CTioga/elements/containers.rb

@@ -0,0 +1,578 @@
+# containers.rb: plottable elements that hold other plottable elements
+# copyright (c) 2006,2007,2008 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 'Dobjects/Dvector'
+require 'CTioga/debug'
+require 'CTioga/log'
+require 'CTioga/plot_style'
+require 'CTioga/layout'
+require 'CTioga/legends'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 839 $', '$Date: 2008-10-11 14:47:08 +0200 (Sat, 11 Oct 2008) $')
+
+  # A class that can hold several 'child' elements, such as
+  # the SubPlot class and the Region class. A missed funcall will
+  # result in a try to call the parent, if it exists.
+  class Container < TiogaElement
+    # The various properties defining the class
+    attr_reader :elements, :funcalls
+
+    # A rescale attribute
+    attr_accessor :rescale
+
+    # Whether or not to show legend for the current plot
+    attr_accessor :show_legend
+
+    # If this attribute is set, all legends here will be completely
+    # ignored.
+    attr_accessor :disable_legend
+
+    # The frame of the element, if that element is the root. Expressed
+    # in big points. Supposedly, nothing should stick out of this frame.
+    # If the element is not root, this should be nil.
+    #
+    # As usual, [left, right, top, bottom]
+    attr_accessor :root_frame
+
+    # The layout preferences for the object, that is, useful
+    # information that will be used by the object to make decisions
+    # about layouts.
+    attr_accessor :layout_preferences
+
+    # The layout !!! This is the one handling the object, but
+    # that does not necessarily mean that self == layout.root_object.
+    # This might even seldom be the case.
+    attr_accessor :layout
+
+    # Override the layouts opinion about where the
+    # object should be placed. Please note that there is no
+    # need for a layout in the case when this attribute is not nil
+    # and not empty. Used with care ;-) !
+    attr_accessor :force_position
+
+    # If true, the plot will keep its legend element, and
+    # the ones communicated by the children for itself.
+    # If false, legend informations are sent to the parent and simply
+    # ignored otherwise.
+    attr_accessor :accept_legend
+
+    def initialize(p = nil)
+      @parent = p
+
+      # elements to be given to tioga
+      @elements = []
+
+      # Used to add initial function calls.
+      @funcalls = []
+
+      # Used to store legends internally. It is an array of CurveStyle
+      @legend_info = []
+      # Whether to accept legends or forward them to the parent
+      @accept_legend = false
+      # Whether or not to show them
+      @show_legend = false
+
+      # A rescale factor:
+      @rescale = false
+
+      # The root frame:
+      @root_frame = nil
+
+      @layout_preferences = LayoutPreferences.new
+    end
+
+    # Converts the current layout using Layout#convert_layout
+    def convert_layout(cls)
+      if @layout
+        @layout = @layout.convert_layout(cls)
+      else
+        @layout = cls.new(self)
+      end
+    end
+
+    def add_elem(elem)
+      elem.parent = self
+      @elements << elem
+
+      # If the element has a style, then we assume it is a curve,
+      # and add legend accordingly
+      if elem.respond_to?(:style) and elem.style.has_legend?
+        add_legend_info(CurveLegend.new(elem.style))
+      end
+    end
+
+    def add_funcall(funcall)
+      funcall.parent = self
+      @funcalls << funcall
+    end
+
+    # If legends are disable, we drop the legend altogether.
+    # If we accept legends, add the legend, if it is not false.
+    # Else, forward it to the parents.
+    #
+    # _info_ may be either a CurveStyle or a LegendLine object.
+    def add_legend_info(info)
+      return unless info.is_a?(LegendItem)
+      return if @disable_legend
+      if @accept_legend
+        debug "Adding legend information #{info.inspect}"
+        @legend_info << info if info
+      elsif parent
+        debug "Forwarding legend to the parent"
+        parent.add_legend_info(info)
+      else
+        info "Legend information dropped - this might not be expected"
+      end
+    end
+
+    # Do the funcalls and some other initialization as well
+    def make_funcalls(t)
+      t.rescale(@rescale) if @rescale
+      for f in @funcalls
+        f.do(t)
+      end
+    end
+
+    def has_plots?
+      @elements.each {|e| 
+        return true if e.is_a?(Curve2D)
+        if e.respond_to? :has_plots? and e.has_plots?
+          return true
+        end
+      }
+      return false
+    end
+
+    # The internal_get_boundaries is the function responsible for
+    # doing the real work behind getting the boundaries for objects.
+    # Some objects might want to use some boundaries but report other
+    # to their parents; they can rely on internal_get_boundaries to
+    # give the right result for them and modify get_boundaries to suit
+    # their needs.
+    def internal_get_boundaries
+      bounds = []
+      @elements.each do |e|
+        bounds.push(e.get_boundaries) if e.respond_to? :get_boundaries
+      end
+      b = Curve2D.compute_boundaries(bounds)
+      return b
+    end
+
+    # This function can be used by external objects to query
+    # the boundaries this object would like to report. The
+    # default behaviour is to not report anything to the parent.
+    def get_boundaries
+      return [0.0/0.0, 0.0/0.0, 0.0/0.0, 0.0/0.0]
+    end
+    
+
+    # We redirect missed funcall to the @parent
+    def method_missing(meth, *args)
+      if @parent
+        debug "Redirecting call #{meth} to parent"
+        @parent.send(meth,*args)
+      else
+        raise NoMethodError.new("No such method: #{meth}",meth,args)
+      end
+    end
+
+    # Whether or not we should display a legend
+    def display_legend?
+      @show_legend && has_plots?  && has_legends? && ( not @disable_legend)
+    end
+
+  end
+
+  # This class represent a subplot, a subfigure or the main plot.
+
+  class SubPlot < Container
+    
+#     # Various textual objects laying around:
+#     attr_accessor :title, :xlabel, :ylabel
+
+#     # Ticks
+#     attr_accessor :xticks, :yticks
+
+    # various important things:
+    attr_accessor :legend_specs
+    
+    # The actual boundaries used for making the plot. This element is only
+    # filled in at the exact moment of the plotting. It is provided so that
+    # subplots or curves may use it.
+    attr_reader :effective_bounds
+    
+    # The amount of space that should be left between the given curve and
+    # the box. It is an array [left,right,top,bottom].
+    attr_accessor :plot_margins
+
+    # A PlotSyle object carrying information about the style of the plot,
+    # such as titles/legends/background color...
+    attr_accessor :plot_style
+
+
+#     # The appearance of the edgesax
+#     attr_accessor :edges
+
+    def number
+      return @elements.length
+    end
+
+    # Returns a purified version of #legend_specs with only plot margins
+    def plot_margins(specs)
+      ret = {}
+      for k in specs.keys
+        if k =~ /plot_(left|right|top|bottom)_margin/
+          ret[$1] = specs[k]
+        end
+      end
+      return ret
+    end
+    
+    def initialize(type = :subplot, parent = nil)
+      super(parent)
+      # @type is the type of the element, :subfigure, :subplot or nil
+      # to indicate that it is the main plot ;-) !
+
+      # the direct parent of that element. If nil, it means that it's
+      # directly a subchild of the main plot.
+      @parent = parent
+
+      # Defaults to no margins (looks somehow less nice in many cases)
+      @plot_margins = [0.0,0.0,0.0,0.0]
+      
+      # Some legend tweaking:
+      if type == :subplot || type == nil
+        @show_legend = true
+        @accept_legend = true
+      else
+        @show_legend = false
+        @accept_legend = false
+      end
+
+#       @title = Label.new(:title)
+#       @title.label = "A nice plot" unless parent
+
+#       @xlabel = Label.new(:xlabel)
+#       @xlabel.label = "$x$" unless parent
+
+#       @ylabel = Label.new(:ylabel)
+#       @ylabel.label = "$y$" unless parent
+
+#       @xticks = TickLabels.new(:xaxis_numeric_label)
+#       @yticks = TickLabels.new(:yaxis_numeric_label)
+
+
+      # the hash used by show_plot_with_legend: we inherit it from the parent
+      # if it exists
+      @legend_specs = if parent 
+                        parent.legend_specs.dup
+                      else
+                        {}
+                      end
+     
+      # User-specified boundaries (left, right, top, bottom)
+      @bounds = [nil,nil,nil,nil]
+      @effective_bounds = nil
+
+#      @edges = EdgesAndAxes.new(@xticks, @yticks)
+
+      @plot_style = PlotStyle.new(self, parent ? true : false)
+    end
+
+    # Returns the inner frames of the object in terms of absolute
+    # big points.
+    def inner_frame(t)
+      frame = outer_frame(t)
+
+      h = t.legend_defaults.dup
+      h.update @legend_specs
+      frame = Utils::apply_margin_to_frame(frame, h) if display_legend?
+      return frame
+    end
+
+    # The outer frame is the reference frame for the object. It is
+    # either the root frame (the whole plot) or the inner frame of the
+    # parent object. Objects should refrain from writing anything
+    # outside this outer frame.
+    def outer_frame(t)
+      # The outer frame is either  the root frame
+      # or the inner_frame of the parent.
+      return @root_frame || parent.inner_frame(t)
+    end
+
+    def bound_left=(a)
+      @bounds[0] = a
+    end
+
+    def bound_right=(a)
+      @bounds[1] = a
+    end
+
+    def bound_top=(a)
+      @bounds[2] = a
+    end
+
+    def bound_bottom=(a)
+      @bounds[3] = a
+    end
+
+    # Used by children to notify that an axis shoudn't be used
+    # anymore.
+    #
+    # TODO: move this to plot_style...
+    def disable_axis(axis)
+      case axis
+      when :x
+        add_funcall(TiogaFuncall.new(:top_edge_type=, AXIS_LINE_ONLY))
+      when :y
+        add_funcall(TiogaFuncall.new(:right_edge_type=, AXIS_LINE_ONLY))
+      end
+    end
+
+
+    def set_margin(which, what)
+      @margins[which.to_s] = what.to_f
+    end
+
+    # this function computes the boundaries for the given plot...
+    def compute_boundaries
+      # We want to use the internal version of get_boundaries
+      bounds = internal_get_boundaries
+
+      # Increase the boundary with the margins
+      width = bounds[1] - bounds[0]
+      bounds[0] -= width * @plot_margins[0]
+      bounds[1] += width * @plot_margins[1]
+      height = bounds[2] - bounds[3]
+      bounds[2] += height * @plot_margins[2]
+      bounds[3] -= height * @plot_margins[3]
+
+      # overriding with user-specified values if applicable
+      nb_nans = 0
+      4.times do |i|
+        if @bounds[i] 
+          bounds[i] = @bounds[i] 
+        end
+        # Replace NaNs with 0
+        if bounds[i].nan?
+          bounds[i] = 0 
+          nb_nans += 1
+        end
+      end
+      # In the case all boundaries are NaN, we provide a 0->1 mapping
+      if nb_nans == 4
+        return [0,1,1,0]
+      end
+      return bounds
+    end
+
+    # Does the plot have legends ?
+    def has_legends?
+      return (not @legend_info.empty?)
+    end
+
+
+    # this function takes a FigureMaker object and returns the block of
+    # instructions corresponding to the current contents of the SubPlot.
+    # To actually plot it correctly, it just needs a further wrapping
+    # in subplot or subfigure.
+
+    def make_main_block(t)
+      if has_plots?
+        block = proc {
+          t.context {
+            # First compute the boundaries:
+            # We first check if the object was required to be somewhere
+            if @force_position and !@force_position.empty?
+              legend_specs = @force_position.to_frame("plot_%s_margin")
+            else
+              # Ask the layout.
+              legend_specs = @layout.legend_specs(t)
+            end
+            # We always wrap the plot in a show_plot_with_legend,
+            # even if there is no legends. That, anyway, is the
+            # job of the layout to see this.
+            debug "Plot specs: #{legend_specs.inspect}"
+            debug "Plot legends #{display_legend?.inspect}: "
+            debug " - @show_legend = #{@show_legend.inspect}"
+            debug " - @disable_legend = #{@disable_legend.inspect}"
+            debug " - has_plots? = #{has_plots?.inspect}"
+            debug " - has_legends? = #{has_legends?.inspect}"
+            debug "Reference frame (#{self.class}): #{Utils::frames_str(t)}"
+
+            margins = plot_margins(legend_specs)
+            
+            t.context do
+              # The call has to be wrapped within a
+              # context call, as it turns the frame reference into
+              # the legend subframe specification afterwards...
+              t.set_subframe(margins)
+              @effective_bounds = compute_boundaries
+              debug "Plot boundaries: #{@effective_bounds.inspect}"
+              debug "Box frame (#{self.class}): #{Utils::frames_str(t)}"
+              
+              @plot_style.show_edges(t, self)
+              
+              t.show_plot(@effective_bounds) {
+                # output frame debug information./
+                debug "Plot frame (#{self.class}): #{Utils::frames_str(t)}"
+                if root_frame
+                  debug "Root frame: #{Utils::framespec_str(root_frame)}"
+                end
+                
+                debug "Inner frame: #{Utils::framespec_str(inner_frame(t))}"
+
+                @plot_style.show_background(t, self)
+                @plot_style.show_labels(t, self)
+
+                @elements.each do |e|
+                  e.do(t)
+                end
+                # We remove all the legends here, as they should all be
+                # handled by the children, or forwarded here.
+                t.reset_legend_info
+                debug "Current figure has #{@legend_info.size} legends"
+                debug "Legends #{@legend_info.inspect}"
+                #                 for s in @legend_info
+                #                   t.save_legend_info(s.legend_info)
+                #                 end
+              } 
+                
+              # Now, additional axes, if applicable
+              t.context do 
+                t.set_bounds(@effective_bounds)
+                # Call the stuff for additional axes.
+                @plot_style.edges.show_additional_axes(t, self)
+              end
+
+            end
+            @plot_style.legend_style.show_legends(t, legend_specs, 
+                                                  margins, @legend_info)
+          }
+        }
+      else
+        block = proc do
+          @elements.each do |e|
+            e.do(t)
+          end
+        end
+      end
+
+      return proc do
+        make_funcalls(t)
+        block.call
+      end
+
+    end
+
+    # this function sets up the appropriate environment and calls the block...
+    def do(t)
+      debug "Making main block for object: #{identify(self)}"
+      make_main_block(t).call
+    end
+
+  end
+
+  # The Region class handles the cases where the user wants some parts
+  # between curves to be coloured. In this case, all the curves which
+  # are included between the --region and --end options will
+  class Region < Container
+
+    # Style attributes
+    attr_accessor :region_color, :region_transparency
+    
+
+    # Some general options
+    attr_accessor :dont_display, :region_debug
+
+    # Filling rules:
+    attr_accessor :invert_rule, :fill_twice 
+    
+    # We want to call the parent's disable legend.
+    undef :disable_legend, :disable_legend=
+    # And as well for rescale.
+    undef :rescale=, :rescale
+    
+    def initialize(parent = nil)
+      super
+      @region_color = [0.9,0.9,0.9] # Very light gray.
+      @region_transparency = 0
+      @dont_display = false
+    end
+
+    # Fills the regions using the index to choose the closing path
+    # for the first curve and opposed ones for next curves.
+    def fill_region(t,i)
+      # We need to wrap in a context, else the clipping path screws up
+      # everyting
+      t.context do 
+        debug "Filling with parameter #{i}"
+        bound = internal_get_boundaries
+        for el in @elements
+          if el.respond_to?(:make_path)
+            el.make_path(t)
+            # We close the path with a line coming back alternatively to
+            # the top and the bottom
+            close_to = bound[i % 2 + 2]
+            el.close_path(t, close_to)
+            i += 1
+            
+            # If the debugging flag is set, we heavily tamper with the
+            # style of the elements to force the fill where
+            # we would clip.
+            if @region_debug
+              el.style.fill_type = close_to
+              el.style.fill_transparency = 0.8
+              el.style.fill_color = el.style.color || el.style.marker_color
+            end
+          end
+          t.clip
+        end
+        
+        t.fill_color = @region_color
+        t.fill_transparency = @region_transparency
+        t.fill_rect(bound[0], bound[3], bound[1] - bound[0], 
+                    bound[2] - bound[3])
+      end
+    end
+
+    # Region must return its true boundaries.
+    def get_boundaries
+      internal_get_boundaries
+    end
+    
+    def do(t)
+      debug "Region: plotting elements"
+      make_funcalls(t)
+      # We fill first, as it looks way better
+      if @fill_twice or (! @invert_rule)
+        fill_region(t,0)
+      end
+      if @fill_twice or @invert_rule
+        fill_region(t,1)
+      end
+      # Then, we plot the elements, unless we were told not to
+      # by --region-dont-display
+      unless @dont_display
+        @elements.each do |e|
+          e.do(t) 
+        end
+      end
+
+    end
+
+  end
+
+end