ctioga 1.11.1

data/lib/CTioga/legends.rb

@@ -0,0 +1,29 @@
+# legends.rb: legend implementation of CTioga
+# copyright (c) 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'
+require 'CTioga/debug'
+require 'CTioga/curve_style'
+require 'CTioga/dimension'
+
+require 'CTioga/boundaries'
+
+require 'CTioga/legends/item'
+require 'CTioga/legends/style'
+require 'CTioga/legends/cmdline'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 838 $', '$Date: 2008-10-11 13:27:05 +0200 (Sat, 11 Oct 2008) $')
+
+end

data/lib/CTioga/legends/cmdline.rb

@@ -0,0 +1,187 @@
+# legends.rb: command-line parsing for legends
+# copyright (c) 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'
+require 'CTioga/debug'
+require 'CTioga/curve_style'
+require 'CTioga/dimension'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 870 $', '$Date: 2009-01-20 14:28:32 +0100 (Tue, 20 Jan 2009) $')
+
+  # A module to deal with legends...
+  module Legends
+
+    # Parse the legend positions
+    def self.legend_position(spec)
+      specs = {}
+      begin
+        margins = Utils::inset_margins(spec)
+        specs = margins.to_frame("legend_%s_margin")
+      rescue                  # in case of an incorrect margin
+        # Then we look for a position in the spirit of:
+        if spec =~ /\s*([tbc])([rlc])\s*(?::\s*([\d.eE+-]+),([\d.eE+-]+))?\s*$/
+          if($3 && $4)
+            x = Float($3)
+            y = Float($4)
+          else
+            x = y = nil
+          end
+          if $1 == 't'
+            specs['legend_top'] = y || 0.95 
+          elsif $1 == 'b'
+            specs['legend_bottom'] = y || 0.05 
+          else
+            specs['legend_vcenter'] = y || 0.5
+          end
+          if $2 == 'l'
+            specs['legend_left'] = x || 0.05
+          elsif $2 == 'r'
+            specs['legend_right'] = x || 0.95
+          else
+            specs['legend_hcenter'] = x || 0.5
+          end
+        else
+          raise "Incorrect legend (inside) position: '#{spec}'"
+        end
+      end
+      return specs
+    end
+
+    # Fills up an OptionParser, _parser_ with legend-related command-line
+    # options. Takes a Plotmaker _target_
+    def self.fill_option_parser(parser, target)
+
+      parser.separator "\nLegends:"
+      
+      parser.on("-l","--[no-]legend [LEGEND]",
+                 "Sets the legend of the next curve.") do |l|
+        target.override_style.legend = l
+      end
+
+      parser.on("--[no-]auto-legend", 
+                 "Whether to automatically add legends",
+                 "to curves") do |l|
+        target.autolegends = l
+      end
+
+      parser.on('-N', "--no-legends", 
+                 "Alias for --no-auto-legend") do
+        target.autolegends = false
+      end
+
+      ## Legend scale
+      parser.on("--legend-scale FACT",
+                 "Sets the scale for the legends") do |l|
+        target.add_elem_funcall(:legend_scale=, Float(l))
+      end
+
+      parser.on("--legend-line TEXT",
+                 "Adds the line TEXT in the legend") do |l|
+        target.current_object.add_legend_info(LegendLine.new(l))
+      end
+
+
+      parser.on("--legend-dy DIM",
+                 "The distance between two legend lines, ",
+                 "expressed in terms of text line size") do |l|
+        target.current_object.plot_style.legend_style.dy = 
+          TextDimension.new(l)
+      end
+
+      parser.on("--legend-pos SPEC", 
+                 "Sets the legend position and its size.",
+                 "SPEC looks like pos,size[,delta]") do |a|
+        w,s,d = a.split /\s*,\s*/
+        if d
+          warn "The delta specification (#{d}) for #{a} is ignored"
+        end
+        target.debug "Legend position #{w.inspect} #{s.inspect}"
+        target.current_object.layout_preferences.legend_position = w.to_sym
+        target.current_object.layout_preferences.legend_size = Dimension.new(s)
+      end
+
+      parser.on("--legend-inside SPEC", 
+                 "Makes a legend inside the plot.",
+                 "See --inset for the format of SPEC") do |a|
+        specs = legend_position(a)
+        target.debug "Specs: #{specs.inspect}"
+        target.current_object.layout_preferences.legend_position = :inside
+        target.current_object.layout_preferences.legend_spec = specs
+      end
+
+      # Frames around legends:
+      parser.on("--[no-]legend-frame [WHAT]",
+                "Which frame should ctioga draw around legends ?") do |l|
+        if l =~ /square|round/i
+          l = l.downcase.to_sym
+        elsif l =~ /none/i || (!l)
+          l = false
+        else
+          warn "Incorrect legend frame: '#{l}'"
+        end
+        target.current_object.plot_style.legend_style.box_style = l
+      end
+
+      # TODO: make all the legend styles...
+      parser.on("--[no-]legend-background [COLOR]",
+                "Background color for the legend") do |c|
+        c = CTioga.get_tioga_color(c) if c
+        target.current_object.plot_style.legend_style.background_color = c
+      end
+
+      parser.on("--[no-]legend-transparency [VALUE]",
+                "Transparency for the background") do |f|
+        if !f 
+          f = 0.0
+        else
+          f = f.to_f
+        end
+        target.current_object.plot_style.legend_style.
+          background_transparency = f
+      end
+
+      parser.on("--[no-]legend-color [COLOR]",
+                "Color for the line around the legend") do |c|
+        c = CTioga.get_tioga_color(c) if c
+        target.current_object.plot_style.legend_style.line_color = c
+      end
+
+      parser.on("--legend-line-width WIDTH",
+                "Line width for drawing the legend") do |c|
+        c = Float(c)
+        target.current_object.plot_style.legend_style.line_width = c
+      end
+
+      parser.on("--legend-line-style STYLE",
+                "Line style for drawing the legend") do |c|
+        c = MetaBuilder::ParameterType.from_string(:line_style,c)
+        target.current_object.plot_style.legend_style.line_style = c
+      end
+      
+      parser.on("--[no-]separate-legends",
+                "If set, PDF files are produced that contain",
+                "what the legend pictogram would look like") do |l|
+        target.separate_legends = l
+        if l
+          # Switches off autolegends by default
+          target.autolegends = false
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/CTioga/legends/item.rb

@@ -0,0 +1,164 @@
+# legends.rb: legend implementation of CTioga
+# copyright (c) 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'
+require 'CTioga/debug'
+require 'CTioga/curve_style'
+require 'CTioga/dimension'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 839 $', '$Date: 2008-10-11 14:47:08 +0200 (Sat, 11 Oct 2008) $')
+
+  # The base class for all legends items (real legends, spacing, lines).
+  class LegendItem
+
+    include Debug
+    include Log
+
+    # This class-wide variable is used to number text
+    # in a unique fashion
+    @@legend_item_numbering = 0
+
+    def initialize
+      @legend_number = @@legend_item_numbering
+      @@legend_item_numbering += 1
+    end
+
+    # Returns the (width, height) in figure coordinates
+    # of the legend element with the given LegendStyle
+    # and FigureMaker reference objects.
+    #
+    # The returned values can be inaccurate to some extent.
+    def size(t, legend_style)
+      return [0, 0]
+    end
+
+    # Draws the legend at the given top left position (x,y)
+    # in figure coordinates.
+    def draw(t, legend_style, x, y)
+    end
+
+    # For internal use
+    def legend_name
+      return "legend-#{@legend_number}"
+    end
+
+    # We put the baseline so that the space above and below in the
+    # box of height legend_style.dy is even.
+    def get_baseline_y(t, legend_style, y)
+      return y - 0.5 * ( TextDimension.new(1.0).to_figure(t, :y)  +
+                         legend_style.dy.to_figure(t, :y))
+    end
+
+
+  end
+
+  # A class representing the style of a single legend line (unrelated
+  # to a curve)
+  class LegendLine < LegendItem
+
+    # The text of the line
+    attr_accessor :text
+    
+    def initialize(text = "")
+      super()
+      @text = text
+    end
+
+    # Draw one single text line
+    def draw(t, legend_style, x, y)
+      y = get_baseline_y(t, legend_style, y) 
+      t.show_text('x' => x, 'y' => y, 
+                  'text' => @text,
+                  'justification' => LEFT_JUSTIFIED,
+                  'measure' => legend_name
+                  )
+    end
+
+    # Computes the size of the line. Height should always
+    # be accurate, but width can be 0 sometimes...
+    def size(t, legend_style)
+      height = legend_style.dy.to_figure(t, :y)
+      info = t.get_text_size(legend_name)
+      if info.key? 'width'
+        width = t.convert_output_to_figure_dx(10*info['width'])
+      else
+        width = 0
+      end
+
+      return [ width, height ]
+    end
+      
+  end
+
+  # The class handling the drawing of one Curve
+  class CurveLegend < LegendItem
+    
+    attr_accessor :curve_style
+
+    def initialize(style)
+      super()
+      @curve_style = style
+    end
+    
+    # Draw one single text line
+    def draw(t, legend_style, x, y)
+      y = get_baseline_y(t, legend_style, y) 
+      t.context do 
+        # Position specification for the legend pictogram
+        margin_specs = { 'left' => x,
+          'right' => 1 - x - legend_style.picto_width.to_figure(t, :x),
+          'bottom' => y,
+          'top' => 1 - y - legend_style.picto_height.to_figure(t, :y)
+        }
+        debug "Legend margins for '#{@curve_style.legend}' : #{margin_specs.inspect}"
+        t.subfigure(margin_specs) do
+          # We scale the text back to normal so the markers have the right
+          # size
+          # t.line_width = 0.1
+          # t.stroke_rect(0,0,1,1)
+          t.rescale_text(1/legend_style.text_scale)
+          @curve_style.output_legend_pictogram(t)
+        end
+      end
+      t.show_text('x' => x + 
+                  legend_style.picto_width.to_figure(t, :x) + 
+                  legend_style.picto_to_text.to_figure(t, :x), 
+                  'y' => y, 'text' => @curve_style.legend,
+                  'measure' => legend_name,
+                  'justification' => LEFT_JUSTIFIED)
+    end
+
+    # Computes the size of the line. Height should always
+    # be accurate, but width can be 0 sometimes...
+    def size(t, legend_style)
+      height = legend_style.dy.to_figure(t, :y)
+
+      width = legend_style.picto_width.to_figure(t, :x) + 
+        legend_style.picto_to_text.to_figure(t, :x) 
+
+      info = t.get_text_size(legend_name)
+      
+      if info.key? 'width'
+        width += t.convert_output_to_figure_dx(10*info['width'])
+      end
+
+      return [ width, height ]
+    end
+    
+    
+  end
+
+
+end

data/lib/CTioga/legends/style.rb

@@ -0,0 +1,257 @@
+# legends.rb: legend implementation of CTioga
+# copyright (c) 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'
+require 'CTioga/debug'
+require 'CTioga/curve_style'
+require 'CTioga/dimension'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 858 $', '$Date: 2009-01-07 13:39:07 +0100 (Wed, 07 Jan 2009) $')
+
+  # A class that provides style information and display facilities
+  # for legends.
+  #
+  # It does not provide contents for the legends themselves
+  class LegendStyle
+    include Debug
+    include Log
+
+    # The distance between two legend lines
+    attr_accessor :dy
+
+    # The legend scale
+    attr_accessor :scale
+
+    # The padding between the legend and anything else around
+    attr_accessor :padding
+
+    # The width of the pictogram
+    attr_accessor :picto_width
+
+    # The height of the pictogram
+    attr_accessor :picto_height
+
+    # The distance between the pictogram and the text
+    attr_accessor :picto_to_text
+
+    # Scales all the text by that factor:
+    attr_accessor :text_scale
+
+    # Style of the box around the legend : (none/round/box)
+    attr_accessor :box_style
+
+    # The amount of space that should be left around the legend
+    # when drawing the box.
+    attr_accessor :margin
+
+    # The color of the background. false means no background
+    # Only meaningful when the #box_style is set to something
+    # different of none.
+    attr_accessor :background_color
+
+    # The color for the lines
+    attr_accessor :line_color
+
+    # The color for the lines
+    attr_accessor :line_width
+
+    # The color for the lines
+    attr_accessor :line_style
+    
+    # The transparency of the background
+    attr_accessor :background_transparency
+
+    def initialize
+      # All in relative units ;-)...
+      @dy = TextDimension.new(1.9)
+      @padding = TextDimension.new(0.5)
+      @picto_width = TextDimension.new(1.5)
+      @picto_height = TextDimension.new(0.75)
+      @picto_to_text = TextDimension.new(0.5)
+      @scale = 1.0
+
+      @box_style = false        # For no box.
+
+      # Frame styles:
+      @background_color = false
+      @background_transparency = 0.0
+      @line_color = Tioga::FigureConstants::Black
+      @line_width = 1.0
+      @line_style = false
+
+
+      @margin = TextDimension.new(0.4)
+
+    end
+
+
+
+    # Prepares the context in which the legend is made, and run
+    # the corresponding code
+    def legend_context(t, legend_specs,plot_margins)
+      subfigure_margins = {}
+
+      if legend_specs.key?('legend_left_margin')
+        # Now, we enter a subfigure:
+        for pos in %w{left right top bottom}
+          subfigure_margins[pos] = legend_specs["legend_#{pos}_margin"]
+        end
+        debug "Legend margins #{subfigure_margins.inspect}"
+      else                      # We make a subfigure relative to the plot
+        if plot_margins
+          subfigure_margins = plot_margins.dup
+        else
+          plot_margins = false
+        end
+      end
+
+      t.context do
+        t.set_subframe(subfigure_margins) if subfigure_margins
+        t.rescale(@scale)
+        t.rescale_text(@text_scale)
+        yield 
+      end
+
+    end
+
+    # Prepare the frame path
+    def prepare_frame_path(t,xl,yt, total_width, total_height)
+      case @box_style
+      when :square
+        t.append_rect_to_path(xl - @margin.to_figure(t, :x), 
+                              yt + @margin.to_figure(t, :y),
+                              total_width + 2 * @margin.to_figure(t, :x), 
+                              - total_height - 2 * @margin.to_figure(t, :y))   
+      when :round
+        # For some reason, the append_rounded_rect_to_path does not
+        # work so well...
+        dx = @margin.to_figure(t, :x)
+        dy = @margin.to_figure(t, :y)
+        xr = xl + total_width
+        yb = yt - total_height
+        t.move_to_point(xl - dx, yt)
+        t.append_curve_to_path(xl - dx, yt + 0.5 * dy, # First control point
+                               xl - 0.5 * dx, yt + dy, 
+                               xl, yt + dy)
+        t.append_point_to_path(xr, yt + dy)
+        t.append_curve_to_path(xr + 0.5 * dx, yt + dy, # First control point
+                               xr + dx, yt + 0.5 * dy, 
+                               xr + dx, yt)
+        t.append_point_to_path(xr + dx, yb)
+        t.append_curve_to_path(xr + dx, yb - 0.5 * dy, # First control point
+                               xr + 0.5 * dx, yb - dy, 
+                               xr, yb - dy)
+        t.append_point_to_path(xl, yb - dy)
+        t.append_curve_to_path(xl - 0.5 * dx, yb - dy, # First control point
+                               xl - dx, yb - 0.5 * dy, 
+                               xl - dx, yb)
+        t.close_path
+      end
+    end
+
+    # Displays legends _legend_info_ to the FigureMaker object _t_ using
+    # boundaries given by _legend_specs_ for the plot with the
+    # given _plot_margins_
+    def show_legends(t, legend_specs, plot_margins, legend_info)
+      debug "Plotting legends: #{legend_specs.inspect}"
+      @text_scale ||= t.legend_scale
+
+      # First, we collect data on the legend_info
+      widths = []
+      heights = []
+      total_height = 0
+      total_width = 0
+      legend_context(t, legend_specs, plot_margins) do 
+        for item in legend_info
+          w, h = item.size(t, self)
+          widths << w
+          heights << h
+          total_height += h
+          total_width = w if total_width < w
+        end
+      end
+
+      debug "Total height: #{total_height}\tTotal width: #{total_width}"
+
+      # Need to scope them now, so the context down actually modifies them !
+      xl = 0
+      yl = 0
+      if legend_specs.key?('legend_left_margin')
+        legend_context(t, legend_specs, plot_margins) do 
+          yl = 1
+          xl = @padding.to_figure(t, :x)
+        end
+      elsif legend_specs.key?('legend_left') or 
+          legend_specs.key?('legend_right') or 
+          legend_specs.key?('legend_hcenter')
+
+        legend_context(t, legend_specs, plot_margins) do 
+          if legend_specs.key?('legend_left')
+            xl = t.convert_frame_to_figure_x(legend_specs['legend_left'])
+          elsif legend_specs.key?('legend_right')
+            xl = t.convert_frame_to_figure_x(legend_specs['legend_right']) - 
+              total_width
+          else
+            xl = t.convert_frame_to_figure_x(legend_specs['legend_hcenter']) - 
+              total_width * 0.5
+          end
+          
+          if legend_specs.key?('legend_top')
+            yl = t.convert_frame_to_figure_y(legend_specs['legend_top'])
+          elsif legend_specs.key?('legend_bottom')
+            yl = t.convert_frame_to_figure_y(legend_specs['legend_bottom']) + 
+              total_height
+          else
+            yl = t.convert_frame_to_figure_y(legend_specs['legend_vcenter']) + 
+              total_height * 0.5
+          end
+        end
+      else
+        # Silently do nothing:
+        return
+      end
+
+      # Always wrapping within a context call ;-)...
+      legend_context(t, legend_specs, plot_margins) do 
+        # First, we draw the box if necessary 
+        if @box_style
+          t.context do 
+            if @background_color
+              t.fill_color = @background_color
+              t.fill_transparency = @background_transparency
+              prepare_frame_path(t, xl, yl, total_width, total_height)
+              t.fill
+            end
+            if @line_color
+              t.stroke_color = @line_color
+              t.line_width = @line_width
+              t.line_type = @line_style if @line_style
+              prepare_frame_path(t, xl, yl, total_width, total_height)
+              t.stroke
+            end
+          end
+        end
+        
+        for item in legend_info
+          w, h = item.size(t, self)
+          item.draw(t, self, xl, yl)
+          yl -= h
+        end
+      end
+    end
+
+  end
+
+end