ctioga2 0.0

data/lib/ctioga2/graphics/types/dimensions.rb

@@ -0,0 +1,157 @@
+# dimensions.rb: various ways to represent a dimension in Tioga
+# 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'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 92 $', '$Date: 2009-06-24 01:17:46 +0200 (Wed, 24 Jun 2009) $')
+
+  module Graphics
+
+    module Types
+
+      # A Dimension is an object that represents a dimension in the
+      # different ways understood by Tioga:
+      # * an "absolute" dimension, ie, in real units (postscript points)
+      # * a "text" dimension, in units of the height of the current
+      #   text object
+      # * a frame/page/figure dimension, in units of the *current*
+      #   frame/page/figure coordinates
+      class Dimension
+
+        include Tioga::Utils
+
+        # What is the underlying representation of the dimension ?
+        # * :bp in postscript points
+        # * :dy in text height units
+        # * :frame in frame coordinates
+        # * :page in page coordinates
+        # * :figure in figure coordinates
+        attr_accessor :type
+
+        # The orientation of the dimension: vertical (:y) or
+        # horizontal (:x) ?
+        attr_accessor :orientation
+
+        # The actual dimension. The interpretation depends on the
+        # value of #type.
+        attr_accessor :value
+
+        # Creates a Dimension object of the given _type_, the given
+        # _value_ oriented along the given _orientation_
+        def initialize(type, value, orientation = :x)
+          @type = type
+          @value = value
+          @orientation = orientation
+        end
+
+        # Converts the Dimension to the *figure* coordinates of the
+        # *current* figure in _t_.
+        def to_figure(t, orientation = nil)
+          orientation ||= @orientation
+          case @type
+          when :bp
+            return t.send("convert_output_to_figure_d#{orientation}", @value) * 10
+          when :dy
+            return t.send("default_text_height_d#{orientation}") * @value
+          when :frame
+            return t.send("convert_frame_to_figure_d#{orientation}", @value)
+          when :page
+            return t.send("convert_page_to_figure_d#{orientation}", @value)
+          when :figure
+            return @value
+          else
+            raise "Invalid type for Dimension: #{@type}"
+          end
+        end
+
+        # Converts the Dimension to the *frame* coordinates of the
+        # *current* frame in _t_.
+        def to_frame(t, orientation = nil)
+          orientation ||= @orientation
+          return t.send("convert_figure_to_frame_d#{orientation}", 
+                        to_figure(t, orientation))
+        end
+
+        # Replace this Dimension by _dimension_ if the latter is
+        # bigger. Conserves the current orientation.
+        def replace_if_bigger(t, dimension)
+          if self.to_figure(t) < dimension.to_figure(t, @orientation)
+            @type = dimension.type
+            @value = dimension.value
+          end
+        end
+
+        # Dimension conversion constants taken straight from the
+        # TeXbook
+        DimensionConversion = {
+          "pt" => (72.0/72.27),
+          "bp" => 1.0,
+          "in" => 72.0,
+          "cm" => (72.0/2.54),
+          "mm" => (72.0/25.4),
+        }
+        
+        # A regular expression that matches all dimensions.
+        DimensionRegexp = /^\s*([+-]?\s*[\d.eE+-]+)\s*([a-zA-Z]+)?\s*$/
+
+
+        # Creates a Dimension object from a _text_ specification. The
+        # text should be in the forms
+        # 
+        #  value unit
+        #  
+        # where unit is one of bp, pt, in, mm, cm, dy (the latter
+        # being one unit of height) f|figure, F|Frame|frame,
+        # p|page. It can be ommitted, in which case it defaults to the
+        # _default_ parameter.
+        def self.from_text(text, orientation, default = :figure)
+          # Absolute or :dy dimension
+          if text =~ DimensionRegexp
+            value = Float($1)
+            unit = $2
+            if ! unit
+              unit = default
+            elsif DimensionConversion.key?(unit.downcase)
+              value *= DimensionConversion[unit.downcase]
+              unit = :bp
+            else
+              case unit
+              when /^dy$/i
+                unit = :dy
+              when /^F|(?i:frame)$/
+                unit = :frame
+              when /^f|(?i:figure)$/
+                unit = :figure
+              when /^p|(?i:page)$/
+                unit = :page
+              else
+                raise "Unkown dimension unit: #{unit}"
+              end
+            end
+            return Dimension.new(unit, value, orientation)
+          else
+            raise "Unkown Dimension specification: '#{text}'"
+          end
+        end
+        
+      end
+
+    end
+    
+  end
+
+end
+

data/lib/ctioga2/graphics/types/point.rb

@@ -0,0 +1,247 @@
+# point.rb: various ways to represent a position in Tioga
+# 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'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 53 $', '$Date: 2009-05-20 01:05:32 +0200 (Wed, 20 May 2009) $')
+
+  module Graphics
+
+    module Types
+
+      # This class performs the same function as Dimension, except
+      # that it represents a *coordinate*. As such, its #value only
+      # makes sense as a page, frame or figure coordinate
+      class BaseCoordinate < Dimension
+        
+        # Creates a BaseCoordinate object of the given _type_, the
+        # given _value_ and oriented along the given _orientation_
+        def initialize(type, value, orientation)
+          super
+        end
+
+        # Converts the Dimension to the *figure* coordinates of the
+        # *current* figure in _t_.
+        def to_figure(t, orientation = nil)
+          orientation ||= @orientation
+          case @type
+          when :frame
+            return t.send("convert_frame_to_figure_#{orientation}", @value)
+          when :page
+            return t.send("convert_page_to_figure_#{orientation}", @value)
+          when :figure
+            return @value
+          else
+            raise "Invalid type for BaseCoordinate: #{@type}"
+          end
+        end
+
+        # Converts the Dimension to the *frame* coordinates of the
+        # *current* frame in _t_.
+        def to_frame(t, orientation = nil)
+          orientation ||= @orientation
+          return t.send("convert_figure_to_frame_#{orientation}",  
+                        to_figure(t, orientation))
+        end
+
+        # Creates a BaseCoordinate object from a text
+        # specification. Takes the same argument as
+        # Dimension.from_text, except that purely dimension #type
+        # won't be accepted.
+        def self.from_text(text, orientation, default = :figure)
+          dim = Dimension.from_text(text, orientation, default)
+          if dim.type == :bp or dim.type == :dy
+            raise "Does not accept dimensions only for coordinates"
+          end
+          return BaseCoordinate.new(dim.type, dim.value, dim.orientation)
+        end
+        
+      end
+
+
+      # Represents a given Point for Tioga. Its coordinates are
+      # BaseCoordinate objects.
+      class Point
+
+        # The X coordinate, a BaseCoordinate object
+        attr_accessor :x
+        
+        # The Y coordinate, a BaseCoordinate object
+        attr_accessor :y
+        
+        # Creates a Point with the given coordinates (of type _type_,
+        # see BaseCoordinate for more information).
+        def initialize(x = nil, y = nil, type = :figure)
+          if x && y
+            @x = BaseCoordinate.new(type, x, :x)
+            @y = BaseCoordinate.new(type, y, :y)
+          end
+        end
+
+        # Converts the point to figure coordinates.
+        def to_figure_xy(t)
+          return [@x.to_figure(t), @y.to_figure(t)]
+        end
+
+        # Converts the points to frame coordinates.
+        def to_frame_xy(t)
+          return [@x.to_frame(t), @y.to_frame(t)]
+        end
+
+        # Creates a Point object from a text specification. Splits up
+        # the text at a comma and 
+        def self.from_text(text, default = :figure)
+          vals = text.split(/\s*,\s*/)
+          if vals.size != 2
+            raise "Should really have two values: #{text}"
+          end
+          coord = Point.new
+          coord.x = BaseCoordinate.from_text(vals[0], :x, default)
+          coord.y = BaseCoordinate.from_text(vals[1], :y, default)
+          return coord
+        end
+      end
+
+      # A Point, but with alignment facilities.
+      class AlignedPoint < Point
+        # Vertical alignement (:top, :center, :bottom)
+        attr_accessor :valign
+
+        # Horizontal alignment (:left, :center, :right)
+        attr_accessor :halign
+
+        # Creates a AlignedPoint
+        def initialize(x = nil, y = nil, type = :figure, 
+                       halign = :center, valign = :center)
+          super(x,y,type)
+          @halign = halign
+          @valign = valign
+        end
+
+        # Returns frame coordinates corresponding to the point, the
+        # alignment and the given size in figure coordinates
+        def to_frame_coordinates(t, width, height)
+          dx = t.convert_figure_to_frame_dx(width).abs
+          dy = t.convert_figure_to_frame_dy(height).abs
+          x,y = self.to_frame_xy(t)
+
+          case @valign
+          when :top
+            yt = y
+            yb = y - dy
+          when :bottom
+            yt = y + dy
+            yb = y
+          when :center
+            yt = y + dy/2
+            yb = y - dy/2
+          else 
+            raise "Unknown vertical alignment: #{@valign}"
+          end
+
+          case @halign
+          when :right
+            xl = x - dx
+            xr = x
+          when :left
+            xl = x
+            xr = x + dx
+          when :center
+            xl = x - dx/2
+            xr = x + dx/2
+          else 
+            raise "Unknown horizontal alignment: #{@halign}"
+          end
+          return [xl, yt, xr, yb]
+        end
+
+        # Returns a frame_margin corresponding to the point, the
+        # alignment and the given size in figure coordinates.
+        #
+        # See #to_frame_coordinates
+        def to_frame_margins(t, width, height)
+          xl, yt, xr, yb = to_frame_coordinates(t, width, height)
+          return [xl,1 - xr, 1 - yt, yb]
+        end
+
+        AlignmentSpecification = {
+          'r' => :right,
+          'c' => :center,
+          'l' => :left,
+          't' => :top,
+          'b' => :bottom
+        }
+          
+
+        # Creates an AlignedPoint object from a text
+        # specification. Splits up the text at a comma and
+        def self.from_text(text, default = :figure)
+          if not text =~ /^\s*([btlrc]{2})(?::([^,]+),\s*(.*))?\s*$/
+            return "Invalid format for #{text}"
+          end
+
+          specs = $1
+          specs = specs.chars.map {|x| 
+            AlignmentSpecification.fetch(x.downcase)
+          }
+          coord = AlignedPoint.new
+          if specs[0] == :center
+            specs.reverse!
+          end
+          case specs[0]
+          when :center
+            coord.halign = :center
+            coord.valign = :center
+          when :left, :right
+            coord.halign = specs[0]
+            coord.valign = specs[1]
+          when :top, :bottom
+            coord.valign = specs[0]
+            coord.halign = specs[1]
+          end
+
+          if $2
+            x_spec,y_spec = $2,$3
+            coord.x = BaseCoordinate.from_text(x_spec, :x, default)
+            coord.y = BaseCoordinate.from_text(y_spec, :y, default)
+          else
+            case coord.halign
+            when :center
+              coord.x = BaseCoordinate.new(:frame, 0.5, :x)
+            when :left
+              coord.x = BaseCoordinate.new(:frame, 0.05, :x)
+            when :right
+              coord.x = BaseCoordinate.new(:frame, 0.95, :x)
+            end
+
+            case coord.valign
+            when :center
+              coord.y = BaseCoordinate.new(:frame, 0.5, :y)
+            when :bottom
+              coord.y = BaseCoordinate.new(:frame, 0.05, :y)
+            when :top
+              coord.y = BaseCoordinate.new(:frame, 0.95, :y)
+            end
+          end
+          return coord
+        end
+      end
+    end
+    
+  end
+
+end
+

data/lib/ctioga2/log.rb

@@ -0,0 +1,97 @@
+# log.rb, copyright (c) 2006, 2007, 2009 by Vincent Fourmond: 
+# The general logging functions for ctioga2
+  
+# 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 'logger'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 90 $', '$Date: 2009-06-22 23:28:01 +0200 (Mon, 22 Jun 2009) $')
+
+  # This module should be included (or extended) by every class that
+  # need logging/debugging facilities.
+  module Log
+
+    # Prints a debug message, on channel _channel_. Channel handling
+    # is not implemented yet.
+    def debug(message, channel = nil)
+      @@logger.debug(message)
+    end
+
+    # Prints a warning message
+    def warn(message)
+      @@logger.warn(message)
+    end
+
+    # Prints an informational message
+    def info(message)
+      @@logger.info(message)
+    end
+
+    # Prints an error message
+    def error(message)
+      @@logger.error(message)
+    end
+
+    # Prints a fatal error message and initiates program termination.
+    def fatal(message)
+      @@logger.fatal(message)
+      exit 1                    # Fatal error.
+    end
+
+    # These are module functions:
+    module_function :error, :debug, :warn, :info, :fatal
+
+    # Format an exception for displaying
+    def format_exception(e)
+      return "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+
+    def self.init_logger(stream = STDERR)
+      Logger::Formatter::Format.replace("[%4$s] %6$s\n")
+      @@logger = Logger.new(stream)
+      @@logger.level = Logger::WARN # Warnings and more only by default
+    end
+
+    # Simple accessor for the @@log class variable.
+    def self.logger
+      return @@logger
+    end
+
+    # Sets the logging level.
+    def self.set_level(level = Logger::WARN)
+      @@logger.level = level
+    end
+
+    # A logged replacement for system
+    def spawn(cmd, priority = :info)
+      retval = system(cmd)
+      self.send(priority, "Spawned #{cmd} -> " + 
+                if retval
+                  "success"
+                else
+                  "failure"
+                end
+                )
+      return retval
+    end
+
+    # Returns a string suitable for identification of an object, a bit
+    # in the spirit of #inspect, but without displaying instance
+    # variables.
+    def identify(obj)
+      return "#<%s 0x%x>" % [obj.class, obj.object_id]
+    end
+
+  end
+end