class Magick::RVG

Constants

WORD_SEP

Attributes

dpi[R]
background_fill[R]

The background fill color specified by #background_fill=

background_fill_opacity[R]

The background fill color opacity specified by #background_fill_opacity=

background_image[R]

The background image specified by #background_image=

background_position[R]

The background image layout specified by #background_position=

canvas[R]

The image after drawing has completed

height[R]
width[R]
x[R]

For embedded RVG objects, the x-axis coordinate of the upper-left corner

y[R]

For embedded RVG objects, the x-axis coordinate of the upper-left corner

Public Class Methods

convert_one_to_float(arg) click to toggle source
# File lib/rvg/misc.rb, line 56
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
    farg
end
convert_to_float(*args) click to toggle source
# File lib/rvg/misc.rb, line 42
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, fmsg(*args)
    end
    fargs
end
dpi=(n) click to toggle source
# File lib/rvg/units.rb, line 8
def dpi=(n)
    unless 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
fmsg(*args) click to toggle source

Convert an array of method arguments to Float objects. If any cannot be converted, raise ArgumentError and issue a message.

# File lib/rvg/misc.rb, line 38
def self.fmsg(*args)
    "at least one argument cannot be converted to Float (got #{args.collect {|a| a.class}.join(', ')})"
end
new(width=nil, height=nil) { |self| ... } click to toggle source

Draw a width x height image. The image is specified by calling one or more drawing methods on the RVG object. You can group the drawing method calls in the optional associated block. The x and y arguments have no meaning for the outermost RVG object. On nested RVG objects [x, y] is the coordinate of the upper-left corner in the containing canvas on which the nested RVG object is placed.

Drawing occurs on a canvas created by the draw method. By default the canvas is transparent. You can specify a different canvas with the background_fill= or background_image= methods.

RVG objects are containers. That is, styles and transforms defined on the object are used by contained objects such as shapes, text, and groups unless overridden by an inner container or the object itself.

Calls superclass method Magick::RVG::Stretchable.new
# File lib/rvg/rvg.rb, line 215
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

Public Instance Methods

background_fill=(color) click to toggle source

Sets the canvas background color. Either a Magick::Pixel or a color name. The default fill is “none”, that is, transparent black.

# File lib/rvg/rvg.rb, line 173
def background_fill=(color)
    warn 'background_fill= has no effect in nested RVG objects' if @nested
    if !color.is_a?(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
background_fill_opacity=(opacity) click to toggle source

Opacity of the background fill color, a number between 0.0 (transparent) and 1.0 (opaque). The default is 1.0 when the #background_fill= attribute has been set.

# File lib/rvg/rvg.rb, line 192
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
background_image=(bg_image) click to toggle source

Sets an image to use as the canvas background. See #background_position= for layout options.

# File lib/rvg/rvg.rb, line 140
def background_image=(bg_image)
    warn 'background_image= has no effect in nested RVG objects' if @nested
    if bg_image && !bg_image.is_a?(Magick::Image)
        fail ArgumentError, "background image must be an Image (got #{bg_image.class})"
    end
    @background_image = bg_image
end
background_pattern=(filler) click to toggle source

Sets an object to use to fill the canvas background. The object must have a fill method. See the Fill Classes section in the RMagick doc for more information.

# File lib/rvg/rvg.rb, line 151
def background_pattern=(filler)
    warn 'background_pattern= has no effect in nested RVG objects' if @nested
    @background_pattern = filler
end
background_position=(pos) click to toggle source

How to position the background image on the canvas. One of the following symbols:

:scaled

Scale the image to the canvas width and height.

:tiled

Tile the image across the canvas.

:fit

Scale the image to fit within the canvas while retaining the image proportions. Center the image on the canvas. Color any part of the canvas not covered by the image with the background color.

# File lib/rvg/rvg.rb, line 162
def background_position=(pos)
    warn 'background_position= has no effect in nested RVG objects' if @nested
    bg_pos = pos.to_s.downcase
    unless ['scaled', 'tiled', 'fit'].include?(bg_pos)
        fail ArgumentError, "background position must be `scaled', `tiled', or `fit' (#{pos} given)"
    end
    @background_position = bg_pos.to_sym
end
deep_equal(other) click to toggle source
# File lib/rvg/deep_equal.rb, line 5
def deep_equal(other)
    if self != other
        puts "#{c.inspect} not equal.\nself:#{self} != other:#{other}"
        return false
    end
    true
end
draw() click to toggle source

Construct a canvas or reuse an existing canvas. Execute drawing commands. Return the canvas.

# File lib/rvg/rvg.rb, line 231
def draw
    fail 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)
    @canvas
end

Private Instance Methods

bgfill() click to toggle source

#background_fill defaults to 'none'. If #background_fill has been set to something else, combine it with the background_fill_opacity.

# File lib/rvg/rvg.rb, line 62
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
    color
end
new_canvas() click to toggle source
# File lib/rvg/rvg.rb, line 72
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
    canvas
end
print_gc(gc) click to toggle source