class Magick::RVG

def self.convert_one_to_float(arg)
    begin
        farg = Float(arg)
    rescue ArgumentError, TypeError
        raise ArgumentError, "argument cannot be converted to Float (got #{arg.class})"
    end
    return farg
end

def self.convert_to_float(*args)
    allow_nil = false
    if args.last == :allow_nil
        allow_nil = true
        args.pop
    end
    begin
        fargs = args.collect { |a| (allow_nil && a.nil?) ? a : Float(a) }
    rescue ArgumentError, TypeError
        raise ArgumentError, self.fmsg(*args)
    end
    return fargs
end

def self.fmsg(*args)
    "at least one argument cannot be converted to Float (got #{args.collect {|a| a.class}.join(', ')})"
end

def add_outermost_primitives(gc)    #:nodoc:
    add_transform_primitives(gc)
    gc.push
    add_viewbox_primitives(@width, @height, gc)
    add_style_primitives(gc)
    @content.each { |element| element.add_primitives(gc) }
    gc.pop
    self
end

def add_primitives(gc)  #:nodoc:
    if @width.nil? || @height.nil?
        raise ArgumentError, "RVG width or height undefined"
    elsif @width == 0 || @height == 0
        return self
    end
    gc.push
    add_outermost_primitives(gc)
    gc.pop
end

def background_fill=(color)
    warn "background_fill= has no effect in nested RVG objects" if @nested
    if ! color.kind_of?(Magick::Pixel)
        begin
            @background_fill = Magick::Pixel.from_color(color)
        rescue Magick::ImageMagickError
            raise ArgumentError, "unknown color `#{color}'"
        rescue TypeError
            raise TypeError, "cannot convert #{color.class} into Pixel"
        rescue
            raise ArgumentError, "argument must be a color name or a Pixel (got #{color.class})"
        end
    else
        @background_fill = color
    end
end

def background_fill_opacity=(opacity)
    warn "background_fill_opacity= has no effect in nested RVG objects" if @nested
    begin
        @background_fill_opacity = Float(opacity)
    rescue ArgumentError
        raise ArgumentError, "background_fill_opacity must be a number between 0 and 1 (#{opacity} given)"
    end
end

def background_image=(bg_image)
    warn "background_image= has no effect in nested RVG objects" if @nested
    if bg_image && ! bg_image.kind_of?(Magick::Image)
        raise ArgumentError, "background image must be an Image (got #{bg_image.class})"
    end
    @background_image = bg_image
end

def background_pattern=(filler)
    warn "background_pattern= has no effect in nested RVG objects" if @nested
    @background_pattern = filler
end

def background_position=(pos)
    warn "background_position= has no effect in nested RVG objects" if @nested
    bg_pos = pos.to_s.downcase
    if ! ['scaled', 'tiled', 'fit'].include?(bg_pos)
        raise ArgumentError, "background position must be `scaled', `tiled', or `fit' (#{pos} given)"
    end
    @background_position = bg_pos.to_sym
end

def bgfill()
    if @background_fill.nil?
        color = Magick::Pixel.new(0,0,0,Magick::TransparentOpacity)
    else
        color = @background_fill
        color.opacity = (1.0 - @background_fill_opacity) * Magick::TransparentOpacity
    end
    return color
end

def corner(x, y)        #:nodoc:
    @nested = true
    @x, @y = Float(x), Float(y)
    translate(@x, @y) if (@x != 0.0 || @y != 0.0)
end

def deep_equal(other)
    if self != other
        puts "#{c.inspect} not equal.\nself:#{self} != other:#{other}"
        return false
    end
    return true
end

def deep_equal(other)
    ivs = self.instance_variables
    ivs.each do |iv|
        itv = self.instance_variable_get(iv)
        otv = other.instance_variable_get(iv)
        if itv.respond_to?(:deep_equal)
            if itv.equal?(otv)
                puts "#{iv} has deep_equal but self.#{iv} and other.#{iv} are the same object."
                return false
            end
            if !itv.deep_equal(otv)
                puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
                return false
            end
        else
            case itv
                when Float, Symbol, TrueClass, FalseClass, Fixnum, NilClass
                    return false if itv != otv
                else
                    if itv.equal?(otv)
                        puts "#{iv} is dup-able but self.#{iv} and other.#{iv} are the same object."
                        return false
                    end
                    if itv != otv
                        puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
                        return false
                    end
            end
        end
    end
    return true
end

def dpi=(n)
    if !defined?(@dpi)
        [Float, Fixnum].each do |c|
            c.class_eval <<-END_DEFS
                # the default measurement - 1px is 1 pixel
                def px
                    self
                end
                # inches
                def in
                    self * ::Magick::RVG.dpi
                end
                # millimeters
                def mm
                    self * ::Magick::RVG.dpi / 25.4
                end
                # centimeters
                def cm
                    self * ::Magick::RVG.dpi / 2.54
                end
                # points
                def pt
                    self * ::Magick::RVG.dpi / 72.0
                end
                # picas
                def pc
                    self * ::Magick::RVG.dpi / 6.0
                end
                # percentage of the argument
                def pct(of)
                    self * Float(of) / 100.0
                end
                # the default is deg
                def deg
                    self
                end
                # radians -> degrees
                def rad
                    self * 180.0 / Math::PI
                end
                # grads -> degrees
                def grad
                    self * 9.0 / 10.0
                end
            END_DEFS
        end
    end
    @dpi = Float(n)
    return @dpi
rescue ArgumentError
    raise TypeError, "Can't convert `#{n}' to Float"
end

def draw
    raise StandardError, "draw not permitted in nested RVG objects" if @nested
    @canvas ||= new_canvas    # allow drawing over existing canvas
    gc = Utility::GraphicContext.new
    add_outermost_primitives(gc)
    pp(self) if ENV['debug_rvg']
    print_gc(gc) if ENV['debug_prim']
    gc.draw(@canvas)
    return @canvas
end

def initialize(width=nil, height=nil)
    super
    @width, @height = width, height
    @content = Content.new
    @canvas = nil
    @background_fill = nil
    @background_fill_opacity = 1.0  # applies only if background_fill= is used
    @background_position = :scaled
    @background_pattern, @background_image, @desc, @title, @metadata = nil
    @x, @y = 0.0, 0.0
    @nested = false
    yield(self) if block_given?
end

def new_canvas
    if @background_pattern
        canvas = Magick::Image.new(@width, @height, @background_pattern)
    elsif @background_image
        if @width != @background_image.columns || @height != @background_image.rows
            canvas = case @background_position
                when :scaled
                    @background_image.resize(@width, @height)
                when :tiled
                    Magick::Image.new(@width, @height, Magick::TextureFill.new(@background_image))
                when :fit
                    width, height = @width, @height
                    bgcolor = bgfill()
                    @background_image.change_geometry(Magick::Geometry.new(width, height)) do |new_cols, new_rows|
                        bg_image = @background_image.resize(new_cols, new_rows)
                        if bg_image.columns != width || bg_image.rows != height
                            bg = Magick::Image.new(width, height) { self.background_color = bgcolor }
                            bg_image = bg.composite!(bg_image, Magick::CenterGravity, Magick::OverCompositeOp)
                        end
                        bg_image
                    end
            end
        else
            canvas = @background_image.copy
        end
    else
        bgcolor = bgfill()
        canvas = Magick::Image.new(Integer(@width), Integer(@height)) { self.background_color = bgcolor }
    end
    canvas[:desc] = @desc if @desc
    canvas[:title] = @title if @title
    canvas[:metadata] = @metadata if @metadata
    return canvas
end

def print_gc(gc)
    primitives = gc.inspect.split(/\n/)
    indent = 0
    primitives.each do |cmd|
        indent -= 1 if cmd['pop ']
        print(('   '*indent), cmd, "\n")
        indent += 1 if cmd['push ']
    end
end

def ref(x, y, rw, rh)   #:nodoc:
    translate(x, y) if (x != 0 || y != 0)
    @width = rw if rw
    @height = rh if rh
end