ctioga2 0.10.1 → 0.11

data/lib/ctioga2/graphics/styles/plot.rb

@@ -15,6 +15,7 @@ require 'ctioga2/utils'
 require 'ctioga2/log'
 
 require 'ctioga2/graphics/coordinates'
+require 'ctioga2/graphics/elements/element'
 
 # This module contains all the classes used by ctioga
 module CTioga2
@@ -85,40 +86,52 @@ module CTioga2
         attr_accessor :frame_real_size
 
 
+        # The target plot (ie the parent of all the small elements)
+        attr_accessor :target_plot
+
         @@current_index = 0
 
-        def initialize
+        def initialize(plt)
           # Default style for the plots.
+          @target_plot = plt
+
           @axes = {}
-          @axes[:left] = 
-            StyleSheet.style_for(AxisStyle, 'left', :left, 
-                                 AXIS_WITH_TICKS_AND_NUMERIC_LABELS,
-                                 '$y$')
-          @axes[:bottom] = 
-            StyleSheet.style_for(AxisStyle, 'bottom', :bottom, 
-                                 AXIS_WITH_TICKS_AND_NUMERIC_LABELS,
-                                 '$x$')
-
-          @axes[:right] = 
-            StyleSheet.style_for(AxisStyle, 'right', :right, 
-                                 AXIS_WITH_TICKS_ONLY)
-          @axes[:top] = 
-            StyleSheet.style_for(AxisStyle, 'top', :top, 
-                                 AXIS_WITH_TICKS_ONLY)
+          for ax in [:left, :right, :top, :bottom] 
+            
+            cls = [ax.to_s]
+            cls << if (ax == :bottom or ax == :top)
+                     'x'
+                   else
+                     'y'
+                   end
+            dec = if (ax == :bottom or ax == :left)
+                    AXIS_WITH_TICKS_AND_NUMERIC_LABELS
+                  else
+                    AXIS_WITH_TICKS_ONLY
+                  end
+            label = nil
+            if ax == :bottom
+              label = '$x$'
+            elsif ax == :left
+              label = '$y$'
+            end
+            
+            axis = Elements::AxisElement.new
+            axis.setup_style(@target_plot, {'class' => cls})
+            axis.initialize_style(ax, dec, label)
+            @axes[ax] = axis
+          end
 
           @xaxis_location = :bottom
           @yaxis_location = :left
 
-          @title = 
-            StyleSheet.style_for(TextLabel, 'title',
-                                 nil, 
-                                 Types::PlotLocation.new(:top))
+          @title = Elements::TitleElement.new(@target_plot, {})
+
           @plot_margin = nil
 
           @transforms = CoordinateTransforms.new
 
-          @background = 
-            StyleSheet.style_for(BackgroundStyle, 'background')
+          @background = Elements::BackgroundElement.new(@target_plot, {})
 
           # A padding of 6bp ? Why ?? Why not ?
           @padding = Types::Dimension.new(:bp, 6)
@@ -152,12 +165,12 @@ module CTioga2
         def set_log_scale(which, val)
           case which
           when :x
-            @axes[:top].log = val
-            @axes[:bottom].log = val
+            @axes[:top].style.log = val
+            @axes[:bottom].style.log = val
             @transforms.x_log = val
           when :y
-            @axes[:left].log = val
-            @axes[:right].log = val
+            @axes[:left].style.log = val
+            @axes[:right].style.log = val
             @transforms.y_log = val
           else
             raise "Unknown axis: #{which.inspect}"
@@ -186,12 +199,12 @@ module CTioga2
         # \todo Maybe x2 and y2 could be provided to signify "the side
         # which isn't the default" ?
         def get_axis_style(name)
-          style = @axes[get_axis_key(name)]
-          if ! style
+          axis = @axes[get_axis_key(name)]
+          if ! axis
             ## @todo Type-safe exception here
             raise "Unkown named axis: '#{name}'"
           else
-            return style
+            return axis.style
           end
         end
 
@@ -206,9 +219,9 @@ module CTioga2
           end
         end
 
-        def set_axis_style(name, style)
+        def set_axis(name, axis)
           key = get_axis_key(name)
-          @axes[key] = style
+          @axes[key] = axis
         end
 
 
@@ -223,7 +236,7 @@ module CTioga2
         # ticks are implied.
         def get_label_style(location)
           if location =~ /^\s*title\s*$/
-            return @title
+            return @title.style
           end
           location =~ /^\s*(.*?)(?:_(ticks?|label))?\s*$/i
           which = $2
@@ -255,22 +268,22 @@ module CTioga2
           for which, axis in @axes
             t.context do
               begin
-                axis.set_bounds_for_axis(t, bounds[which])
-                axis.draw_axis(t, @text_sizes)
+                axis.style.set_bounds_for_axis(t, bounds[which])
+                axis.style.draw_axis(t, @text_sizes)
               rescue Exception => e
                 error { "Impossible to draw axis #{which}: #{e.message}" }
-                debug { "Full message: #{e.inspect}\n#{e.backtrace.join("\n")}" }
+                info { "Full message: #{e.inspect}\n#{e.backtrace.join("\n")}" }
               end
             end
           end
           # We draw the title last
-          title.draw(t, 'title', "title-#{@text_size_index}")
+          title.style.draw(t, 'title', "title-#{@text_size_index}")
         end
 
         # Draws all axes background lines for the plot.
         def draw_all_background_lines(t)
           for which, axis in @axes
-            axis.draw_background_lines(t)
+            axis.style.draw_background_lines(t)
           end
         end
 
@@ -305,10 +318,10 @@ module CTioga2
         def estimate_margins(t)
           margins = [:left, :right, :top, :bottom].map do |side|
             exts = axes_for_side(side).map do |ax|
-              ax.extension(t,self)
+              ax.style.extension(t, self)
             end
-            if @title.loc.is_side?(side)
-              exts << @title.label_extension(t, 'title', @title.loc) * 
+            if @title.style.loc.is_side?(side)
+              exts << @title.style.label_extension(t, 'title', @title.style.loc) * 
                 (@text_scale || 1)
             end
             Types::Dimension.new(:dy, exts.max || 0)
@@ -374,7 +387,7 @@ module CTioga2
         def axes_for_side(side)
           ret = []
           for k,v in @axes
-            ret << v if v.location.is_side?(side)
+            ret << v if v.style.location.is_side?(side)
           end
           return ret
         end
@@ -548,6 +561,35 @@ EOH
 Sets the color of the background lines for the given axis.
 EOH
 
+      BackgroundGridCommand = 
+        Cmd.new('background-grid', nil, '--background-grid',
+                [
+                 CmdArg.new('color-or-false')
+                ],
+                StrokeStyle.options_hash().without('color')
+                ) do |plotmaker, color, options|
+        for which in [:left, :bottom]
+          axis = AxisStyle.current_axis_style(plotmaker, which)
+          if color
+            style = {'color' => color}
+            style.merge!(options)
+            if axis.background_lines
+              axis.background_lines.set_from_hash(style)
+            else
+              axis.background_lines = StrokeStyle.from_hash(style)
+            end
+          else
+            axis.background_lines = false
+          end
+        end
+      end
+      
+      BackgroundGridCommand.
+        describe("Sets the color of the background lines", 
+                 <<"EOH", AxisGroup)
+Shortcut to set the color for the left and bottom axes
+EOH
+
 
       %w{x y}.each do |axis|
         labelcmd = Cmd.new("#{axis}label", "-#{axis}", 
@@ -651,11 +693,13 @@ EOH
         Cmd.new('new-zaxis', nil, '--new-zaxis',
                 [
                  CmdArg.new('text')
-                ],ZAxisStyle) do |plotmaker, name, options|
-        axis = Styles::MapAxisStyle.new
-        PlotStyle.current_plot_style(plotmaker).
-          set_axis_style(name, axis)
-        axis.set_from_hash(options)
+                ], ZAxisStyle.merge(Elements::TiogaElement::StyleBaseOptions)
+                ) do |plotmaker, name, options|
+        
+        cps = PlotStyle.current_plot_style(plotmaker)
+        axis = Elements::MapAxisElement.new(cps.target_plot, options)
+        cps.set_axis(name, axis)
+        axis.style.set_from_hash(options)
       end
       
       NewZAxisCommand.

data/lib/ctioga2/graphics/styles/sets.rb

@@ -91,6 +91,9 @@ module CTioga2
           MarkerSets[k] = lst
         end
 
+        MarkerSets["alternate"] = MarkerSets["default"].
+          zip(MarkerSets["open"]).flatten(1)
+
         LineWidthSets = {
           'default' => [1.0]
         }

data/lib/ctioga2/graphics/styles/{sheet.rb → styles.rb}

@@ -1,5 +1,5 @@
-# sheet.rb: handling of style sheets
-# copyright (c) 2012 by Vincent Fourmond
+# styles.rb: commands for setting styles
+# copyright (c) 2014 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
@@ -23,181 +23,42 @@ module CTioga2
 
     module Styles
    
-      # This is a style sheet, is a storage place for style
-      # objects. It has two related functions:
-      # * first, store the user-specified preferences
-      # * second, provide the appropriate default style for any given
-      #   object, most probably at construction time (although that
-      #   may get hard some times)
-      #
-      # The style are cascading and scoped. A scope should begin in
-      # each plot.
-      #
-      # Cascades happen in two ways:
-      # 
-      # * more specific styles inherit from less specific (axis ->
-      #   yaxis -> left)
-      # * children style inherit from parent style
-      class StyleSheet
-
-        # The parent of the style sheet, or nil if this is the top one.
-        attr_accessor :parent
-
-        # The styles, in form of a style class -> style name -> style
-        # object nested hash
-        #
-        # The style object is actually a hash ready to be fed to the
-        # BasicStyle#set_from_hash
-        attr_accessor :own_styles
-
-        def initialize(par = nil)
-          @parent = par
-          @own_styles = {}
-        end
-
-        # This hash contains the parent style for each of the style
-        # listed in
-        #
-        # Keyed by class -> style name -> parent name
-        @style_parent = {}
-
-        # Sets the parent for the given style
-        def self.set_parent(cls, style, parent)
-          @style_parent[cls] ||= {}
-          @style_parent[cls][style] = parent
-        end
-        
-        # Returns the parent style for the style (or _nil_ should the
-        # style have no parent)
-        #
-        # All styles (but base) derive from the corresponding "base"
-        # style.
-        def self.get_parent(cls, style)
-          @style_parent[cls] ||= {}
-          stl = @style_parent[cls][style]
-          if (! stl) and (! (style == 'base'))
-            return 'base'
-          end
-          return stl
-        end
-
-        set_parent AxisStyle, "x",  "base"
-        set_parent AxisStyle, "y",  "base"
-
-        set_parent AxisStyle, "bottom", "x"
-        set_parent AxisStyle, "top",    "x"
-        set_parent AxisStyle, "left",   "y"
-        set_parent AxisStyle, "right",  "y"
-
-
-        # This returns the style we have in this object for the given
-        # name. Inner cascading should take place (ie object
-        # hierarchy, but not scope hierarchy).
-        #
-        # This returns a hash that can be modified.
-        def own_style_hash_for(cls, name)
-          p = self.class.get_parent(cls, name)
-          base = {}
-          if p
-            base = own_style_hash_for(cls, p)
-          end
-          @own_styles[cls] ||= {}
-          style = @own_styles[cls][name]
-          if ! style
-            return base
-          end
-          style = style.dup
-          style.merge!(base) { |key, v1, v2| v1 }
-          return style
-        end
-
-        # The style for the given name, including all cascading
-        def get_style_hash_for(cls, name)
-          ps = {}
-          if @parent
-            ps = @parent.get_style_hash_for(cls, name);
-          end
-          style = own_style_hash_for(cls, name)
-          style.merge!(ps) { |key, v1, v2| v1 }
-          return style
-        end
-
-
-
-        # The current sheet
-        @sheet = StyleSheet.new
-        
-        # Returns a suitable style object for the given style name, or
-        # crashes if the name isn't known.
-        #
-        # Additional arguments are passed to the constructor
-        def self.style_for(cls, name, *args)
-          a = cls.new(*args)
-          a.set_from_hash(@sheet.get_style_hash_for(cls, name))
-          return a
-        end
-
-        def self.enter_scope()
-          @sheet = StyleSheet.new(@sheet)
-        end
-
-        def self.leave_scope()
-          if @sheet.parent
-            @sheet = @sheet.parent
-          else
-            warn { "Trying to leave top-level stylesheet scope" }
-          end
-        end
-
-        def self.current_sheet()
-          return @sheet
-        end
-
-
-        # Updates the style sheet concerning the _what_ of class _cls_
-        # with the given values
-        def self.update_style(cls, what, values)
-          StyleSheet.current_sheet.own_styles[cls] ||= {}
-          StyleSheet.current_sheet.own_styles[cls][what] ||= {}
-          StyleSheet.current_sheet.own_styles[cls][what].merge!(values)
-        end
-        
-      end
-
       StyleSheetGroup = CmdGroup.new('style-sheets',
                                      "Default styles", 
                                      <<EOD, 40)
 Commands for defining default styles.
 
-All commands take the name of the style to redefine. Different styles
-live in a different name space, so there is no risk naming an @axis@ and
-a @text@ style with the same name. All styles for a given type inherit from 
-the style name @base@.
+All commands take the selector of the style to be defined. It is a
+CSS-like selector, relying on #id and .class, and using
+#parentality. Therefore, defining a style for @.insets #stuff@ will
+define it for an object named @stuff@, but only if it is contained
+within another one that has a @.insets@ class.
 
 ctioga2 does not support changing a style after its use. It may
 affect only the following objects or all the ones that were created
 from the beginning, depending on the context. For safety, only define
 style before issueing any graphics command.
 
-ctioga2 may support at a later time loading style files, but that is
-not the case for now.
-
 EOD
       # We create the commands programmatically
       kinds = [
                ['axis', AxisStyle, 'axis'],
                ['background', BackgroundStyle, 'plot background'],
+               ['curve', CurveStyle, 'plot background'],
                ['title', TextLabel, 'plot title'],
                ['text', FullTextStyle, 'text'],
                ['marker', MarkerStringStyle, 'marker'],
+               ['legend', LegendStorageStyle, 'legend'],
                ['box', BoxStyle, 'boxes'],
                ['arrow', ArrowStyle, 'arrows'],
                ['image', ImageStyle, 'image'],
-               ['line', StrokeStyle, 'lines']
+               ['line', StrokeStyle, 'lines'],
+               ['oriented-line', OrientedLineStyle, 'oriented lines']
               ]
 
       StyleSheetCommands = {}
       StyleSheetPredefinedNames = {}
+      AllStyleKeys = []
 
       kinds.each do |k|
         name, cls, desc = *k
@@ -209,15 +70,41 @@ EOD
                    CmdArg.new('text'),
                   ], 
                   cls.options_hash
-                  ) do |plotmaker, what, opts|
-          StyleSheet.update_style(cls, what, opts)
+                  ) do |plotmaker, xpath, opts|
+          StyleSheet.style_sheet.update_style(xpath, opts, name)
         end
         StyleSheetCommands[name].
           describe("Sets the default style for the given #{desc}.", 
                    <<"EOH", StyleSheetGroup)
 Sets the default style for the named #{desc}.
 EOH
+        AllStyleKeys.concat(cls.options_hash.keys)
       end
+
+      AllStyleKeys.uniq!
+      AllStyleKeys.sort!
+
+      AllStyleOptions = {}
+      for k in AllStyleKeys
+        AllStyleOptions[k] = CmdArg.new('text')
+      end
+
+      GenericStyleCommand = 
+          Cmd.new("define-style",nil,
+                  "--define-style", 
+                  [
+                   CmdArg.new('text'),
+                  ], 
+                  AllStyleOptions
+                 ) do |plotmaker, xpath, opts|
+        StyleSheet.style_sheet.update_style(xpath, opts)
+      end
+      GenericStyleCommand.
+          describe("Defines style for the given xpath", 
+                   <<"EOH", StyleSheetGroup)
+...
+EOH
+
       
       StyleSheetCommands['line'].long_description = <<EOD
 Sets the default style for lines. All line styles descend from the
@@ -230,15 +117,19 @@ Meaning of the style parameters:
  * @style@: the line style, see {type: line-style}
  * @width@: the line width (in points)
 
-> --define-line-style base /color=Pink
+> --define-line-style * /color=Pink
 
 makes all lines  pink (unless overriden by the /color option to
 {command: draw-line}), while
 
-> --define-line-style line-pink /color=Pink
+> --define-line-style .pink /color=Pink
 
-only affect those to which the /base-style=line-pink style option
+only affect those to which the /class=pink style option
 was given.
+EOD
+
+      StyleSheetCommands['legend'].long_description = <<EOD
+Sets the style for legends.
 EOD
 
       StyleSheetCommands['arrow'].long_description = <<EOD
@@ -352,10 +243,29 @@ EOD
 
       # Here, a few defaults styles
       
-      StyleSheet.update_style(TextLabel, 'title', {
-                                'text_width' => 
-                                Types::Dimension.new(:frame, 1.0, :x)
-                              })
+      StyleSheet.style_sheet.
+        update_style('title', {
+                       'text_width' => 
+                       Types::Dimension.new(:frame, 1.0, :x)
+                     })
+
+      LoadStyleCommand = 
+        Cmd.new("load-style", nil,
+                  "--load-style", 
+                  [
+                   CmdArg.new('file'),
+                  ], {}
+                  ) do |plotmaker, file|
+        File.open(file) do |f|
+          str = f.read
+          StyleSheet.style_sheet.update_from_string(str)
+        end
+      end
+      LoadStyleCommand.
+        describe("Load a style file", 
+                 <<"EOH", StyleSheetGroup)
+...
+EOH
     end
   end
 end