dyi 0.0.0

data/lib/dyi/formatter/svg_reader.rb

@@ -0,0 +1,113 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI 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 3 of the License, or
+# (at your option) any later version.
+#
+# DYI 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.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rexml/document'
+
+module DYI #:nodoc:
+  module Formatter #:nodoc:
+
+    class SvgReader
+      class << self
+        def read(file_name)
+          doc = REXML::Document.new(open(file_name))
+          container = DYI::Shape::ShapeGroup.new
+          doc.root.elements.each do |element|
+            container.child_elements.push(create_shape(element))
+          end
+          container
+        end
+
+        private
+
+        def create_shape(element)
+          case element.name
+            when 'g' then create_shape_group(element)
+            when 'polygon' then create_polygon(element)
+            when 'path' then create_path(element)
+          end
+        end
+
+        def create_shape_group(element)
+          group = DYI::Shape::ShapeGroup.new
+          element.elements.each do |child|
+            child_element = create_shape(child)
+            group.child_elements.push(child_element) if child_element
+          end
+          group
+        end
+
+        def create_polygon(element)
+          color = DYI::Color.new(element.attributes['fill']) if element.attributes['fill'] != 'none'
+          points = element.attributes['points'].split(/\s+/).map {|pt| pt.scan(/-?[\.0-9]+/).map {|s| s.to_f}}
+          path = nil
+          points.each do |pt|
+            if path
+              path.line_to(pt)
+            else
+              path = DYI::Shape::Polygon.new(pt, :painting => {:fill => color})
+            end
+          end
+          path
+        end
+
+        def create_path(element)
+          color = DYI::Color.new(element.attributes['fill']) if element.attributes['fill'] != 'none'
+          pathes = element.attributes['d'].scan(/(M|L|l|H|h|V|v|C|c|z)\s*(\s*(?:\s*,?[\-\.0-9]+)*)/)
+          path = nil
+          if pathes.first.first == 'M'
+            pathes.each do |p_el|
+              coors = p_el[1].scan(/-?[\.0-9]+/).map {|s| s.to_f}
+              case p_el.first
+              when 'M'
+                if path
+                  path.move_to(coors)
+                else
+                  path = DYI::Shape::Path.new(coors, :painting => {:fill => color})
+                end
+              when 'L'
+                path.line_to(coors)
+              when 'l'
+                path.line_to(coors, true)
+              when 'H'
+    p 'H'
+                path.line_to([coors.first, path.current_point.y])
+              when 'h'
+                path.line_to([coors.first, 0], true)
+              when 'V'
+    p 'V'
+                path.line_to([path.current_point.x, coors.first])
+              when 'v'
+                path.line_to([0, coors.first], true)
+              when 'C'
+                path.curve_to([coors[0..1], coors[2..3], coors[4..5]])
+              when 'c'
+                path.curve_to([coors[0..1], coors[2..3], coors[4..5]], true)
+              when 'z'
+                path.close_path
+              end
+            end
+          end
+          path
+        end
+      end
+    end
+  end
+end

data/lib/dyi/formatter/xaml_formatter.rb

@@ -0,0 +1,317 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI 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 3 of the License, or
+# (at your option) any later version.
+#
+# DYI 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.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+
+module DYI #:nodoc:
+  module Formatter #:nodoc:
+
+    class XamlFormatter < XmlFormatter
+
+      FONT_STYLE = {'normal'=>'Normal','italic'=>'Italic'}
+      FONT_WEIGHT = {'normal'=>'Normal','bold'=>'Bold','100'=>'Thin','200'=>'ExtraLight','300'=>'Light','400'=>'Normal','500'=>'Medium','600'=>'SemiBold','700'=>'Bold','800'=>'ExtraBold','900'=>'Black'}
+      FONT_STRETCH = {'normal'=>'Normal','ultra-condensed'=>'UltraCondensed','extra-condensed'=>'ExtraCondensed','condensed'=>'Condensed','semi-condensed'=>'SemiCondensed','semi-expanded'=>'SemiExpanded','expanded'=>'Expanded','extra-expanded'=>'ExtraExpanded','ultra-expanded'=>'UltraExpanded'}
+      STROKE_LINE_CAP = {'butt'=>'Flat','round'=>'Round','square'=>'Square'}
+      STROKE_LINE_JOIN = {'miter'=>'Miter','round'=>'Round','bevel'=>'Bevel'}
+      TEXT_ANCHOR = {'start'=>'Left','middle'=>'Center','end'=>'Right'}
+      SPREAD_METHOD = {'pad'=>'Pad','reflect'=>'Reflect','repeat'=>'Repeat'}
+
+      def puts(io=$>)
+        StringFormat.set_default_formats(:coordinate => 'x,y') {
+          super
+        }
+      end
+
+      def write_canvas(canvas, io)
+        create_node(io, 'UserControl',
+            :xmlns => "http://schemas.microsoft.com/winfx/2006/xaml/presentation",
+            :"xmlns:x" => "http://schemas.microsoft.com/winfx/2006/xaml",
+#            :"xmlns:navigation" => "clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation",
+#            :"xmlns:d" => "http://schemas.microsoft.com/expression/blend/2008",
+#            :"xmlns:mc" => "http://schemas.openxmlformats.org/markup-compatibility/2006",
+            :Width => canvas.width,
+            :Height => canvas.height) {
+          create_node(io, 'Canvas'){
+            canvas.child_elements.each do |element|
+              element.write_as(self, io)
+            end
+          }
+        }
+      end
+
+      def write_rectangle(shape, io)
+        attrs, attr_creator = common_attributes(shape, :shape)
+        attrs.merge!(:"Canvas.Left"=>shape.left, :"Canvas.Top"=>shape.top, :Width=>shape.width, :Height=>shape.height)
+        attrs[:RadiusX] = shape.attributes[:rx] if shape.attributes[:rx]
+        attrs[:RadiusY] = shape.attributes[:ry] if shape.attributes[:ry]
+        if attr_creator
+          create_node(io, 'Rectangle', attrs) {
+            attr_creator.call(io, 'Rectangle')
+          }
+        else
+          create_leaf_node(io, 'Rectangle', attrs)
+        end
+      end
+
+      def write_circle(shape, io)
+        attrs, attr_creator = common_attributes(shape, :shape)
+        attrs.merge!(:"Canvas.Left"=>shape.center.x - shape.radius, :"Canvas.Top"=>shape.center.y - shape.radius, :Width=>shape.radius * 2, :Height=>shape.radius * 2)
+        if attr_creator
+          create_node(io, 'Ellipse', attrs) {
+            attr_creator.call(io, 'Ellipse')
+          }
+        else
+          create_leaf_node(io, 'Ellipse', attrs)
+        end
+      end
+
+      def write_ellipse(shape, io)
+        attrs, attr_creator = common_attributes(shape, :shape)
+        attrs.merge!(:"Canvas.Left"=>shape.center.x - shape.radius, :"Canvas.Top"=>shape.center.y - shape.radius, :Width=>shape.radius_x * 2, :Height=>shape.radius_y * 2)
+        if attr_creator
+          create_node(io, 'Ellipse', attrs) {
+            attr_creator.call(io, 'Ellipse')
+          }
+        else
+          create_leaf_node(io, 'Ellipse', attrs)
+        end
+      end
+
+      def write_line(shape, io)
+        attrs, attr_creator = common_attributes(shape, :line)
+        attrs.merge!(:X1 => shape.start_point.x, :Y1 => shape.start_point.y, :X2 => shape.end_point.x, :Y2 => shape.end_point.y)
+        if attr_creator
+          create_node(io, 'Line', attrs) {
+            attr_creator.call(io, 'Line')
+          }
+        else
+          create_leaf_node(io, 'Line', attrs)
+        end
+      end
+
+      def write_polyline(shape, io)
+        attrs, attr_creator = common_attributes(shape, :line)
+        attrs.merge!(:Points => shape.points.join(' '))
+        if attr_creator
+          create_node(io, 'Polyline', attrs) {
+            attr_creator.call(io, 'Polyline')
+          }
+        else
+          create_leaf_node(io, 'Polyline', attrs)
+        end
+      end
+
+      def write_polygon(shape, io)
+        attrs, attr_creator = common_attributes(shape, :shape)
+        attrs.merge!(:Points => shape.points.join(' '))
+        if attr_creator
+          create_node(io, 'Polygon', attrs) {
+            attr_creator.call(io, 'Polygon')
+          }
+        else
+          create_leaf_node(io, 'Polygon', attrs)
+        end
+      end
+
+      def write_path(shape, io)
+        attrs, attr_creator = common_attributes(shape, :line)
+        attrs.merge!(:Data => shape.concise_path_data)
+        if attr_creator
+          create_node(io, 'Path', attrs) {
+            attr_creator.call(io, 'Path')
+          }
+        else
+          create_leaf_node(io, 'Path', attrs)
+        end
+      end
+
+      def write_text(shape, io)
+        attrs, attr_creator = common_attributes(shape, :text)
+        attrs.merge!(:"Canvas.Left" => shape.point.x, :"Canvas.Top" => shape.point.y)
+#        attrs[:"text-decoration"] = shape.attributes[:text_decoration] if shape.attributes[:text_decoration]
+        case shape.attributes[:alignment_baseline]
+          when nil then attrs[:"Canvas.Top"] -= shape.font_height * 0.85
+          when 'middle' then attrs[:"Canvas.Top"] -= shape.font_height * 0.5
+          when 'bottom' then attrs[:"Canvas.Top"] -= shape.font_height
+        end
+        case text_anchor = TEXT_ANCHOR[shape.attributes[:text_anchor]]
+        when 'Left'
+          attrs[:TextAlignment] = text_anchor
+        when 'Center'
+          attrs[:Width] = @canvas.width
+          attrs[:"Canvas.Left"] -= @canvas.width.quo(2)
+          attrs[:TextAlignment] = text_anchor
+        when 'Right'
+          attrs[:Width] = @canvas.width
+          attrs[:"Canvas.Left"] -= @canvas.width
+          attrs[:TextAlignment] = text_anchor
+        end
+#        attrs[:"writing-mode"] = shape.attributes[:writing_mode] if shape.attributes[:writing_mode]
+        text = shape.formated_text
+        if text =~ /(\r\n|\n|\r)/
+          attrs[:Text] = $`.strip
+          create_node(io, 'TextBlock', attrs) {
+            attr_creator.call(io, 'TextBlock') if attr_creator
+            create_leaf_node(io, 'LineBreak')
+            $'.each_line do |line|
+              create_leaf_node(io, 'Run', line.strip)
+            end
+          }
+        else
+          attrs[:Text] = text
+          if attr_creator
+            create_node(io, 'TextBlock', attrs, &attr_creator)
+          else
+            create_leaf_node(io, 'TextBlock', attrs)
+          end
+        end
+      end
+
+      def write_group(shape, io)
+        attrs, attr_creator = common_attributes(shape)
+        create_node(io, 'Canvas', attrs) {
+          attr_creator.call(io, 'Canvas') if attr_creator
+          create_node(io, 'Canvas.RenderTransform') {
+            create_transform_node(shape, io)
+          } unless shape.transform.empty?
+          shape.child_elements.each do |element|
+            element.write_as(self, io)
+          end
+        }
+      end
+
+      def write_linear_gradient(shape, io)
+        attr = {
+          :StartPoint => "#{shape.start_point[0]},#{shape.start_point[1]}",
+          :EndPoint => "#{shape.stop_point[0]},#{shape.stop_point[1]}"}
+        if spread_method = SPREAD_METHOD[shape.spread_method]
+          attr[:SpreadMethod] = spread_method
+        end
+        create_node(io, 'LinearGradientBrush', attr) {
+          shape.child_elements.each do |element|
+            element.write_as(self, io)
+          end
+        }
+      end
+
+      def write_gradient_stop(shape, io)
+        attrs = {:Offset=>shape.offset}
+        attrs[:Color] = shape.color.to_s16(shape.opacity) if shape.color
+        create_leaf_node(io, 'GradientStop', attrs)
+      end
+
+      def write_clip(shape, io)
+        # TODO
+      end
+
+      private
+
+      def common_attributes(shape, type=nil) # :nodoc:
+        attributes = {}
+        font = create_font_attr(shape)
+        painting, attr_creator = create_painting_attr(shape, type)
+        attributes.merge!(font) unless font.empty?
+        attributes.merge!(painting) unless painting.empty?
+        [attributes, attr_creator]
+      end
+
+      def create_font_attr(shape) # :nodoc:
+        attr = {}
+        if shape.respond_to?(:font) && (font = shape.font) && !font.empty?
+          attr[:FontFamily] = font.font_family if font.font_family
+          if font_style = FONT_STYLE[font.style]
+            attr[:FontStyle] = font_style
+          end
+          if font_weight = FONT_WEIGHT[font.weight]
+            attr[:FontWeight] = font_weight
+          end
+          if font_stretch = FONT_STRETCH[font.stretch]
+            attr[:FontStretch] = font_stretch
+          end
+        end
+        attr[:FontSize] = shape.font_height.to_user_unit if shape.respond_to?(:font_height)
+        attr
+      end
+
+      def create_painting_attr(shape, type) # :nodoc:
+        attr = {}
+        attr_creator = nil
+        if shape.respond_to?(:painting) && (painting = shape.painting) && !painting.empty?
+          if painting.fill
+            if painting.fill.respond_to?(:write_as)
+              case type
+              when :shape,:line
+                attr_creator = proc {|io, tag_name|
+                  create_node(io, "#{tag_name}.Fill") {
+                    painting.fill.write_as(self, io)
+                  }
+                }
+              when :text
+                attr_creator = proc {|io, tag_name|
+                  create_node(io, "#{tag_name}.Foreground") {
+                    painting.fill.write_as(self, io)
+                  }
+                }
+              end
+            else
+              case type
+                when :shape,:line then attr[:Fill] = painting.fill.to_s16(painting.fill_opacity)
+                when :text then attr[:Foreground] = painting.fill.to_s16(painting.fill_opacity)
+              end
+            end
+          end
+          attr[:Stroke] = painting.stroke.to_s16(painting.stroke_opacity) if painting.stroke
+          attr[:StrokeDashArray] = painting.stroke_dasharray.join(',') if painting.stroke_dasharray
+          attr[:StrokeDashOffset] = painting.stroke_dashoffset.to_user_unit if painting.stroke_dashoffset
+          if type == :line && linecap = STROKE_LINE_CAP[painting.stroke_linecap]
+            attr[:StrokeStartLineCap] = linecap
+            attr[:StrokeEndLineCap] = linecap
+          end
+          if linejoin = STROKE_LINE_JOIN[painting.stroke_linejoin]
+            attr[:StrokeLineJoin] = linejoin
+          end
+          attr[:StrokeMitterLimit] = painting.stroke_miterlimit if painting.stroke_miterlimit
+          if painting.stroke_width
+            attr[:StrokeThickness] = painting.stroke_width.to_user_unit
+          end
+        end
+        [attr, attr_creator]
+      end
+
+      def create_transform_node(shape, io) # :nodoc:
+        create_node(io, 'TransformGroup') {
+          shape.transform.each do |tr|
+            case tr.first
+            when :translate
+              create_leaf_node(io, 'TranslateTransform', :X=>tr[1], :Y=>tr[2])
+            when :scale
+              create_leaf_node(io, 'ScaleTransform', :ScaleX=>tr[1], :ScaleY=>tr[2])
+            when :rotate
+              create_leaf_node(io, 'RotateTransform', :Angle=>tr[1])
+            when :skewX
+              create_leaf_node(io, 'ScaleTransform', :AngleX=>tr[1])
+            when :skewY
+              create_leaf_node(io, 'ScaleTransform', :AngleY=>tr[1])
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/dyi/length.rb

@@ -0,0 +1,399 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+# Documentation:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI 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 3 of the License, or
+# (at your option) any later version.
+#
+# DYI 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.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+#
+# == Overview
+#
+# This file provides the DYI::Length class, which provides length
+# supports for DYI scripts.  The length is a distance measurement.
+#
+# See the documentation to the DYI::Length class for more details and
+# examples of usage.
+#
+
+module DYI #:nodoc:
+
+  # Class representing a length.  See documentation for the file
+  # dyi/length.rb for an overview.
+  #
+  # == Introduction
+  #
+  # This class works with an amount and a unit.  The lists of unit identifiers
+  # matches the list of unit identifiers in CSS: em, ex, px, pt, pc, cm, mm, in
+  # and percentages(%).  When a unit is not given, then the length is assumed
+  # to be in user units (i.e., a value in the current user coordinate sytem).
+  #
+  # * As in CSS, the _em_ and _ex_ unit identifiers are relative to the current
+  #   font's font-size and x-height, respectively.
+  # * One _px_ unit is defined to be equal to one user unit.
+  # * 1<em>pt</em> equals 1.25 user units.
+  # * 1<em>pc</em> equals 15 user units.
+  # * 1<em>mm</em> equals 3.543307 user units.
+  # * 1<em>cm</em> equals 35.43307 user units.
+  # * 1<em>in</em> equals 90 user units.
+  # * For percentage values that are defined to be relative to the size of
+  #   parent element.
+  #
+  # == Ways of comparing and calculating
+  #
+  # This class include +Comparable+ module, therefore you can use the
+  # comparative operators.  In the comparison between DYI::Length
+  # objects, the unit of each objects are arranged and it does.  The equality
+  # operator '<tt>==</tt>' does not test equality instance but test equality
+  # value.
+  #
+  # This class suports following arithmetic operators and methods: <tt>+</tt>,
+  # <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, <tt>%</tt>, <tt>**</tt>, +#div+, +#quo+,
+  # +#modulo+.  The operators '<tt>+</tt>', '<tt>-</tt>' coerced right hand
+  # operand into Length, and then calculate.
+  #
+  # See the documentation to each operators and methods class for details.
+  #
+  # == Examples of use
+  #
+  #   length1 = DYI::Length.new(10)   # 10 user unit (equals to 10px).
+  #   length2 = DYI::Length.new('10') # it is 10px too.
+  #   DYI::Length.new('1in') > DYI::Length.new(50)
+  #                             # => true, 1in equals 90px.
+  #   DYI::Length.new('1in') > DYI::Length.new('2em')
+  #                             # => Error, 'em' is not comparable unit.
+  #   DYI::Length.new('10cm') == DYI::Length.new('100mm')
+  #                             # => true
+  class Length
+    include Comparable
+
+    # Array of unit that can be used.
+    UNITS = ['px', 'pt', '%', 'cm', 'mm', 'in', 'em', 'ex', 'pc']
+
+    @@units = {'px'=>1.0,'pt'=>1.25,'cm'=>35.43307,'mm'=>3.543307,'in'=>90.0,'pc'=>15.0}
+    @@default_format = '0.###U'
+
+    # Returns a new DYI::Length object.
+    #
+    # +length+ is instance of +Numeric+, +String+, or
+    # <tt>DYI::Length</tt> class.
+    def initialize(length)
+      case length
+      when Length
+        @value = length._num
+        @unit = length._unit
+      when Numeric
+        @value = length
+        @unit = nil
+      when String
+        unless /^\s*(-?[\d]*(?:\d\.|\.\d|\d)[0\d]*)(#{UNITS.join('|')})?\s*$/ =~ length
+          raise ArgumentError, "`#{length}' is string that could not be understand"
+        end
+        __value, __unit = $1, $2
+        @value = __value.include?('.') ? __value.to_f : __value.to_i
+        @unit = (__unit == 'px' || @value == 0) ? nil : __unit
+      else
+        raise TypeError, "#{length.class} can't be coerced into Length"
+      end
+    end
+
+    # This constant is zoro length.
+    ZERO = new(0)
+
+    # Returns the receiver's value.
+    def +@
+      self
+    end
+
+    # Returns the receiver's value, negated.
+    def -@
+      new_length(-@value)
+    end
+
+    # Returns a new length which is the sum of the receiver and +other+.
+    def +(other)
+      other = self.class.new(other)
+      if @unit == other._unit
+        new_length(@value + other._num)
+      else
+        self.class.new(to_f + other.to_f)
+      end
+    end
+
+    # Returns a new length which is the difference of the receiver and +other+.
+    def -(other)
+      other = self.class.new(other)
+      if @unit == other._unit
+        new_length(@value - other._num)
+      else
+        self.class.new(to_f - other.to_f)
+      end
+    end
+
+    # Returns a new muliplicative length of the receiver by +number+.
+    def *(number)
+      new_length(@value * number)
+    end
+
+    # Raises a length the number power.
+    def **(number)
+      new_length(@value ** number)
+    end
+
+    # Returns a new length which is the result of dividing the receiver by
+    # +other+.
+    def div(other)
+      case other
+      when Length
+        if @unit == other.unit
+          @value.div(other._num)
+        else
+          to_f.div(other.to_f)
+        end
+      else
+        raise TypeError, "#{other.class} can't be coerced into Length"
+      end
+    end
+
+    # Return a new length which is the modulo after division of the receiver by
+    # +other+.
+    def % (other)
+      case other
+      when Length
+        if @unit == other.unit
+          new_length(@value % other._num)
+        else
+          self.class.new(to_f % other.to_f)
+        end
+      else
+        raise TypeError, "#{other.class} can't be coerced into Length"
+      end
+    end
+
+    # If argument +number+ is a numeric, returns a new divisional length of the
+    # receiver by +other+.  If argument +number+ is a length, returns a divisional
+    # float of the receiver by +other+.
+    #
+    #   DYI::Length.new(10) / 4                          # => 2.5px
+    #   DYI::Length.new(10) / DYI::Length.new(4) # => 2.5
+    def /(number)
+      case number
+      when Numeric
+        new_length(@value.quo(number.to_f))
+      when Length
+        if @unit == number.unit
+          @value.quo(number._num.to_f)
+        else
+          to_f.quo(number.to_f)
+        end
+      else
+        raise TypeError, "#{number.class} can't be coerced into Numeric or Length"
+      end
+    end
+
+    alias quo /
+    alias modulo %
+
+    def clone #:nodoc:
+      raise TypeError, "allocator undefined for Length"
+    end
+
+    def dup #:nodoc:
+      raise TypeError, "allocator undefined for Length"
+    end
+
+    # Returns +true+ if the receiver has a zero length, +false+ otherwise.
+    def zero?
+      @value == 0
+    end
+
+    # Returns +self+ if the receiver is not zero, +nil+ otherwise.
+    def nonzero?
+      @value == 0 ? nil : self
+    end
+
+    # Returns the absolute length of the receiver.
+    def abs
+      @value >= 0 ? self : -self
+    end
+
+    # Returns +-1+, +0+, <tt>+1</tt> or +nil+ depending on whether the receiver
+    # is less than, equal to, greater than real or not comparable.
+    def <=>(other)
+      return nil unless other.kind_of?(Length)
+      if @unit == other._unit
+        @value <=> other._num
+      else
+        to_f <=> other.to_f rescue nil
+      end
+    end
+
+    # Returns the receiver's unit.  If receiver has no unit, returns 'px'.
+    def unit
+      @unit.nil? ? 'px' : @unit
+    end
+
+    # :call-seq:
+    # step (limit, step) {|length| ...}
+    # step (limit, step)
+    #
+    # Invokes block with the sequence of length starting at receiver,
+    # incremented by +step+ on each call.  The loop finishes when +length+ to be
+    # passed to the block is greater than +limit+ (if +step+ is positive) or
+    # less than +limit+ (if +step+ is negative).
+    #
+    # If no block is given, an enumerator is returned instead.
+    def step(limit, step)
+      if @unit == limit._unit && @unit == step._unit
+        self_value, limit_value, step_value = @value, limit._num, step._num
+      else
+        self_value, limit_value, step_value = to_f, limit.to_f, step.to_f
+      end
+      enum = Enumerator.new {|y|
+        self_value.step(limit_value, step_value) do |value|
+          self.new_length(value)
+        end
+      }
+      if block_given?
+        enum.each(&proc)
+        self
+      else
+        enum
+      end
+    end
+
+    # Returns a new length that converted into length of user unit.
+    def to_user_unit
+      @unit ? self.class.new(to_f) : self
+    end
+
+    # Returns a string representing obj.
+    #
+    # Format string can be specified for the argument.  If no argument is given,
+    # +default_format+ of this class is used as format string. About format
+    # string, see the documentation to +default_format+ method.
+    def to_s(format=nil)
+      fmts = (format || @@default_format).split('\\\\')
+      fmts = fmts.map do |fmt|
+        fmt.gsub(/(?!\\U)(.|\G)U/, '\\1' + @unit.to_s).gsub(/(?!\\u)(.|\G)u/, '\\1' + unit)
+      end
+      @value.strfnum(fmts.join('\\\\'))
+    end
+
+    # Returns amount part of a length converted into given unit as float.  If
+    # parameter +unit+ is given, converts into user unit.
+    def to_f(unit=nil)
+      unless self_ratio = @unit ? @@units[@unit] : 1.0
+        raise RuntimeError, "unit `#{@unit}' can not convert into user unit"
+      end
+      unless param_ratio = unit ? @@units[unit] : 1.0
+        if UNITS.include?(unit)
+          raise RuntimeError, "unit `#{@unit}' can not convert into user unit"
+        else
+          raise ArgumentError, "unit `#{@unit}' is unknown unit"
+        end
+      end
+      (@value * self_ratio.quo(param_ratio)).to_f
+    end
+
+    def inspect #:nodoc:
+      @value.to_s + @unit.to_s
+    end
+
+    protected
+
+    def _num #:nodoc:
+      @value
+    end
+
+    def _unit #:nodoc:
+      @unit
+    end
+
+    private
+
+    def new_length(value) #:nodoc:
+      other = self.class.allocate
+      other.instance_variable_set(:@value, value)
+      other.instance_variable_set(:@unit, @unit)
+      other
+    end
+
+    class << self
+
+      public
+
+      def new(*args) #:nodoc:
+        return args.first if args.size == 1 && args.first.instance_of?(self)
+        super
+      end
+
+      # Returns new instance as +new+ method when an argument is not +nil+.
+      # If an argument is +nil+, returns +nil+.
+      def new_or_nil(*args)
+        (args.size == 1 && args.first.nil?) ? nil : new(*args)
+      end
+
+      # Returns a coefficient that is used for conversion from any unit into
+      # user unit. 
+      def unit_ratio(unit)
+        raise ArgumentError, "unit `#{unit}' can not convert other unit" unless ratio = @@units[unit.to_s]
+        ratio
+      end
+
+      # :call-seq:
+      # set_default_format (format) {...}
+      # set_default_format (format)
+      #
+      # Invokes block with given +format+ string as default format.  After
+      # invokes block, formar format is used.
+      #
+      # If no block is given, sets default format setring as +default_format=+
+      # method.
+      def set_default_format(format)
+        if block_given?
+          org_format = @@default_format
+          self.default_format = format
+          yield
+          @@default_format = org_format
+          self
+        else
+          self.default_format = format
+        end
+      end
+
+      # Returns format that is used when called to_s. See the documentation to
+      # +default_format=+ method too.
+      def default_format
+        @@default_format
+      end
+
+      # Sets format that is used when called to_s.
+      #
+      # The format string is same as <tt>Numeric#strfnum</tt> format.  See the
+      # documentation to <tt>Numeric#strfnum</tt> method.  In addition to
+      # place-holder of +strfnum+, following placeholder can be used.
+      #
+      # +u+:: (unit placeholder) Placeholder '+u+' is replaced as a unit. If
+      #       the unit is user unit, '+u+' is repleced as 'px'.
+      # +U+:: (unit placeholder) Placeholder '+U+' is replaced as a unit. If
+      #       the unit is user unit, '+U+' is replece as empty string.
+      def default_format=(fromat)
+        @@default_format = fromat.dup
+      end
+    end
+  end
+end