ctioga2 0.0

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

@@ -0,0 +1,351 @@
+# factory.rb: an object in charge of generating the style for Curves
+# copyright (c) 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'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 59 $', '$Date: 2009-05-28 23:15:50 +0200 (Thu, 28 May 2009) $')
+
+  module Graphics
+
+    module Styles
+
+      # This object is in charge of the generation of the CurveStyle
+      # object for the next curve to be drawn.
+      class CurveStyleFactory
+
+        include Log
+
+        # A private class that defines a parameter for the Factory
+        class CurveStyleFactoryParameter
+
+          # The code-like name of the parameter
+          attr_accessor :name
+
+          # The Commands::CommandType of the parameter
+          attr_accessor :type
+          
+          # The pre-defined sets available to use with that
+          # parameter. It is a hash. 
+          attr_accessor :sets
+
+          # The description of the parameter.
+          attr_accessor :description
+          
+          # The short option for setting the parameter directly from
+          # the command-line.
+          attr_accessor :short_option
+
+          # The MetaBuilder::Type object that can convert a String to
+          # an Array suitable for use with CircularArray.
+          attr_accessor :sets_type
+          
+
+          # Creates a new CurveStyleFactoryParameter object.
+          def initialize(name, type, sets, description, 
+                         short_option = nil)
+            @name = name
+            @type = Commands::CommandType.get_type(type)
+            @sets = sets
+            @description = description
+            @short_option = short_option
+
+            # TODO: it is not very satisfying to mix CommandTypes and
+            # MetaBuilder::Type on the same level.
+            if @sets
+              @sets_type = 
+                MetaBuilder::Type.get_type({
+                                             :type => :set,
+                                             :subtype => @type.type,
+                                             :shortcuts => @sets
+                                           })
+            end
+          end
+
+          # Returns a suitable default set for the given object.
+          def default_set
+            return nil unless @sets
+            if @sets.key? 'default'
+              return @sets['default']
+            else
+              @sets.each do |k,v|
+                return v
+              end
+            end
+          end
+
+        end
+
+        # Switch some parameter back to automatic
+        AutoRE = /auto/i
+
+        # Sets some parameter to _false_.
+        DisableRE = /no(ne)?|off/i
+
+
+
+        # Creates a new parameter for the style factory.
+        def self.define_parameter(target, name, type, sets, description, 
+                                  short_option = nil)
+          # We define two new types:
+          # - first, the color-or-auto type:
+          base_type = Commands::CommandType.get_type(type)
+
+          if ! Commands::Interpreter.type("#{base_type.name}-or-auto")
+            mb_type = base_type.type.dup
+            mb_type.re_shortcuts = (mb_type.re_shortcuts ? 
+                                        mb_type.re_shortcuts.dup : {}) 
+            
+            mb_type.re_shortcuts[AutoRE] = 'auto'
+            mb_type.re_shortcuts[DisableRE] = false
+
+            # Now, register a type for the type or automatic.
+            CmdType.new("#{base_type.name}-or-auto", mb_type,
+                        "Same thing as type #{base_type.name}, or 'auto'")
+
+          end
+
+          if sets and ! Commands::Interpreter.type("#{base_type.name}-set")
+            # Now, register a type for the type or automatic.
+            CmdType.new("#{base_type.name}-set",{
+                          :type => :set,
+                          :subtype => base_type.type,
+                          :shortcuts => sets
+                        } ,
+                        "Sets of #{base_type.name}")
+          end
+          param = 
+            CurveStyleFactoryParameter.new(name, type, sets, 
+                                           description, short_option)
+          @parameters ||= {}
+          @parameters[target] = param
+
+          @name_to_target ||= {}
+          @name_to_target[name] = target
+        end
+
+        # Returns the Hash containing the class parameters.
+        def self.parameters
+          return @parameters || {}
+        end
+
+
+        # Returns the Hash containing the class parameters.
+        def self.name_to_target
+          return @name_to_target
+        end
+
+        # The CmdGroup for stylistic information about
+        # curves.
+        CurveStyleGroup = 
+          CmdGroup.new('curve-style', "Curve styles", 
+                       "Set stylistic details about curves", 1)
+
+
+        # Creates two commands for each parameter of the object:
+        # * a command to set the override
+        # * a command to choose the sets.
+        def self.create_commands
+          parameters.each do |target, param|
+            override_cmd = 
+              Cmd.new("#{param.name}",
+                      param.short_option,
+                      "--#{param.name}", 
+                      [
+                       CmdArg.new("#{param.type.name}-or-auto") 
+                      ], {},
+                      "Sets the #{param.description} for subsequent curves",
+                      "Sets the #{param.description} for subsequent curves, until cancelled with 'auto' as argument.", CurveStyleGroup) do |plotmaker, value|
+              plotmaker.curve_generator.style_factory.
+                set_parameter_override(target, value)
+            end
+
+            if param.sets
+              set_cmd = 
+                Cmd.new("#{param.name}-set",
+                        nil,
+                        "--#{param.name}-set", 
+                        [
+                         CmdArg.new("#{param.type.name}-set")
+                        ], {},
+                        "Chooses a set for the #{param.description} of subsequent curves",
+                        "Chooses a set for the #{param.description} of subsequent curves", 
+                        CurveStyleGroup) do |plotmaker, value|
+                plotmaker.curve_generator.style_factory.
+                  set_parameter_set(target, value)
+              end
+            end
+          end
+        end
+
+        # This function returns a hash suitable for use with the plot
+        # command as optional arguments, that will end up as the
+        # _one_time_ hash in #next.
+        def self.plot_optional_arguments
+          args = {}
+          for option_name, param in @parameters
+            args[param.name] = 
+              CmdArg.new(param.type)
+          end
+
+          # Here, we add the support for a /legend= option
+          args['legend'] = CmdArg.new('text')
+          @name_to_target['legend'] = 'legend'
+
+          return args
+        end
+
+
+        # A hash containing values that override default ones derived
+        # from the CircularArray objects.
+        attr_accessor :override_parameters
+
+        # A hash of CircularArray objects.
+        attr_accessor :parameter_carrays
+
+
+        # Creates a new CurveStyleFactory.
+        def initialize
+          # Overrides as in the first ctioga
+          @override_parameters = {
+            'line_style' => LineStyles::Solid,
+            'marker_marker' => false,
+            'marker_scale' => 0.5 
+          }
+          @parameters_carrays = {}
+          for target, param in self.class.parameters
+            set = param.default_set
+            if set
+              @parameters_carrays[target] = CircularArray.new(set)
+            end
+          end
+        end
+
+        # Gets the style for the next curve. The _one_time_ hash
+        # contains values 'parameter name' (name, and not target) =>
+        # value that are used for this time only.
+        def next(one_time = {})
+          base = {}
+          for target, array in @parameters_carrays
+            base[target] = array.next
+          end
+          base.merge!(@override_parameters)
+          base.merge!(hash_name_to_target(one_time))
+          # TODO: here, resolve 'links', such as :->color ?
+          return CurveStyle.from_hash(base)
+        end
+
+
+
+        # Sets the override for the given parameter. This corresponds
+        # to fixing manually the corresponding element until the
+        # override is removed, by a call with a _value_ that matches
+        # AutoRE.
+        #
+        # The _value_ should ideally be a String that is further
+        # converted to the appropriate type. Non-string objects will
+        # be left untouched.
+        def set_parameter_override(target, value)
+          param = get_parameter(target)
+          # Perform automatic type conversion only on strings.
+          if value.is_a? String 
+            if value =~ AutoRE
+              @override_parameters.delete(target)
+              return
+            end
+            if value =~ DisableRE
+              value = false
+            else
+              value = param.type.string_to_type(value)
+            end
+          end
+
+          @override_parameters[target] = value
+        end
+
+        # Sets the CircularArray set corresponding to the named
+        def set_parameter_set(target, value)
+          param = get_parameter(target)
+          # Perform automatic type conversion only on strings.
+          if value.is_a? String 
+            value = param.sets_type.string_to_type(value)
+          end
+          @parameters_carrays[target].set = value
+        end
+
+        # Now, the parameters:
+        define_parameter 'line_color', 'color', 'color',
+        Sets::ColorSets, "color", "-c"
+
+        define_parameter 'line_width', 'line-width', 'float',
+        Sets::LineWidthSets, "line width", nil
+
+        define_parameter 'line_style', 'line-style', 'line-style',
+        Sets::LineStyleSets, "line style", nil
+
+        define_parameter 'marker_marker', 'marker', 'marker',
+        Sets::MarkerSets, "marker", '-m'
+
+        define_parameter 'marker_color', 'marker-color', 'color',
+        Sets::ColorSets, "marker color", nil
+
+        define_parameter 'marker_scale', 'marker-scale', 'float',
+        Sets::LineWidthSets, "marker scale", nil
+
+
+        # And finally, we register all necessary commands...
+        create_commands
+
+        # A constant suitable for use as the optional arguments of the
+        # plot command.
+        PlotCommandOptions = plot_optional_arguments
+
+        protected
+
+        # Returns the CurveFactoryParameterType object corresponding
+        # to the named parameter.
+        def get_parameter(target)
+          if ! parameters.key? target
+            raise "Unkown parameter: #{target}"
+          else
+            return parameters[target]
+          end
+        end
+
+        # Returns the class parameters hash
+        def parameters
+          return self.class.parameters
+        end
+
+        # Converts the one-time parameters, which is a hash whose keys
+        # are the names of the parameters to targets.
+        def hash_name_to_target(h)
+          retval = {}
+          convert = self.class.name_to_target
+          for k,v in h
+            if convert.key? k 
+              retval[convert[k]] = v
+            else
+              warn "Unkown key for hash_name_to_target: #{k}"
+            end
+          end
+          return retval
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,63 @@
+# legend.rb: style of legends
+# copyright (c) 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'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+
+  module Graphics
+
+    module Styles
+
+      # Style of a given Legends::LegendStorage object.
+      class LegendStorageStyle < BasicStyle
+
+        # The distance between two lines, a Types::Dimension object.
+        attr_accessor :dy
+
+        # The width of the legend pictogram, a Types::Dimension object.
+        attr_accessor :picto_width
+
+        # The height of the legend pictogram, a Types::Dimension object.
+        attr_accessor :picto_height
+
+        # The distance between the legend pictogram and the text
+        attr_accessor :picto_to_text
+
+        # The scale of the legend
+        attr_accessor :scale
+
+        # The scale of the legend text -- relative to the overall
+        # scale.
+        attr_accessor :text_scale
+
+        def initialize
+          @dy = Types::Dimension.new(:dy, 1.6, :y)
+
+          @picto_width = Types::Dimension.new(:dy, 1.6, :x)
+          @picto_height = Types::Dimension.new(:dy, 0.6, :y)
+
+          @picto_to_text = Types::Dimension.new(:dy, 0.3, :x)
+
+          @scale = 0.8
+          @text_scale = 0.82
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,410 @@
+# plot.rb: the style of a plot object.
+# copyright (c) 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'
+
+require 'ctioga2/graphics/coordinates'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 94 $', '$Date: 2009-06-25 23:37:13 +0200 (Thu, 25 Jun 2009) $')
+
+  module Graphics
+
+    module Styles
+
+      # The style of a Elements::Subplot object.
+      #
+      # TODO: it should hold
+      # * labels
+      # * axes and edges (in a *clean* way !)
+      # * ticks
+      # * background (uniform fill + watermark if applicable + possibly
+      #   a picture .?)
+      class PlotStyle
+
+        include Tioga::FigureConstants
+
+        # The various sides of the plot. A hash location -> AxisStyle.
+        attr_accessor :axes
+
+        # The default location of the X axis (well, mainly, the X label)
+        attr_accessor :xaxis_location
+
+        # The default location of the Y axis (well, mainly, the Y label)
+        attr_accessor :yaxis_location
+
+        # The title of the plot
+        attr_accessor :title
+
+        # A margin to be left around the data points
+        attr_accessor :plot_margin
+
+        # Coordinate tranforms
+        attr_accessor :transforms
+
+        # Style of the background of the plot
+        attr_accessor :background
+
+        # Scale of the lines of the plot. The plot is wrapped in a
+        # t.rescale_lines call.
+        attr_accessor :lines_scale
+
+        # Scale of the text of the plot. The plot is wrapped in a
+        # t.rescale_text call.
+        attr_accessor :text_scale
+
+        # A padding around the box when automatic spacing is in auto
+        # mode. A Dimension.
+        attr_accessor :padding
+
+        def initialize
+          # Default style for the plots.
+          @axes = {}
+          @axes[:left] = AxisStyle.new(:left, 
+                                       AXIS_WITH_TICKS_AND_NUMERIC_LABELS,
+                                       '$y$')
+          @axes[:bottom] = AxisStyle.new(:bottom, 
+                                         AXIS_WITH_TICKS_AND_NUMERIC_LABELS,
+                                         '$x$')
+
+          @axes[:right] = AxisStyle.new(:right, AXIS_WITH_TICKS_ONLY)
+          @axes[:top] = AxisStyle.new(:top, AXIS_WITH_TICKS_ONLY)
+
+          @xaxis_location = :bottom
+          @yaxis_location = :left
+
+          @title = TextLabel.new
+          @title.loc = :top
+
+          @plot_margin = nil
+
+          @transforms = CoordinateTransforms.new
+
+          @background = BackgroundStyle.new
+
+          # A padding of 4bp ? Why ?? Why not ?
+          @padding = Types::Dimension.new(:bp, 4)
+        end
+
+        # Whether to use log scale for the given axis.
+        #
+        # Now the question is: how should that affect user-defined
+        # axes ? It should not.
+        def set_log_scale(which, val)
+          case which
+          when :x
+            @axes[:top].log = val
+            @axes[:bottom].log = val
+            @transforms.x_log = val
+          when :y
+            @axes[:left].log = val
+            @axes[:right].log = val
+            @transforms.y_log = val
+          else
+            raise "Unknown axis: #{which.inspect}"
+          end
+        end
+
+        # Returns the AxisStyle corresponding to the named
+        # axis. _name_ can be:
+        # * one of the named elements of axes (ie, by default: top,
+        #   left, right, bottom). All names are stripped from spaces
+        #   around, and downcased (see #clean_axis_name).
+        # * x(axis)?/y(axis)?, which returns the default object for the
+        #   given location
+        def get_axis_style(name)
+          if name =~ /^\s*([xy])(?:axis)?\s*$/i
+            return @axes[self.send("#{$1.downcase}axis_location")]
+          else
+            style = @axes[clean_axis_name(name)]
+            if ! style
+              raise "Unkown named axis: '#{name}'"
+            else
+              return style
+            end
+          end 
+        end
+
+        # Returns a BaseTextStyle or similar for the given
+        # location. The location is of the form:
+        #   axis_name(_(ticks?|label))
+        # or
+        #   title
+        #
+        # If neither label nor ticks is specified in the first form,
+        # ticks are implied.
+        def get_label_style(location)
+          if location =~ /^\s*title\s*$/
+            return @title
+          end
+          location =~ /^\s*(.*?)(?:_(ticks?|label))?\s*$/i
+          which = $2
+          axis = get_axis_style($1)
+          if which =~ /label/
+            return axis.axis_label
+          else
+            return axis.tick_label_style
+          end
+        end
+
+        # Sets the style of the given label. Sets the text as well, if
+        # _text_ is not _nil_
+        def set_label_style(which, hash, text = nil)
+          style = get_label_style(which)
+          hash = hash.merge({'text' => text}) unless text.nil?
+          if hash.key?('text') and ! style.is_a?(TextLabel)
+            CTioga2::Log::warn("Text property of label #{which} was set, but this has no meaning: tick labels can't be set this way. Did you mean to use \"#{which}_label\"" + " instead ?")
+          end
+          style.set_from_hash(hash)
+        end
+
+
+        # Draws all axes for the plot.
+        def draw_all_axes(t)
+          for which, axis in @axes
+            axis.draw_axis(t)
+          end
+          # We draw the title last
+          title.draw(t, 'title')
+        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)
+          end
+        end
+
+        # Sets up the FigureMaker object for the plot. To be called
+        # just after the outermost context call for the concerned
+        # plot.
+        def setup_figure_maker(t)
+          if @lines_scale
+            t.rescale_lines(@lines_scale)
+          end
+          if @text_scale
+            t.rescale_text(@text_scale)
+          end
+        end
+
+
+        # Returns a deep copy of _self_, with all references stripped.
+        def deep_copy
+          return Marshal.load(Marshal.dump(self))
+        end
+
+        # Returns the PlotStyle object of the current plot
+        def self.current_plot_style(plotmaker)
+          return plotmaker.root_object.current_plot.style
+        end
+
+        # Estimate the margins of the plot whose style this object
+        # controls. These margins are used when the plot margins are
+        # in automatic mode.
+        #
+        # Returns a Types::MarginsBox
+        def estimate_margins(t)
+          margins = [:left, :right, :top, :bottom].map do |side|
+            ext = @axes[side].extension(t,self)
+            if side == @title.loc
+              ext2 = @title.label_extension(t, 'title', side) * 
+                (@text_scale || 1)
+              if ext < ext2
+                ext = ext2
+              end
+            end
+            Types::Dimension.new(:dy, ext)
+          end
+
+          # TODO: add the plot title !
+          box = Types::MarginsBox.new(*margins)
+          if @padding
+            for dim in box.margins
+              dim.replace_if_bigger(t, @padding)
+            end
+          end
+          return box
+        end
+
+        protected
+
+        # Takes a string and returns a Symbol suitable for use with
+        # the #axes hash (lower case without spaces).
+        def clean_axis_name(name)
+          if name.is_a?(::Symbol) # Argh ! Tioga redefined Symbol !
+            return name
+          end
+          name =~ /^\s*(.*?)\s*$/
+          return $1.downcase.to_sym
+        end
+
+      end
+
+      AxisGroup = CmdGroup.new('axes-labels',
+                               "Axes and labels", "Axes and labels", 40)
+
+
+      
+      AxisTypeCommands = []
+      [:left, :right, :top, :bottom].each do |loc|
+        AxisTypeCommands << 
+          Cmd.new("#{loc}",nil,"--#{loc}", 
+                  [
+                   CmdArg.new('axis-decoration'),
+                  ], PartialAxisStyle) do |plotmaker, dec, opts|
+          style = AxisStyle.current_axis_style(plotmaker, loc)
+          style.decoration = dec
+
+          style.set_from_hash(opts)
+        end
+        AxisTypeCommands.last.
+          describe("Sets the type of the #{loc} axis", 
+                   <<"EOH", AxisGroup)
+Sets the type of the #{loc} axis.
+EOH
+      end
+
+      AxisStyleCommand = 
+          Cmd.new("axis-style",nil,"--axis-style", 
+                  [
+                   CmdArg.new('axis'),
+                  ], FullAxisStyle) do |plotmaker, which, opts|
+        style = AxisStyle.current_axis_style(plotmaker, which)
+        style.set_from_hash(opts)
+      end
+      AxisStyleCommand.
+        describe("Sets the style of the given axis", 
+                 <<"EOH", AxisGroup)
+This command can be used to set various aspects of the style of the 
+given axis, through its various options:
+ * decoration
+EOH
+
+      BackgroundLinesCommands = 
+        Cmd.new('background-lines', nil, '--background-lines',
+                [
+                 CmdArg.new('axis'), 
+                 CmdArg.new('color-or-false')
+                ],{
+                  'style' => CmdArg.new('line-style'),
+                  'width' => CmdArg.new('float')
+                }) do |plotmaker, which, color, options|
+        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
+      
+      BackgroundLinesCommands.
+        describe("Sets the color of the background lines", 
+                 <<"EOH", AxisGroup)
+Sets the color of the background lines for the given axis.
+EOH
+
+
+      XAxisLabelCommand = 
+        Cmd.new('xlabel', '-x', '--xlabel', [ CmdArg.new('text') ],
+                FullTextStyleOptions) do |plotmaker, label, options|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style('x_label', options, label)
+      end
+
+      XAxisLabelCommand.describe("Sets the X label of the plot", 
+                                 <<"EOH", AxisGroup)
+Sets the X label of the current plot.
+EOH
+
+      NoXAxisLabelCommand = 
+        Cmd.new('no-xlabel', nil, '--no-xlabel', []) do |plotmaker|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style('x_label', {}, false)
+      end
+
+      NoXAxisLabelCommand.describe("Disables X label for the plot", 
+                                   <<"EOH", AxisGroup)
+Disables the X label for the current plot.
+EOH
+
+
+      YAxisLabelCommand = 
+        Cmd.new('ylabel', '-y', '--ylabel', [ CmdArg.new('text') ],
+                FullTextStyleOptions) do |plotmaker, label, options|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style('y_label', options, label)
+      end
+
+      YAxisLabelCommand.describe("Sets the Y label of the plot", 
+                                 <<"EOH", AxisGroup)
+Sets the Y label of the current plot.
+EOH
+
+      NoYAxisLabelCommand = 
+        Cmd.new('no-ylabel', nil, '--no-ylabel', []) do |plotmaker|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style('y_label', {}, false)
+      end
+
+      NoYAxisLabelCommand.describe("Disables Y label for the plot", 
+                                   <<"EOH", AxisGroup)
+Disables the Y label for the current plot.
+EOH
+
+      TitleLabelCommand = 
+        Cmd.new('title', '-t', '--title', [ CmdArg.new('text') ],
+                FullTextStyleOptions) do |plotmaker, label, options|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style('title', options, label)
+      end
+
+      TitleLabelCommand.describe("Sets the title of the plot", 
+                                 <<"EOH", AxisGroup)
+Sets the title of the current plot.
+EOH
+
+      LabelStyleCommand = 
+        Cmd.new('label-style', nil, '--label-style',
+                [ CmdArg.new('label') ], # Here: change the label too... 
+                FullTextLabelOptions) do |plotmaker, which, options|
+        PlotStyle.current_plot_style(plotmaker).
+          set_label_style(which, options)
+      end
+      
+      LabelStyleCommand.describe("Sets the style of the given label", 
+                                 <<"EOH", AxisGroup)
+Sets the style of the given label (see the type {type: label} for more
+information).
+
+The option text permits to also set the text of the label (does not
+work for ticks). 
+
+For tick labels, setting the color option also sets the color for the
+lines of the corresponding axis. If you don't want that, you can 
+override the color using the /stroke_color option of 
+{command: axis-style}. This will only work with Tioga version 1.11 or 
+greater.
+EOH
+
+    end
+  end
+end