Class Magick::RVG
In: lib/rvg/paint.rb
lib/rvg/stylable.rb
lib/rvg/clippath.rb
lib/rvg/units.rb
lib/rvg/deep_equal.rb
lib/rvg/stretchable.rb
lib/rvg/pathdata.rb
lib/rvg/rvg.rb
lib/rvg/transformable.rb
lib/rvg/text.rb
lib/rvg/describable.rb
lib/rvg/embellishable.rb
lib/rvg/misc.rb
lib/rvg/container.rb
Parent: Object
Enum GeometryValue Stylable RVG\n[lib/rvg/clippath.rb\nlib/rvg/container.rb\nlib/rvg/deep_equal.rb\nlib/rvg/describable.rb\nlib/rvg/embellishable.rb\nlib/rvg/misc.rb\nlib/rvg/paint.rb\nlib/rvg/pathdata.rb\nlib/rvg/rvg.rb\nlib/rvg/stretchable.rb\nlib/rvg/stylable.rb\nlib/rvg/text.rb\nlib/rvg/transformable.rb\nlib/rvg/units.rb] Transformable Stretchable Embellishable Describable Duplicatable Comparable Image ImageList Enumerable Geometry OptionalMethodArguments HatchFill Draw lib/RMagick.rb lib/rvg/container.rb ObjectData Application Pre_ObjectData_Descriptor Envelope Post_ObjectData_Descriptor IPTC Magick dot/m_14_0.png

Methods

Included Modules

Stylable Transformable Stretchable Embellishable Describable Duplicatable

Classes and Modules

Module Magick::RVG::Describable
Module Magick::RVG::Duplicatable
Module Magick::RVG::Embellishable
Module Magick::RVG::ImageConstructors
Module Magick::RVG::PreserveAspectRatio
Module Magick::RVG::ShapeConstructors
Module Magick::RVG::Stretchable
Module Magick::RVG::StructureConstructors
Module Magick::RVG::Stylable
Module Magick::RVG::TextConstructors
Module Magick::RVG::Transformable
Module Magick::RVG::UseConstructors
Class Magick::RVG::Circle
Class Magick::RVG::ClipPath
Class Magick::RVG::Ellipse
Class Magick::RVG::Group
Class Magick::RVG::Image
Class Magick::RVG::Line
Class Magick::RVG::Path
Class Magick::RVG::PathData
Class Magick::RVG::Pattern
Class Magick::RVG::PolyShape
Class Magick::RVG::Polygon
Class Magick::RVG::Polyline
Class Magick::RVG::Rect
Class Magick::RVG::Text
Class Magick::RVG::TextBase
Class Magick::RVG::Use
Class Magick::RVG::Utility

Constants

WORD_SEP = / /

Attributes

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
dpi  [R] 
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

[Source]

    # File lib/rvg/misc.rb, line 60
60:         def self.convert_one_to_float(arg)
61:             begin
62:                 farg = Float(arg)
63:             rescue ArgumentError, TypeError
64:                 raise ArgumentError, "argument cannot be converted to Float (got #{arg.class})"
65:             end
66:             return farg
67:         end

[Source]

    # File lib/rvg/misc.rb, line 46
46:         def self.convert_to_float(*args)
47:             allow_nil = false
48:             if args.last == :allow_nil
49:                 allow_nil = true
50:                 args.pop
51:             end
52:             begin
53:                 fargs = args.collect { |a| (allow_nil && a.nil?) ? a : Float(a) }
54:             rescue ArgumentError, TypeError
55:                 raise ArgumentError, self.fmsg(*args)
56:             end
57:             return fargs
58:         end

[Source]

    # File lib/rvg/units.rb, line 9
 9:             def dpi=(n)
10:                 if !defined?(@dpi)
11:                     [Float, Fixnum].each do |c|
12:                         c.class_eval "# the default measurement - 1px is 1 pixel\ndef px\nself\nend\n# inches\ndef in\nself * ::Magick::RVG.dpi\nend\n# millimeters\ndef mm\nself * ::Magick::RVG.dpi / 25.4\nend\n# centimeters\ndef cm\nself * ::Magick::RVG.dpi / 2.54\nend\n# points\ndef pt\nself * ::Magick::RVG.dpi / 72.0\nend\n# picas\ndef pc\nself * ::Magick::RVG.dpi / 6.0\nend\n# percentage of the argument\ndef pct(of)\nself * Float(of) / 100.0\nend\n# the default is deg\ndef deg\nself\nend\n# radians -> degrees\ndef rad\nself * 180.0 / Math::PI\nend\n# grads -> degrees\ndef grad\nself * 9.0 / 10.0\nend\n"
13:                     end
14:                 end
15: 
16:                 @dpi = Float(n)
17:                 return @dpi
18:             rescue ArgumentError
19:                 raise TypeError, "Can't convert `#{n}' to Float"
20:             end

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

[Source]

    # File lib/rvg/misc.rb, line 42
42:         def self.fmsg(*args)
43:             "at least one argument cannot be converted to Float (got #{args.collect {|a| a.class}.join(', ')})"
44:         end

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.

[Source]

     # File lib/rvg/rvg.rb, line 216
216:         def initialize(width=nil, height=nil)
217:             super
218:             @width, @height = width, height
219:             @content = Content.new
220:             @canvas = nil
221:             @background_fill = nil
222:             @background_fill_opacity = 1.0  # applies only if background_fill= is used
223:             @background_position = :scaled
224:             @background_pattern, @background_image, @desc, @title, @metadata = nil
225:             @x, @y = 0.0, 0.0
226:             @nested = false
227:             yield(self) if block_given?
228:         end

Public Instance methods

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

[Source]

     # File lib/rvg/rvg.rb, line 174
174:         def background_fill=(color)
175:             warn "background_fill= has no effect in nested RVG objects" if @nested
176:             if ! color.kind_of?(Magick::Pixel)
177:                 begin
178:                     @background_fill = Magick::Pixel.from_color(color)
179:                 rescue Magick::ImageMagickError
180:                     raise ArgumentError, "unknown color `#{color}'"
181:                 rescue TypeError
182:                     raise TypeError, "cannot convert #{color.class} into Pixel"
183:                 rescue
184:                     raise ArgumentError, "argument must be a color name or a Pixel (got #{color.class})"
185:                 end
186:             else
187:                 @background_fill = color
188:             end
189:         end

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.

[Source]

     # File lib/rvg/rvg.rb, line 193
193:         def background_fill_opacity=(opacity)
194:             warn "background_fill_opacity= has no effect in nested RVG objects" if @nested
195:             begin
196:                 @background_fill_opacity = Float(opacity)
197:             rescue ArgumentError
198:                 raise ArgumentError, "background_fill_opacity must be a number between 0 and 1 (#{opacity} given)"
199:             end
200:         end

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

[Source]

     # File lib/rvg/rvg.rb, line 141
141:         def background_image=(bg_image)
142:             warn "background_image= has no effect in nested RVG objects" if @nested
143:             if bg_image && ! bg_image.kind_of?(Magick::Image)
144:                 raise ArgumentError, "background image must be an Image (got #{bg_image.class})"
145:             end
146:             @background_image = bg_image
147:         end

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.

[Source]

     # File lib/rvg/rvg.rb, line 152
152:         def background_pattern=(filler)
153:             warn "background_pattern= has no effect in nested RVG objects" if @nested
154:             @background_pattern = filler
155:         end

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.

[Source]

     # File lib/rvg/rvg.rb, line 163
163:         def background_position=(pos)
164:             warn "background_position= has no effect in nested RVG objects" if @nested
165:             bg_pos = pos.to_s.downcase
166:             if ! ['scaled', 'tiled', 'fit'].include?(bg_pos)
167:                 raise ArgumentError, "background position must be `scaled', `tiled', or `fit' (#{pos} given)"
168:             end
169:             @background_position = bg_pos.to_sym
170:         end

[Source]

    # File lib/rvg/deep_equal.rb, line 6
 6:                 def deep_equal(other)
 7:                     if self != other
 8:                         puts "#{c.inspect} not equal.\nself:#{self} != other:#{other}"
 9:                         return false
10:                     end
11:                     return true
12:                 end

[Source]

    # File lib/rvg/deep_equal.rb, line 18
18:                 def deep_equal(other)
19:                     ivs = self.instance_variables
20: 
21:                     ivs.each do |iv|
22:                         itv = self.instance_variable_get(iv)
23:                         otv = other.instance_variable_get(iv)
24:                         if itv.respond_to?(:deep_equal)
25:                             if itv.equal?(otv)
26:                                 puts "#{iv} has deep_equal but self.#{iv} and other.#{iv} are the same object."
27:                                 return false
28:                             end
29:                             if !itv.deep_equal(otv)
30:                                 puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
31:                                 return false
32:                             end
33:                         else
34:                             case itv
35:                                 when Float, Symbol, TrueClass, FalseClass, Fixnum, NilClass
36:                                     return false if itv != otv
37:                                 else
38:                                     if itv.equal?(otv)
39:                                         puts "#{iv} is dup-able but self.#{iv} and other.#{iv} are the same object."
40:                                         return false
41:                                     end
42:                                     if itv != otv
43:                                         puts "Not equal.\nself.#{iv}=#{itv.inspect}\nother.#{iv}=#{otv.inspect}"
44:                                         return false
45:                                     end
46:                             end
47:                         end
48:                     end
49: 
50:                     return true
51:                 end

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

[Source]

     # File lib/rvg/rvg.rb, line 232
232:         def draw
233:             raise StandardError, "draw not permitted in nested RVG objects" if @nested
234:             @canvas ||= new_canvas    # allow drawing over existing canvas
235:             gc = Utility::GraphicContext.new
236:             add_outermost_primitives(gc)
237:             pp(self) if ENV['debug_rvg']
238:             print_gc(gc) if ENV['debug_prim']
239:             gc.draw(@canvas)
240:             return @canvas
241:         end

Private Instance methods

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

[Source]

    # File lib/rvg/rvg.rb, line 63
63:         def bgfill()
64:             if @background_fill.nil?
65:                 color = Magick::Pixel.new(0,0,0,Magick::TransparentOpacity)
66:             else
67:                 color = @background_fill
68:                 color.opacity = (1.0 - @background_fill_opacity) * Magick::TransparentOpacity
69:             end
70:             return color
71:         end

[Source]

     # File lib/rvg/rvg.rb, line 73
 73:         def new_canvas
 74:             if @background_pattern
 75:                 canvas = Magick::Image.new(@width, @height, @background_pattern)
 76:             elsif @background_image
 77:                 if @width != @background_image.columns || @height != @background_image.rows
 78:                     canvas = case @background_position
 79:                         when :scaled
 80:                             @background_image.resize(@width, @height)
 81:                         when :tiled
 82:                             Magick::Image.new(@width, @height, Magick::TextureFill.new(@background_image))
 83:                         when :fit
 84:                             width, height = @width, @height
 85:                             bgcolor = bgfill()
 86:                             @background_image.change_geometry(Magick::Geometry.new(width, height)) do |new_cols, new_rows|
 87:                                 bg_image = @background_image.resize(new_cols, new_rows)
 88:                                 if bg_image.columns != width || bg_image.rows != height
 89:                                     bg = Magick::Image.new(width, height) { self.background_color = bgcolor }
 90:                                     bg_image = bg.composite!(bg_image, Magick::CenterGravity, Magick::OverCompositeOp)
 91:                                 end
 92:                                 bg_image
 93:                             end
 94:                     end
 95:                 else
 96:                     canvas = @background_image.copy
 97:                 end
 98:             else
 99:                 bgcolor = bgfill()
100:                 canvas = Magick::Image.new(Integer(@width), Integer(@height)) { self.background_color = bgcolor }
101:             end
102:             canvas[:desc] = @desc if @desc
103:             canvas[:title] = @title if @title
104:             canvas[:metadata] = @metadata if @metadata
105:             return canvas
106:         end

[Source]

     # File lib/rvg/rvg.rb, line 109
109:             def print_gc(gc)
110:                 primitives = gc.inspect.split(/\n/)
111:                 indent = 0
112:                 primitives.each do |cmd|
113:                     indent -= 1 if cmd['pop ']
114:                     print(('   '*indent), cmd, "\n")
115:                     indent += 1 if cmd['push ']
116:                 end
117:             end

[Validate]