text_box method accepts both :width and
:height options. So what happens if the text doesn't fit the
box?
The default behavior is to truncate the text but this can be changed with
the :overflow option. Available modes are
:expand (the box will increase to fit the text) and
:shrink_to_fit (the text font size will be shrunk to fit).
If :shrink_to_fit mode is used with the
:min_font_size option set, the font size will not be reduced
to less than the value provided even if it means truncating some text.
If the :disable_wrap_by_char is set to true
then any text wrapping done while using the :shrink_to_fit
mode will not break up the middle of words.
TEXT
end
example new_page: true do
string = 'This is the sample text used for the text boxes. See how it ' \
'behave with the various overflow options used.'
text string
y_position = cursor - 20
%i[truncate expand shrink_to_fit].each_with_index do |mode, i|
text_box string,
at: [i * 150, y_position],
width: 100,
height: 50,
overflow: mode
end
string = 'If the box is too small for the text, :shrink_to_fit ' \
'can render the text in a really small font size.'
move_down 120
text string
y_position = cursor - 20
[nil, 8, 10, 12].each_with_index do |value, index|
text_box string,
at: [index * 150, y_position],
width: 50,
height: 50,
overflow: :shrink_to_fit,
min_font_size: value
end
end
end
ruby-prawn-2.5.0.orig/manual/text/text_box_extensions.rb 0000664 0000000 0000000 00000002724 14571572164 022205 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Text Box Extensions'
text do
prose <<~TEXT
We've already seen one way of using text boxes with the
text_box method. Turns out this method is just a convenience
for using the Prawn::Text::Box class as it creates a new
object and call render on it.
Knowing that any extensions we add to Prawn::Text::Box will
take effect when we use the text_box method. To add an
extension all we need to do is append the
Prawn::Text::Box.extensions array with a module.
TEXT
end
example new_page: true do
module TriangleBox
def available_width
height + 25
end
end
y_position = cursor
width = 100
height = 100
Prawn::Text::Box.extensions << TriangleBox
stroke_rectangle([0, y_position], width, height)
text_box(
'A' * 100,
at: [0, y_position],
width: width,
height: height,
)
Prawn::Text::Formatted::Box.extensions << TriangleBox
stroke_rectangle([200, y_position], width, height)
formatted_text_box(
[{ text: 'A' * 100, color: '009900' }],
at: [200, y_position],
width: width,
height: height,
)
# Here we clear the extensions array
Prawn::Text::Box.extensions.clear
Prawn::Text::Formatted::Box.extensions.clear
end
end
ruby-prawn-2.5.0.orig/manual/text/text_box_excess.rb 0000664 0000000 0000000 00000002104 14571572164 021270 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Text Box Excess'
text do
prose <<~TEXT
Whenever the text_box method truncates text, this truncated
bit is not lost, it is the method return value and we can take advantage
of that.
We just need to take some precautions.
This example renders as much of the text as will fit in a larger font
inside one text_box and then proceeds to render the remaining text in the
default size in a second text_box.
TEXT
end
example do
string = 'This is the beginning of the text. It will be cut somewhere and ' \
'the rest of the text will proceed to be rendered this time by ' \
'calling another method.' + (' . ' * 50)
y_position = cursor - 20
excess_text = text_box(
string,
width: 300,
height: 50,
overflow: :truncate,
at: [100, y_position],
size: 18,
)
text_box(
excess_text,
width: 300,
at: [100, y_position - 100],
)
end
end
ruby-prawn-2.5.0.orig/manual/text/single_usage.rb 0000664 0000000 0000000 00000002467 14571572164 020543 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Single Usage Fonts'
text do
prose <<~TEXT
The PDF format has some built-in font support. If you want to use other
fonts in Prawn you need to embed the font file.
Doing this for a single font is extremely simple. Remember the Styling
font example? Another use of the font method is to provide a
font file path and the font will be embedded in the document and set as
the current font.
This is reasonable if a font is used only once, but, if a font used
several times, providing the path each time it is used becomes
cumbersome. The example on the next page shows a better way to deal with
fonts which are used several times in a document.
TEXT
end
example do
# Using a TTF font file
font("#{Prawn::ManualBuilder::DATADIR}/fonts/DejaVuSans.ttf") do
text 'Written with the DejaVu Sans TTF font.'
end
move_down 20
text 'Written with the default font.'
move_down 20
# Using an DFONT font file
font("#{Prawn::ManualBuilder::DATADIR}/fonts/Panic+Sans.dfont") do
text 'Written with the Panic Sans DFONT font'
end
move_down 20
text 'Written with the default font once more.'
end
end
ruby-prawn-2.5.0.orig/manual/text/rotation.rb 0000664 0000000 0000000 00000002774 14571572164 017736 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Rotation'
text do
prose <<~TEXT
Rotating text is best avoided on free flowing text, so this example
will only use the text_box method as we can have much more
control over its output.
To rotate text all we need to do is use the :rotate option
passing an angle in degrees and an optional :rotate_around
to indicate the origin of the rotation (the default is
:upper_left).
TEXT
end
example new_page: true do
width = 100
height = 60
angle = 30
x = 200
y = cursor - 30
stroke_rectangle [0, y], width, height
text_box(
'This text was not rotated',
at: [0, y],
width: width,
height: height,
)
stroke_rectangle [0, y - 100], width, height
text_box(
'This text was rotated around the center',
at: [0, y - 100],
width: width,
height: height,
rotate: angle,
rotate_around: :center,
)
%i[lower_left upper_left lower_right upper_right].each_with_index do |corner, index|
y -= 100 if index == 2
stroke_rectangle [x + ((index % 2) * 200), y], width, height
text_box(
"This text was rotated around the #{corner} corner.",
at: [x + ((index % 2) * 200), y],
width: width,
height: height,
rotate: angle,
rotate_around: corner,
)
end
end
end
ruby-prawn-2.5.0.orig/manual/text/right_to_left_text.rb 0000664 0000000 0000000 00000004626 14571572164 021772 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Right-to-Left Text'
text do
prose <<~TEXT
Prawn can be used with right-to-left text. The direction can be set
document-wide, on particular text, or on a text-box. Setting the
direction to :rtl automatically changes the default
alignment to :right.
You can even override direction on an individual fragment. The one caveat
is that two fragments going against the main direction cannot be placed
next to each other without appearing in the wrong order.
Writing bidirectional text that combines both left-to-right and
right-to-left languages is easy using the bidi Ruby Gem and
its render_visual function. See
https://github.com/elad/ruby-bidi for instructions and an example using Prawn.
TEXT
end
example new_page: true do
# set the direction document-wide
self.text_direction = :rtl
font("#{Prawn::ManualBuilder::DATADIR}/fonts/Jigmo.ttf", size: 16) do
long_text = '写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事写个小爬虫把你的页面上的' \
'关键信息顺次爬下来也不是什么难事写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事写' \
'个小'
text long_text
move_down 20
text 'You can override the document direction.', direction: :ltr
move_down 20
formatted_text [
{ text: '更可怕的是，同质化竞争对手可以按照' },
{ text: 'URL', direction: :ltr },
{ text: '中后面这个' },
{ text: 'ID', direction: :ltr },
{ text: '来遍历您的' },
{ text: 'DB', direction: :ltr },
{
text: '中的内容、写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事、这样的话、' \
'你就非常被动了。',
},
]
move_down 20
formatted_text [
{ text: '更可怕的是、同质化竞争对手可以按照' },
{ text: 'this', direction: :ltr },
{ text: "won't", direction: :ltr, size: 24 },
{ text: 'work', direction: :ltr },
{ text: '中的内容、写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事' },
]
end
end
end
ruby-prawn-2.5.0.orig/manual/text/rendering_and_color.rb 0000664 0000000 0000000 00000002340 14571572164 022061 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Text Rendering Modes'
text do
prose <<~TEXT
You have already seen how to set the text color using both inline
formatting and the format text methods. There is another way by using the
graphics methods fill_color and stroke_color.
When reading the graphics reference you learned about fill and stroke. If
you haven't read it before, read it now before continuing.
Text can be rendered by being filled (the default mode) or just stroked,
or both filled and stroked. This can be set using the
text_rendering_mode method or the :mode option
on the text methods.
TEXT
end
example do
fill_color '00ff00'
stroke_color '0000ff'
font_size(40) do
# normal rendering mode: fill
text 'This text is filled with green.'
# inline rendering mode: stroke
text 'This text is stroked with blue', mode: :stroke
# block rendering mode: fill and stroke
text_rendering_mode(:fill_stroke) do
text 'This text is filled with green and stroked with blue'
end
end
end
end
ruby-prawn-2.5.0.orig/manual/text/registering_families.rb 0000664 0000000 0000000 00000003273 14571572164 022265 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Registering Font Families'
text do
prose <<~TEXT
Registering font families will help you when you want to use a font over
and over or if you would like to take advantage of the :style
option of the text methods and the b and i tags
when using inline formatting.
To register a font family update the font_families hash with
the font path for each style you want to use.
TEXT
end
example new_page: true do
# Registering a single external font
font_families.update(
'DejaVu Sans' => {
normal: "#{Prawn::ManualBuilder::DATADIR}/fonts/DejaVuSans.ttf",
},
)
font('DejaVu Sans') do
text 'Using the DejaVu Sans font providing only its name to the font method'
end
move_down 20
# Registering a DFONT package
font_path = "#{Prawn::ManualBuilder::DATADIR}/fonts/Panic+Sans.dfont"
font_families.update(
'Panic Sans' => {
normal: { file: font_path, font: 'PanicSans' },
italic: { file: font_path, font: 'PanicSans-Italic' },
bold: { file: font_path, font: 'PanicSans-Bold' },
bold_italic: { file: font_path, font: 'PanicSans-BoldItalic' },
},
)
font 'Panic Sans'
text 'Also using Panic Sans by providing only its name'
move_down 20
text 'Taking advantage of the inline formatting',
inline_format: true
move_down 20
%i[bold bold_italic italic normal].each do |style|
text "Using the #{style} style option.", style: style
move_down 10
end
end
end
ruby-prawn-2.5.0.orig/manual/text/positioned_text.rb 0000664 0000000 0000000 00000003050 14571572164 021304 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Positioned Text'
text do
prose <<~TEXT
Sometimes we want the text on a specific position on the page. The
text method just won't help us.
There are two other methods for this task: draw_text and
text_box.
draw_text is very simple. It will render text starting at
the position provided to the :at option. It won't flow to a
new line even if it hits the document boundaries so it is best suited for
short text.
text_box gives us much more control over the output. Just
provide :width and :height options and the text
will flow accordingly. Even if you don't provide a :width
option the text will flow to a new line if it reaches the right border.
Given that, text_box is the better option available.
TEXT
end
example do
draw_text "This draw_text line is absolute positioned. However don't " \
'expect it to flow even if it hits the document border',
at: [200, 170]
text_box 'This is a text box, you can control where it will flow by ' \
'specifying the :height and :width options',
at: [50, 150],
height: 100,
width: 100
text_box 'Another text box with no :width option passed, so it will ' \
'flow to a new line whenever it reaches the right margin. ',
at: [200, 100]
end
end
ruby-prawn-2.5.0.orig/manual/text/paragraph_indentation.rb 0000664 0000000 0000000 00000002203 14571572164 022423 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Paragraph Indentation'
text do
prose <<~TEXT
Prawn strips all whitespace from the beginning and the end of strings so
there are two ways to indent paragraphs:
One is to use non-breaking spaces which Prawn won't strip. One shortcut
to using them is the Prawn::Text::NBSP.
The other is to use the :indent_paragraphs option with the
text methods. Just pass a number with the space to indent the first line
in each paragraph.
TEXT
end
example new_page: true do
# Using non-breaking spaces
text (' ' * 10) + ("This paragraph won't be indented. " * 10) +
"\n#{Prawn::Text::NBSP * 10}" + ('This one will with NBSP. ' * 10)
move_down 20
text "#{'This paragraph will be indented. ' * 10}\n#{'This one will too. ' * 10}",
indent_paragraphs: 60
move_down 20
text 'FROM RIGHT TO LEFT:'
text "#{'This paragraph will be indented. ' * 10}\n#{'This one will too. ' * 10}",
indent_paragraphs: 60,
direction: :rtl
end
end
ruby-prawn-2.5.0.orig/manual/text/line_wrapping.rb 0000664 0000000 0000000 00000006146 14571572164 020732 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Line Wrapping'
text do
prose <<~TEXT
Line wrapping happens on white space or hyphens. Soft hyphens can be used
to indicate where words can be hyphenated. Non-breaking spaces can be
used to display space without allowing for a break.
For writing styles that do not make use of spaces, the zero width space
serves to mark word boundaries. Zero width spaces are available only with
external fonts.
TEXT
end
example new_page: true do
text "Hard hyphens:\n" \
'Slip-sliding away, slip sliding awaaaay. You know the ' \
"nearer your destination the more you're slip-sliding away."
move_down 20
shy = Prawn::Text::SHY
text "Soft hyphens:\n" \
"Slip slid#{shy}ing away, slip slid#{shy}ing away. You know the " \
"nearer your destinat#{shy}ion the more you're slip slid#{shy}ing away."
move_down 20
nbsp = Prawn::Text::NBSP
text "Non-breaking spaces:\n" \
"Slip#{nbsp}sliding away, slip#{nbsp}sliding awaaaay. You know the " \
"nearer your destination the more you're slip#{nbsp}sliding away."
move_down 20
font_families.update('Jigmo' => { normal: "#{Prawn::ManualBuilder::DATADIR}/fonts/Jigmo.ttf" })
font('Jigmo', size: 16) do
text "No word boundaries:\n更可怕的是、同质化竞争对手可以按照URL中后面这个ID来遍历" \
'您的DB中的内容、写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事、这样的话、' \
'你就非常被动了。更可怕的是，同质化竞争对手可以按照URL中后面这个ID来遍历您的DB中的内容、' \
'写个小爬虫把你的页面上的关键信息顺次爬下来也不是什么难事、这样的话、你就非常被动了。'
move_down 20
zwsp = Prawn::Text::ZWSP
text "Invisible word boundaries:\n更#{zwsp}可怕的#{zwsp}是、#{zwsp}同质化#{zwsp}竞争" \
"#{zwsp}对#{zwsp}手#{zwsp}可以#{zwsp}按照#{zwsp}URL#{zwsp}中#{zwsp}后面#{zwsp}这个" \
"#{zwsp}ID#{zwsp}来#{zwsp}遍历#{zwsp}您的#{zwsp}DB#{zwsp}中的#{zwsp}内容、#{zwsp}写个" \
"#{zwsp}小爬虫#{zwsp}把#{zwsp}你的#{zwsp}页面#{zwsp}上的#{zwsp}关#{zwsp}键#{zwsp}信" \
"#{zwsp}息顺#{zwsp}次#{zwsp}爬#{zwsp}下来#{zwsp}也#{zwsp}不是#{zwsp}什么#{zwsp}难事、" \
"#{zwsp}这样的话，#{zwsp}你#{zwsp}就#{zwsp}非常#{zwsp}被动了。#{zwsp}更#{zwsp}可怕的" \
"#{zwsp}是、#{zwsp}同质化#{zwsp}竞争#{zwsp}对#{zwsp}手#{zwsp}可以#{zwsp}按照#{zwsp}URL" \
"#{zwsp}中#{zwsp}后面#{zwsp}这个#{zwsp}ID#{zwsp}来#{zwsp}遍历#{zwsp}您的#{zwsp}DB#{zwsp}" \
"中的#{zwsp}内容、#{zwsp}写个#{zwsp}小爬虫#{zwsp}把#{zwsp}你的#{zwsp}页面#{zwsp}上的" \
"#{zwsp}关#{zwsp}键#{zwsp}信#{zwsp}息顺#{zwsp}次#{zwsp}爬#{zwsp}下来#{zwsp}也#{zwsp}不是" \
"#{zwsp}什么#{zwsp}难事、#{zwsp}这样的话、#{zwsp}你#{zwsp}就#{zwsp}非常#{zwsp}被动了。"
end
end
end
ruby-prawn-2.5.0.orig/manual/text/leading.rb 0000664 0000000 0000000 00000001321 14571572164 017465 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Leading'
text do
prose <<~TEXT
Leading is the additional space between lines of text.
The leading can be set using the default_leading method
which applies to the rest of the document or until it is changed, or
inline in the text methods with the :leading option.
The default leading is 0.
TEXT
end
example do
string = 'Hey, what did you do with the space between my lines? ' * 8
text string, leading: 0
move_down 20
default_leading 5
text string
move_down 20
text string, leading: 10
end
end
ruby-prawn-2.5.0.orig/manual/text/kerning_and_character_spacing.rb 0000664 0000000 0000000 00000002761 14571572164 024072 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Kerning and Character Spacing'
text do
prose <<~TEXT
Kerning is the process of adjusting the spacing between characters in a
proportional font. It is usually done with specific letter pairs. We can
switch it on and off if it is available with the current font. Just pass
a boolean value to the :kerning option of the text methods.
Character Spacing is the space between characters. It can be increased or
decreased and will have effect on the whole text. Just pass a number to
the :character_spacing option from the text methods.
TEXT
end
example new_page: true do
font_size(30) do
text_box 'With kerning:', kerning: true, at: [0, y - 40]
text_box 'Without kerning:', kerning: false, at: [0, y - 80]
text_box 'Tomato', kerning: true, at: [230, y - 40]
text_box 'Tomato', kerning: false, at: [230, y - 80]
text_box 'WAR', kerning: true, at: [360, y - 40]
text_box 'WAR', kerning: false, at: [360, y - 80]
text_box 'F.', kerning: true, at: [470, y - 40]
text_box 'F.', kerning: false, at: [470, y - 80]
end
move_down 80
string = 'What have you done to the space between the characters?'
[-2, -1, 0, 0.5, 1, 2].each do |spacing|
move_down 20
text "#{string} (character_spacing: #{spacing})",
character_spacing: spacing
end
end
end
ruby-prawn-2.5.0.orig/manual/text/inline.rb 0000664 0000000 0000000 00000003212 14571572164 017341 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Inline Formatting'
text do
prose <<~TEXT
Inline formatting gives you the option to format specific portions of a
text. It uses HTML-esque syntax inside the text string. Supported tags
are: b (bold), i (italic), u
(underline), strikethrough, sub (subscript),
sup (superscript).
The following tags accept specific attributes: font accepts
size, name, and character_spacing;
color accepts rgb and set of c,
m, y, and k;
link accepts href for external links.
TEXT
end
example do
%w[b i u strikethrough sub sup].each do |tag|
text "Just your regular text <#{tag}>except this portion " \
"is using the #{tag} tag",
inline_format: true
# move_down 10
end
text "This line uses " \
"all the font tag attributes in " \
"a single line. ",
inline_format: true
# move_down 10
text "Coloring in text. It is meant
for free flowing text. The provided string will flow according to the
current bounding box width and height. It will also flow onto the next
page if the bottom of the bounding box is reached.
The text will start being rendered on the current cursor position. When
it finishes rendering, the cursor is left directly below the text.
This example also shows text flowing across pages following the margin
box and other bounding boxes.
TEXT
end
example do
text 'This text will flow to the next page. ' * 20
y_position = cursor
bounding_box([0, y_position], width: 200, height: 150) do
transparent(0.5) { stroke_bounds }
text 'This text will flow along this bounding box we created for it. ' * 5
end
bounding_box([300, y_position], width: 200, height: 150) do
transparent(0.5) { stroke_bounds } # This will stroke on one page
text 'Now look what happens when the free flowing text reaches the end of a bounding box ' \
"that is narrower than the margin box.#{' . ' * 200}It continues on the next page as if " \
'the previous bounding box was cloned. If we want it to have the same border as the one on ' \
'the previous page we will need to stroke the boundaries again.'
transparent(0.5) { stroke_bounds } # And this will stroke on the next
end
move_cursor_to 200
span(350, position: :center) do
text 'Span is a different kind of bounding box as it lets the text flow gracefully onto the ' \
"next page. It doesn't matter if the text started on the middle of the previous page, when " \
"it flows to the next page it will start at the beginning.#{' _ ' * 500}" \
'I told you it would start on the beginning of this page.'
end
end
end
ruby-prawn-2.5.0.orig/manual/text/formatted_text.rb 0000664 0000000 0000000 00000004542 14571572164 021123 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Formatted Text'
text do
prose <<~TEXT
There are two other text methods available: formatted_text
and formatted_text_box.
These are useful when the provided text has numerous portions that need
to be formatted differently. As you might imply from their names the
first should be used for free flowing text just like the
text method and the last should be used for positioned text
just like text_box.
The main difference between these methods and the text and
text_box methods is how the text is provided. The
formatted_text and formatted_text_box methods
accept an array of hashes. Each hash must provide a :text
option which is the text string and may provide the following options:
:styles (an array of symbols), :size (the font
size), :character_spacing (additional space between the
characters), :font (the name of a registered font),
:color (the same input accepted by fill_color
and stroke_color), :link (an URL to create a
link), and :local (a link to a local file).
TEXT
end
example new_page: true do
formatted_text [
{ text: 'Some bold. ', styles: [:bold] },
{ text: 'Some italic. ', styles: [:italic] },
{ text: 'Bold italic. ', styles: %i[bold italic] },
{ text: 'Bigger Text. ', size: 20 },
{ text: 'More spacing. ', character_spacing: 3 },
{ text: 'Different Font. ', font: 'Courier' },
{ text: 'Some coloring. ', color: 'FF00FF' },
{ text: 'Link to the home page. ', color: '0000FF', link: 'https://prawnpdf.org/' },
{ text: 'Link to a local file. ', color: '0000FF', local: 'README.md' },
]
formatted_text_box(
[
{ text: 'Just your regular' },
{ text: ' text_box ', font: 'Courier' },
{
text: 'with some additional formatting options added to the mix.',
color: [50, 100, 0, 0],
styles: [:italic],
},
],
at: [100, 100],
width: 200,
height: 100,
)
end
end
ruby-prawn-2.5.0.orig/manual/text/formatted_callbacks.rb 0000664 0000000 0000000 00000003643 14571572164 022057 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Formatted Text Callbacks'
text do
prose <<~TEXT
The :callback option is also available for the formatted
text methods.
This option accepts an object (or array of objects) on which two methods
will be called if defined: render_behind and
render_in_front. They are called before and after rendering
the text fragment and are passed the fragment as an argument.
This example defines two new callback classes and provide callback
objects for the formatted_text.
TEXT
end
example new_page: true do
class HighlightCallback
def initialize(options)
@color, @document = options.values_at(:color, :document)
end
def render_behind(fragment)
original_color = @document.fill_color
@document.fill_color = @color
@document.fill_rectangle(fragment.top_left, fragment.width, fragment.height)
@document.fill_color = original_color
end
end
class ConnectedBorderCallback
def initialize(options)
@radius, @document = options.values_at(:radius, :document)
end
def render_in_front(fragment)
points = [fragment.top_left, fragment.top_right, fragment.bottom_right, fragment.bottom_left]
@document.stroke_polygon(*points)
points.each { |point| @document.fill_circle(point, @radius) }
end
end
highlight = HighlightCallback.new(color: 'ffff00', document: self)
border = ConnectedBorderCallback.new(radius: 2.5, document: self)
formatted_text(
[
{ text: 'hello', callback: highlight },
{ text: ' ' },
{ text: 'world', callback: border },
{ text: ' ' },
{ text: 'hello world', callback: [highlight, border] },
],
size: 20,
)
end
end
ruby-prawn-2.5.0.orig/manual/text/font_style.rb 0000664 0000000 0000000 00000001526 14571572164 020257 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Font Style'
text do
prose <<~TEXT
Most font families come with some styles other than normal. Most common
are bold, italic and bold_italic.
The style can be set the using the :style option, with
either the font method which will set the font and style for
rest of the document, or with the inline text methods.
TEXT
end
example do
fonts = %w[Courier Helvetica Times-Roman]
styles = %i[bold bold_italic italic normal]
fonts.each do |example_font|
move_down 20
styles.each do |style|
font example_font, style: style
text "I'm writing in #{example_font} (#{style})"
end
end
end
end
ruby-prawn-2.5.0.orig/manual/text/font_size.rb 0000664 0000000 0000000 00000002006 14571572164 020063 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Font Size'
text do
prose <<~TEXT
The font_size method works just like the font
method.
In fact we can even use font with the :size
option to declare which size we want.
Another way to change the font size is by supplying the
:size option to the text methods.
The default font size is 12.
TEXT
end
example do
text "Let's see which is the current font_size: #{font_size.inspect}"
font_size 16
text 'Yeah, something bigger!'
font_size(25) { text 'Even bigger!' }
text 'Back to 16 again.'
text 'Single line on 20 using the :size option.', size: 20
text 'Back to 16 once more.'
font('Courier', size: 10) do
text 'Yeah, using Courier 10 courtesy of the font method.'
end
font('Helvetica', size: 12)
text 'Back to normal'
end
end
ruby-prawn-2.5.0.orig/manual/text/font.rb 0000664 0000000 0000000 00000002053 14571572164 017033 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Fonts'
text do
prose <<~TEXT
The font method can be used in three different ways.
If we don't pass it any arguments it will return the current font being
used to render text.
If we just pass it a font name it will use that font for rendering text
through the rest of the document.
It can also be used by passing a font name and a block. In this case the
specified font will only be used to render text inside the block.
The default font is Helvetica.
TEXT
end
example do
text "Let's see which font we are using: #{font.inspect}"
font 'Times-Roman'
text 'Written in Times.'
font('Courier') do
text 'Written in Courier because we are inside the block.'
end
text 'Written in Times again as we left the previous block.'
text "Let's see which font we are using again: #{font.inspect}"
font 'Helvetica'
text 'Back to normal.'
end
end
ruby-prawn-2.5.0.orig/manual/text/fallback_fonts.rb 0000664 0000000 0000000 00000002614 14571572164 021040 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Fallback Fonts'
text do
prose <<~TEXT
Prawn enables the declaration of fallback fonts for those glyphs that may
not be present in the desired font. Use the :fallback_fonts
option with any of the text or text box methods, or set fallback_fonts
document-wide.
TEXT
end
example do
jigmo_file = "#{Prawn::ManualBuilder::DATADIR}/fonts/Jigmo.ttf"
font_families['Jigmo'] = { normal: { file: jigmo_file, font: 'Jigmo' } }
panic_sans_file = "#{Prawn::ManualBuilder::DATADIR}/fonts/Panic+Sans.dfont"
font_families['Panic Sans'] = { normal: { file: panic_sans_file, font: 'PanicSans' } }
font('Panic Sans') do
text(
'When fallback fonts are included, each glyph will be rendered ' \
'using the first font that includes the glyph, starting with the ' \
'current font and then moving through the fallback fonts from left ' \
'to right.' \
"\n\n" \
"hello ƒ 你好\n再见 ƒ goodbye",
fallback_fonts: %w[Times-Roman Jigmo],
)
end
move_down 20
formatted_text(
[
{ text: 'Fallback fonts can even override' },
{ text: 'fragment fonts (你好)', font: 'Times-Roman' },
],
fallback_fonts: %w[Times-Roman Jigmo],
)
end
end
ruby-prawn-2.5.0.orig/manual/text/column_box.rb 0000664 0000000 0000000 00000002746 14571572164 020243 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Column Box'
text do
prose <<~TEXT
The column_box method allows you to define columns that flow
their contents from one section to the next. You can have a number of
columns on the page, and only when the last column overflows will a new
page be created.
TEXT
end
example new_page: true do
move_down 30
text 'The Prince', align: :center, size: 18
text 'Niccolò Machiavelli', align: :center, size: 14
move_down 30
column_box([0, cursor], columns: 2, width: bounds.width) do
text("#{<<~TEXT.gsub(/\s+/, ' ')}\n\n" * 5)
All the States and Governments by which men are or ever have been ruled,
have been and are either Republics or Princedoms. Princedoms are either
hereditary, in which the sovereignty is derived through an ancient line
of ancestors, or they are new. New Princedoms are either wholly new, as
that of Milan to Francesco Sforza; or they are like limbs joined on to
the hereditary possessions of the Prince who acquires them, as the
Kingdom of Naples to the dominions of the King of Spain. The States thus
acquired have either been used to live under a Prince or have been free;
and he who acquires them does so either by his own arms or by the arms of
others, and either by good fortune or by merit.
TEXT
end
end
end
ruby-prawn-2.5.0.orig/manual/text/color.rb 0000664 0000000 0000000 00000001156 14571572164 017206 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Color'
text do
prose <<~TEXT
The :color attribute can give a block of text a default
color, in RGB hex format or 4-value CMYK.
TEXT
end
example do
text 'Default color is black'
move_down 25
text 'Changed to red', color: 'FF0000'
move_down 25
text 'CMYK color', color: [22, 55, 79, 30]
move_down 25
text(
"Also works with :align option to the text methods. Available options are
:left (default), :right, :center,
and :justify.
Vertical text alignment can be achieved using the :valign
option with the text methods. Available options are :top
(default), :center, and :bottom.
Both forms of alignment will be evaluated in the context of the current
bounding_box.
TEXT
end
example new_page: true do
text 'This text should be left aligned'
text 'This text should be centered', align: :center
text 'This text should be right aligned', align: :right
y = cursor - 20
bounding_box([0, y], width: 250, height: 220) do
text 'This text is flowing from the left. ' * 4
move_down 15
text 'This text is flowing from the center. ' * 3, align: :center
move_down 15
text 'This text is flowing from the right. ' * 4, align: :right
move_down 15
text 'This text is justified. ' * 6, align: :justify
transparent(0.5) { stroke_bounds }
end
bounding_box([270, y], width: 250, height: 220) do
text 'This text should be vertically top aligned'
text 'This text should be vertically centered', valign: :center
text 'This text should be vertically bottom aligned', valign: :bottom
transparent(0.5) { stroke_bounds }
end
end
end
ruby-prawn-2.5.0.orig/manual/text.rb 0000664 0000000 0000000 00000002331 14571572164 016064 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Text')
prose <<-TEXT
This is probably the feature people will use the most. There is no
shortage of options when it comes to text. You'll be hard pressed to
find a use case that is not covered by one of the text methods and
configurable options.
The examples show:
TEXT
list(
'Text that flows from page to page automatically starting new pages when necessary',
'How to use text boxes and place them on specific positions',
'What to do when a text box is too small to fit its content',
'Flowing text in columns',
'How to change the text style configuring font, size, alignment and many other settings',
'How to style specific portions of a text with inline styling and formatted text',
'How to define formatted callbacks to reuse common styling definitions',
'How to use the different rendering modes available for the text methods',
'How to create your custom text box extensions',
'How to use external fonts on your pdfs',
'What happens when rendering text in different languages',
)
end
end
ruby-prawn-2.5.0.orig/manual/table.rb 0000664 0000000 0000000 00000000542 14571572164 016171 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Prawn::Table'
text do
prose <<~TEXT
As of Prawn 1.2.0, Prawn::Table has been extracted into its own
semi-officially supported gem.
Please see https://github.com/prawnpdf/prawn-table for more details.
TEXT
end
end
ruby-prawn-2.5.0.orig/manual/security/ 0000775 0000000 0000000 00000000000 14571572164 016423 5 ustar root root ruby-prawn-2.5.0.orig/manual/security/permissions.rb 0000664 0000000 0000000 00000003517 14571572164 021331 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Permissions'
text do
prose <<~TEXT
Some permissions may be set for the regular user with the following
options: :print_document, :modify_contents,
:copy_contents, :modify_annotations. All this
options default to true, so if you'd like to revoke just set
them to false.
A user may bypass all permissions if he provides the owner password which
may be set with the :owner_password option. This option may
be set to :random so that users will never be able to bypass
permissions.
There are some caveats when encrypting your PDFs. Be sure to read the source
documentation (you can find it here:
https://github.com/prawnpdf/prawn/blob/master/lib/prawn/security.rb\u200B)
before using this for anything super serious.
TEXT
end
example eval: false, standalone: true do
# User cannot print the document.
Prawn::Document.generate('cannot_print.pdf') do
text "If you used the user password you won't be able to print the doc."
encrypt_document(
user_password: 'foo',
owner_password: 'bar',
permissions: { print_document: false },
)
end
# All permissions revoked and owner password set to random
Prawn::Document.generate('no_permissions.pdf') do
text "You may only view this and won't be able to use the owner password."
encrypt_document(
user_password: 'foo',
owner_password: :random,
permissions: {
print_document: false,
modify_contents: false,
copy_contents: false,
modify_annotations: false,
},
)
end
end
end
ruby-prawn-2.5.0.orig/manual/security/encryption.rb 0000664 0000000 0000000 00000002516 14571572164 021146 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Encryption'
text do
prose <<~TEXT
The encrypt_document method, as you might have already
guessed, is used to encrypt the PDF document.
Once encrypted whoever is using the document will need the user password
to read the document. This password can be set with the
:user_password option. If this is not set the document will
be encrypted but a password will not be needed to read the document.
There are some caveats when encrypting your PDFs. Be sure to read the
source documentation (you can find it here:
https://github.com/prawnpdf/prawn/blob/master/lib/prawn/security.rb\u200B)
before using this for anything super serious.
TEXT
end
example eval: false, standalone: true do
# Bare encryption. No password needed.
Prawn::ManualBuilder::Example.generate('bare_encryption.pdf') do
text 'See, no password was asked but the document is still encrypted.'
encrypt_document
end
# Simple password. All permissions granted.
Prawn::ManualBuilder::Example.generate('simple_password.pdf') do
text 'You was asked for a password.'
encrypt_document(user_password: 'foo', owner_password: 'bar')
end
end
end
ruby-prawn-2.5.0.orig/manual/security.rb 0000664 0000000 0000000 00000001070 14571572164 016746 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Security')
prose <<-TEXT
Security lets you control who can read the document by defining
a password.
The examples include:
TEXT
list(
'How to encrypt the document without the need for a password',
'How to configure the regular user permissions',
'How to require a password for the regular user',
'How to set a owner password that bypass the document permissions',
)
end
end
ruby-prawn-2.5.0.orig/manual/repeatable_content/ 0000775 0000000 0000000 00000000000 14571572164 020412 5 ustar root root ruby-prawn-2.5.0.orig/manual/repeatable_content/stamp.rb 0000664 0000000 0000000 00000002607 14571572164 022070 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stamp'
text do
prose <<~TEXT
Stamps should be used when you have content that will be included
multiple times in a document. Its advantages over creating the content
anew each time are:
TEXT
ordered_list(
'Faster document creation',
'Smaller final document',
'Faster display on subsequent displays of the repeated element because ' \
'the viewer application can cache the rendered results',
)
prose <<~TEXT
The create_stamp method does just what it says. Pass it a
block with the content that should be generated and the stamp will be
created.
There are two methods to render the stamp on a page stamp
and stamp_at. The first will render the stamp as is while
the second accepts a point to serve as an offset to the stamp content.
TEXT
end
example do
create_stamp('approved') do
rotate(30, origin: [-5, -5]) do
stroke_color 'FF3333'
stroke_ellipse [0, 0], 29, 15
stroke_color '000000'
fill_color '993333'
font('Times-Roman') do
draw_text 'Approved', at: [-23, -3]
end
fill_color '000000'
end
end
stamp 'approved'
stamp_at 'approved', [200, 100]
end
end
ruby-prawn-2.5.0.orig/manual/repeatable_content/repeater.rb 0000664 0000000 0000000 00000003140 14571572164 022544 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Repeater'
text do
prose <<~TEXT
The repeat method is quite versatile when it comes to define
the intervals at which the content block should repeat.
The interval may be a symbol (:all, :odd,
:even), an array listing the pages, a range or a
Proc that receives the page number as an argument and should
return true if the content is to be repeated on the given page.
You may also pass an option :dynamic to reevaluate the code
block on every call which is useful when the content changes based on the
page number.
It is also important to say that no matter where you define the repeater
it will be applied to all matching pages.
TEXT
end
example eval: false do
repeat(:all) do
draw_text 'All pages', at: bounds.top_left
end
repeat(:odd) do
draw_text 'Only odd pages', at: [0, 0]
end
repeat(:even) do
draw_text 'Only even pages', at: [0, 0]
end
repeat([1, 3, 7]) do
draw_text 'Only on pages 1, 3 and 7', at: [100, 0]
end
repeat(2..4) do
draw_text 'From the 2nd to the 4th page', at: [300, 0]
end
repeat(->(pg) { (pg % 3).zero? }) do
draw_text 'Every third page', at: [250, 20]
end
repeat(:all, dynamic: true) do
draw_text page_number, at: [500, 0]
end
10.times do
start_new_page
draw_text 'A wonderful page', at: [400, 400]
end
end
end
ruby-prawn-2.5.0.orig/manual/repeatable_content/page_numbering.rb 0000664 0000000 0000000 00000003567 14571572164 023734 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Page Numbering'
text do
prose <<~TEXT
The number_pages method is a simple way to number the pages
of your document. It should be called towards the end of the document
since pages created after the call won't be numbered.
It accepts a string and a hash of options:
TEXT
list(
'start_count_at is the value from which to start numbering pages',
'total_pages If provided, will replace total ' \
'with the value given. Useful for overriding the total number of pages ' \
'when using the start_count_at option.',
'page_filter, which is one of: :all, ' \
':odd, :even, an array, a range, or a Proc that ' \
'receives the page number as an argument and should return true if the page ' \
'number should be printed on that page.',
'color which accepts the same values as fill_color',
'As well as any option accepted by text_box',
)
end
example eval: false do
text 'This is the first page!'
10.times do
start_new_page
text 'Here comes yet another page.'
end
string = 'page outline
method to lazily instantiate an outline object. Then we use the
define method with a block to start the outline tree.
The basic methods for creating outline nodes are section and
page. The only difference between the two is that
page doesn't accept a block and will only create leaf nodes
while section accepts a block to create nested nodes.
section accepts the title of the section and two options:
:destination - a page number to link and
:closed - a boolean value that defines if the nested outline
nodes are shown when the document is open (defaults to true).
page is very similar to section. It requires a
:title option to be set and accepts a
:destination.
section and page may also be used without the
define method but they will need to instantiate the
outline object every time.
TEXT
end
example eval: false do
# First we create 10 pages just to have something to link to
(1..10).each do |index|
text "Page #{index}"
start_new_page
end
outline.define do
section('Section 1', destination: 1) do
page title: 'Page 2', destination: 2
page title: 'Page 3', destination: 3
end
section('Section 2', destination: 4) do
page title: 'Page 5', destination: 5
section('Subsection 2.1', destination: 6, closed: true) do
page title: 'Page 7', destination: 7
end
end
end
# Outside of the define block
outline.section('Section 3', destination: 8) do
outline.page(title: 'Page 9', destination: 9)
end
outline.page(title: 'Page 10', destination: 10)
# Section and Pages without links. While a section without a link may be
# useful to group some pages, a page without a link is useless
outline.update do # update is an alias to define
section('Section without link') do
page title: 'Page without link'
end
end
end
end
ruby-prawn-2.5.0.orig/manual/outline/insert_section_after.rb 0000664 0000000 0000000 00000002643 14571572164 022776 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Insert Section After'
text do
prose <<~TEXT
Another way to insert nodes into an existing outline is the
insert_section_after method.
It accepts the title of the node that the new section will go after and a
block declaring the new section.
As is the case with add_subsection_to the section added
doesn't need to be a section, it may be just a page.
TEXT
end
example eval: false do
# First we create 10 pages and some default outline
(1..10).each do |index|
text "Page #{index}"
start_new_page
end
outline.define do
section('Section 1', destination: 1) do
page title: 'Page 2', destination: 2
page title: 'Page 3', destination: 3
end
end
# Now we will start adding nodes to the previous outline
outline.insert_section_after('Page 2') do
outline.section('Section after Page 2') do
outline.page(title: 'Page 4', destination: 4)
end
end
outline.insert_section_after('Section 1') do
outline.section('Section after Section 1') do
outline.page(title: 'Page 5', destination: 5)
end
end
# Adding just a page
outline.insert_section_after('Page 3') do
outline.page(title: 'Page after Page 3', destination: 6)
end
end
end
ruby-prawn-2.5.0.orig/manual/outline/add_subsection_to.rb 0000664 0000000 0000000 00000004076 14571572164 022257 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Adding a Subsection to the Outline Tree'
text do
prose <<~TEXT
We have already seen how to define an outline tree sequentially.
If you'd like to add nodes to the middle of an outline tree the
add_subsection_to may help you.
It allows you to insert sections to the outline tree at any point. Just
provide the title of the parent section, the
position you want the new subsection to be inserted
:first or :last (defaults to
:last) and a block to declare the subsection.
The add_subsection_to block doesn't necessarily create new
sections, it may also create new pages.
If the parent title provided is the title of a page. The page will be
converted into a section to receive the subsection created.
TEXT
end
example eval: false do
# First we create 10 pages and some default outline
(1..10).each do |index|
text "Page #{index}"
start_new_page
end
outline.define do
section('Section 1', destination: 1) do
page title: 'Page 2', destination: 2
page title: 'Page 3', destination: 3
end
end
# Now we will start adding nodes to the previous outline
outline.add_subsection_to('Section 1', :first) do
outline.section('Added later - first position') do
outline.page(title: 'Page 4', destination: 4)
outline.page(title: 'Page 5', destination: 5)
end
end
outline.add_subsection_to('Section 1') do
outline.page(title: 'Added later - last position', destination: 6)
end
outline.add_subsection_to('Added later - first position') do
outline.page(title: 'Another page added later', destination: 7)
end
# The title provided is for a page which will be converted into a section
outline.add_subsection_to('Page 3') do
outline.page(title: 'Last page added', destination: 8)
end
end
end
ruby-prawn-2.5.0.orig/manual/outline.rb 0000664 0000000 0000000 00000000732 14571572164 016562 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Outline')
prose <<-TEXT
The outline of a PDF document is the table of contents tab you see to
the right or left of your PDF viewer.
The examples include:
TEXT
list(
'How to define sections and pages',
'How to insert sections and/or pages to a previously defined outline structure',
)
end
end
ruby-prawn-2.5.0.orig/manual/manual.rb 0000664 0000000 0000000 00000010747 14571572164 016367 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Manual.new(__dir__, page_size: 'A4') do
part 'cover'
part 'how_to_read_this_manual'
# Core chapters
section 'Basic Concepts' do
part 'basic_concepts'
chapter 'basic_concepts/creation'
chapter 'basic_concepts/origin'
chapter 'basic_concepts/cursor'
chapter 'basic_concepts/other_cursor_helpers'
chapter 'basic_concepts/adding_pages'
chapter 'basic_concepts/measurement'
chapter 'basic_concepts/view'
end
section 'Graphics' do
part 'graphics'
section 'Basics' do
chapter 'graphics/helper'
chapter 'graphics/fill_and_stroke'
end
section 'Shapes' do
chapter 'graphics/lines_and_curves'
chapter 'graphics/common_lines'
chapter 'graphics/rectangle'
chapter 'graphics/polygon'
chapter 'graphics/circle_and_ellipse'
end
section 'Fill and Stroke Settings' do
chapter 'graphics/line_width'
chapter 'graphics/stroke_cap'
chapter 'graphics/stroke_join'
chapter 'graphics/stroke_dash'
chapter 'graphics/color'
chapter 'graphics/gradients'
chapter 'graphics/transparency'
chapter 'graphics/soft_masks'
chapter 'graphics/blend_mode'
chapter 'graphics/fill_rules'
end
section 'Transformations' do
chapter 'graphics/rotate'
chapter 'graphics/translate'
chapter 'graphics/scale'
end
end
section 'Text' do
part 'text'
section 'Basics' do
chapter 'text/free_flowing_text'
chapter 'text/positioned_text'
chapter 'text/text_box_overflow'
chapter 'text/text_box_excess'
chapter 'text/column_box'
end
section 'Styling' do
chapter 'text/font'
chapter 'text/font_size'
chapter 'text/font_style'
chapter 'text/color'
chapter 'text/alignment'
chapter 'text/leading'
chapter 'text/kerning_and_character_spacing'
chapter 'text/paragraph_indentation'
chapter 'text/rotation'
end
section 'Advanced Styling' do
chapter 'text/inline'
chapter 'text/formatted_text'
chapter 'text/formatted_callbacks'
chapter 'text/rendering_and_color'
chapter 'text/text_box_extensions'
end
section 'External Fonts' do
chapter 'text/single_usage'
chapter 'text/registering_families'
end
section 'Multilingualization' do
chapter 'text/utf8'
chapter 'text/line_wrapping'
chapter 'text/right_to_left_text'
chapter 'text/fallback_fonts'
chapter 'text/win_ansi_charset'
end
end
section 'Bounding Box' do
part 'bounding_box'
section 'Basics' do
chapter 'bounding_box/creation'
chapter 'bounding_box/bounds'
end
section 'Advanced' do
chapter 'bounding_box/stretchy'
chapter 'bounding_box/nesting'
chapter 'bounding_box/indentation'
chapter 'bounding_box/canvas'
chapter 'bounding_box/recursive_boxes'
end
end
# Remaining chapters
section 'Layout' do
part 'layout'
chapter 'layout/simple_grid'
chapter 'layout/boxes'
chapter 'layout/content'
end
chapter 'table'
section 'Images' do
part 'images'
section 'Basics' do
chapter 'images/plain_image'
chapter 'images/absolute_position'
end
section 'Relative Positioning' do
chapter 'images/horizontal'
chapter 'images/vertical'
end
section 'Size' do
chapter 'images/width_and_height'
chapter 'images/scale'
chapter 'images/fit'
end
end
section 'Document and Page Options' do
part 'document_and_page_options'
chapter 'document_and_page_options/page_size'
chapter 'document_and_page_options/page_margins'
chapter 'document_and_page_options/background'
chapter 'document_and_page_options/metadata'
chapter 'document_and_page_options/print_scaling'
end
section 'Outline' do
part 'outline'
section 'Basics' do
chapter 'outline/sections_and_pages'
end
section 'Adding Nodes Later' do
chapter 'outline/add_subsection_to'
chapter 'outline/insert_section_after'
end
end
section 'Repeatable Content' do
part 'repeatable_content'
chapter 'repeatable_content/repeater'
chapter 'repeatable_content/stamp'
chapter 'repeatable_content/page_numbering'
chapter 'repeatable_content/alternate_page_numbering'
end
section 'Security' do
part 'security'
chapter 'security/encryption'
chapter 'security/permissions'
end
end
ruby-prawn-2.5.0.orig/manual/layout/ 0000775 0000000 0000000 00000000000 14571572164 016071 5 ustar root root ruby-prawn-2.5.0.orig/manual/layout/simple_grid.rb 0000664 0000000 0000000 00000001652 14571572164 020720 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Simple Grid'
text do
prose <<~TEXT
The document grid on Prawn is just a table-like structure with a defined
number of rows and columns. There are some helpers to create boxes of
content based on the grid coordinates.
define_grid accepts the following options which are pretty
much self-explanatory: :rows, :columns,
:gutter, :row_gutter,
:column_gutter.
TEXT
end
example do
# The grid only need to be defined once, but since all the examples should be
# able to run alone we are repeating it on every example
define_grid(columns: 5, rows: 8, gutter: 10)
text 'We defined the grid, roll over to the next page to see its outline'
start_new_page
grid.show_all
end
end
ruby-prawn-2.5.0.orig/manual/layout/content.rb 0000664 0000000 0000000 00000001473 14571572164 020075 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Content'
text do
prose <<~TEXT
Now that we know how to access the boxes we might as well add some
content to them.
This can be done by taping into the bounding box for a given grid box or
multi-box with the bounding_box method.
TEXT
end
example do
# The grid only need to be defined once, but since all the examples should be
# able to run alone we are repeating it on every example
define_grid(rows: 4, columns: 5, gutter: 10)
grid([1, 0], [3, 1]).bounding_box do
text "Adding some content to this multi_box.\n#{' _ ' * 200}"
end
grid(2, 3).bounding_box do
text "Just a little snippet here.\n#{' _ ' * 10}"
end
end
end
ruby-prawn-2.5.0.orig/manual/layout/boxes.rb 0000664 0000000 0000000 00000001702 14571572164 017536 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Boxes'
text do
prose <<~TEXT
After defined the grid is there but nothing happens. To start taking
effect we need to use the grid boxes.
grid has three different return values based on the
arguments received. With no arguments it will return the grid itself.
With integers it will return the grid box at those indices. With two
arrays it will return a multi-box spanning the region of the two grid
boxes at the arrays indices.
TEXT
end
example do
# The grid only need to be defined once, but since all the examples should be
# able to run alone we are repeating it on every example
define_grid(columns: 5, rows: 4, gutter: 10)
grid(0, 0).show
grid(1, 1).show
grid([2, 2], [3, 3]).show
grid([0, 4], [3, 4]).show
grid([3, 0], [3, 1]).show
end
end
ruby-prawn-2.5.0.orig/manual/layout.rb 0000664 0000000 0000000 00000000704 14571572164 016417 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Layout')
prose <<-TEXT
Prawn has support for two-dimensional grid based layouts out of the box.
The examples show:
TEXT
list(
'How to define the document grid',
'How to configure the grid rows and columns gutters',
'How to create boxes according to the grid',
)
end
end
ruby-prawn-2.5.0.orig/manual/images/ 0000775 0000000 0000000 00000000000 14571572164 016021 5 ustar root root ruby-prawn-2.5.0.orig/manual/images/width_and_height.rb 0000664 0000000 0000000 00000001544 14571572164 021643 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Width and Height'
text do
prose <<~TEXT
The image size can be set with the :width and
:height options.
If only one of those is provided, the image will be scaled
proportionally. When both are provided, the image will be stretched to
fit the dimensions without maintaining the aspect ratio.
TEXT
end
example do
text 'Scale by setting only the width'
image "#{Prawn::DATADIR}/images/pigs.jpg", width: 150
move_down 10
text 'Scale by setting only the height'
image "#{Prawn::DATADIR}/images/pigs.jpg", height: 80
move_down 10
text 'Stretch to fit the width and height provided'
image "#{Prawn::DATADIR}/images/pigs.jpg", width: 500, height: 100
end
end
ruby-prawn-2.5.0.orig/manual/images/vertical.rb 0000664 0000000 0000000 00000002010 14571572164 020150 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Vertical Positioning'
text do
prose <<~TEXT
To set the vertical position of an image use the :vposition
option.
It may be :top, :center, :bottom
or a number representing the y-offset from the top boundary.
TEXT
end
example new_page: true do
bounding_box([0, cursor], width: 500, height: 450) do
stroke_bounds
%i[top center bottom].each do |vposition|
text "Image vertically aligned to the #{vposition}.", valign: vposition
image "#{Prawn::DATADIR}/images/stef.jpg",
position: 220,
vposition: vposition
end
text_box 'The next image has a 100 point offset from the top boundary',
at: [bounds.width - 110, bounds.top - 10],
width: 100
image "#{Prawn::DATADIR}/images/stef.jpg",
position: :right,
vposition: 100
end
end
end
ruby-prawn-2.5.0.orig/manual/images/scale.rb 0000664 0000000 0000000 00000001117 14571572164 017435 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Scaling Pmages'
text do
prose <<~TEXT
To scale an image use the :scale option.
It scales the image proportionally given the provided value.
TEXT
end
example do
text 'Normal size'
image "#{Prawn::DATADIR}/images/stef.jpg"
move_down 10
text 'Scaled to 50%'
image "#{Prawn::DATADIR}/images/stef.jpg", scale: 0.5
move_down 10
text 'Scaled to 200%'
image "#{Prawn::DATADIR}/images/stef.jpg", scale: 2
end
end
ruby-prawn-2.5.0.orig/manual/images/plain_image.rb 0000664 0000000 0000000 00000001300 14571572164 020605 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Plain Image'
text do
prose <<~TEXT
To embed images onto your PDF file use the image method.
It accepts the file path of the image to be loaded and some optional
arguments.
If only the image path is provided the image will be rendered starting on
the cursor position. No manipulation is done with the image even if it
doesn't fit entirely on the page like the following snippet.
TEXT
end
example new_page: true do
text 'The image will go right below this line of text.'
image "#{Prawn::DATADIR}/images/pigs.jpg"
end
end
ruby-prawn-2.5.0.orig/manual/images/horizontal.rb 0000664 0000000 0000000 00000001625 14571572164 020543 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Horizontal Positioning'
text do
prose <<~TEXT
The image may be positioned relatively to the current bounding box. The
horizontal position may be set with the :position option.
It may be :left, :center, :right
or a number representing an x-offset from the left boundary.
TEXT
end
example new_page: true do
bounding_box([50, cursor], width: 400, height: 450) do
stroke_bounds
%i[left center right].each do |position|
text "Image aligned to the #{position}."
image "#{Prawn::DATADIR}/images/stef.jpg", position: position
end
text 'The next image has a 50 point offset from the left boundary'
image "#{Prawn::DATADIR}/images/stef.jpg", position: 50
end
end
end
ruby-prawn-2.5.0.orig/manual/images/fit.rb 0000664 0000000 0000000 00000001147 14571572164 017133 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Fiting'
text do
prose <<~TEXT
:fit option is useful when you want the image to have the
maximum size within a container preserving the aspect ratio without
overlapping.
Just provide the container width and height pair.
TEXT
end
example do
size = 300
text 'Using the fit option'
bounding_box([0, cursor], width: size, height: size) do
image "#{Prawn::DATADIR}/images/pigs.jpg", fit: [size, size]
stroke_bounds
end
end
end
ruby-prawn-2.5.0.orig/manual/images/absolute_position.rb 0000664 0000000 0000000 00000001600 14571572164 022105 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Absolute Positioning'
text do
prose <<~TEXT
One of the options that the image method accepts is
:at. If you've read some of the graphics examples you are
probably already familiar with it. Just provide it the upper-left corner
where you want the image placed.
While sometimes useful this option won't be practical. Notice that the
cursor won't be moved after the image is rendered and there is nothing
forbidding the text to overlap with the image.
TEXT
end
example do
y_position = cursor
text "The image won't go below this line of text."
image "#{Prawn::DATADIR}/images/fractal.jpg", at: [200, y_position]
text 'And this line of text will go just below the previous one.'
end
end
ruby-prawn-2.5.0.orig/manual/images.rb 0000664 0000000 0000000 00000001013 14571572164 016341 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Images')
prose <<-TEXT
Embedding images on PDF documents is fairly easy. Prawn supports both JPG
and PNG images.
The examples show:
TEXT
list(
'How to add an image to a page',
'How place the image on a specific position',
'How to configure the image dimensions by setting the width and ' \
'height or by scaling it',
)
end
end
ruby-prawn-2.5.0.orig/manual/how_to_read_this_manual.rb 0000664 0000000 0000000 00000004337 14571572164 021766 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
doc.move_down(Prawn::ManualBuilder::INNER_MARGIN)
header('How to read this manual')
prose <<~END_TEXT
This manual is a collection of examples categorized by theme and
organized from the least to the most complex. While it covers most of the
common use cases it is not a comprehensive guide.
The best way to read it depends on your previous knowledge of Prawn and
what you need to accomplish.
If you are beginning with Prawn the first chapter will teach you the most
basic concepts and how to create pdf documents. For an overview of the
other features each chapter beyond the first either has a Basics section
(which offer enough insight on the feature without showing all the
advanced stuff you might never use) or is simple enough with only a few
examples.
Once you understand the basics you might want to come back to this manual
looking for examples that accomplish tasks you need.
Advanced users are encouraged to go beyond this manual and read the
source code directly if any doubt is not directly covered on this manual.
END_TEXT
doc.move_down(Prawn::ManualBuilder::RHYTHM + Prawn::ManualBuilder::INNER_MARGIN)
header('Reading the examples')
prose <<~END_TEXT
The title of each example is the relative path from the Prawn source
manual/ folder.
The first body of text is the introductory text for the example.
Generally it is a short description of the features illustrated by the
example.
Next comes the example source code block in fixed width font.
Most of the example snippets illustrate features that alter the page in
place. The effect of these snippets is shown right below a dashed line.
If it doesn't make sense to evaluate the snippet inline, a box with the
link for the example file is shown instead.
Note that the stroke_axis method used throughout the manual
is part of standard Prawn. It is defined in this file:
https://github.com/prawnpdf/prawn/blob/master/lib/prawn/graphics.rb
END_TEXT
end
end
ruby-prawn-2.5.0.orig/manual/graphics/ 0000775 0000000 0000000 00000000000 14571572164 016354 5 ustar root root ruby-prawn-2.5.0.orig/manual/graphics/transparency.rb 0000664 0000000 0000000 00000001757 14571572164 021424 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Transparency'
text do
prose <<~TEXT
Although the name of the method is transparency, what we are
actually setting is the opacity for fill and stroke. So 0
means completely transparent and 1.0 means completely
opaque.
You may call it providing one or two values. The first value sets fill
opacity and the second value sets stroke opacity. If the second value is
omitted fill and stroke will have the same opacity.
TEXT
end
example do
self.line_width = 5
fill_color 'ff0000'
fill_rectangle [0, 100], 500, 100
fill_color '000000'
stroke_color 'ffffff'
base_x = 100
[[0.5, 1], 0.5, [1, 0.5]].each do |args|
transparent(*args) do
fill_circle [base_x, 100], 50
stroke_rectangle [base_x - 20, 100], 40, 80
end
base_x += 150
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/translate.rb 0000664 0000000 0000000 00000001267 14571572164 020704 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Translation'
text do
prose <<~TEXT
This transformation is used to translate the user space. Just provide the
x and y coordinates for the new origin.
TEXT
end
example axes: true do
1.upto(3) do |i|
x = i * 50
y = i * 100
translate(x, y) do
# Draw a point on the new origin
fill_circle [0, 0], 2
draw_text "New origin after translation to [#{x}, #{y}]", at: [5, -3]
stroke_rectangle [100, 50], 200, 30
text_box 'Top left corner at [100, 50]', at: [110, 40], width: 180
end
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/stroke_join.rb 0000664 0000000 0000000 00000001427 14571572164 021233 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stroke Join'
text do
prose <<~TEXT
The join style defines how the intersection between two lines is drawn.
There are three types: :miter (the default),
:round and :bevel.
Just like cap_style, the difference between styles is better
seen with thicker lines.
TEXT
end
example do
self.line_width = 25
%i[miter round bevel].each_with_index do |style, i|
self.join_style = style
y = 200 - (i * 100)
stroke do
move_to(100, y)
line_to(200, y + 100)
line_to(300, y)
end
stroke_rectangle [400, y + 75], 50, 50
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/stroke_dash.rb 0000664 0000000 0000000 00000003042 14571572164 021206 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stroke Dash Pattern'
text do
prose <<~TEXT
This sets the dashed pattern for lines and curves. The (dash) length
defines how long each dash will be.
The :space option defines the length of the space between
the dashes.
The :phase option defines the start point of the sequence of
dashes and spaces.
Complex dash patterns can be specified by using an array with alternating
dash/gap lengths for the first parameter (note that the
:space option is ignored in this case).
TEXT
end
example new_page: true do
move_down 20
dash([1, 2, 3, 2, 1, 5], phase: 6)
stroke_horizontal_line 50, 500
move_down 10
dash([1, 2, 3, 4, 5, 6, 7, 8])
stroke_horizontal_line 50, 500
base_y = cursor - 10
24.times do |i|
length = (i / 4) + 1
space = length # space between dashes same length as dash
phase = 0 # start with dash
case i % 4
when 0 then base_y -= 10
when 1 then phase = length # start with space between dashes
when 2 then space = length * 0.5 # space between dashes half as long as dash
when 3
space = length * 0.5 # space between dashes half as long as dash
phase = length # start with space between dashes
end
base_y -= 10
dash(length, space: space, phase: phase)
stroke_horizontal_line 50, 500, at: base_y - (2 * i)
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/stroke_cap.rb 0000664 0000000 0000000 00000002015 14571572164 021031 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stroke Cap'
text do
prose <<~TEXT
The cap style defines how the edge of a line or curve will be drawn.
There are three types: :butt (the default),
:round and :projecting_square.
The difference is better seen with thicker lines. With :butt
lines are drawn starting and ending at the exact points provided. With
both :round and :projecting_square the line is
projected beyond the start and end points.
Just like line_width= the cap_style= method
needs an explicit receiver to work.
TEXT
end
example axes: true do
self.line_width = 25
%i[butt round projecting_square].each_with_index do |cap, i|
self.cap_style = cap
y = 250 - (i * 100)
stroke_horizontal_line 100, 300, at: y
stroke_circle [400, y], 15
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/soft_masks.rb 0000664 0000000 0000000 00000002277 14571572164 021062 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Soft Masks'
text do
prose <<~TEXT
Soft masks are used for more complex alpha channel manipulations. You can
use arbitrary drawing functions for creation of soft masks. The resulting
alpha channel is made of greyscale version of the drawing (luminosity
channel to be precise). So while you can use any combination of colors
for soft masks it's easier to use greyscales. Black will result in full
transparency and white will make region fully opaque.
Soft mask is a part of page graphic state. So if you want to apply soft
mask only to a part of page you need to enclose drawing instructions in
save_graphics_state block.
TEXT
end
example do
save_graphics_state do
soft_mask do
0.upto(15) do |i|
fill_color 0, 0, 0, 100.0 / 16.0 * (15 - i)
fill_circle [75 + (i * 25), 100], 60
end
end
%w[009ddc 963d97 e03a3e f5821f fdb827 61bb46].each_with_index do |color, i|
fill_color color
fill_rectangle [0, 60 + (i * 20)], 600, 20
end
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/scale.rb 0000664 0000000 0000000 00000002221 14571572164 017765 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Scaling'
text do
prose <<~TEXT
This transformation is used to scale the user space. Give it an scale
factor and an :origin point and everything inside the block
will be scaled using the origin point as reference.
If you omit the :origin option the page origin will be used.
TEXT
end
example do
width = 100
height = 50
y = 190
x = 50
stroke_rectangle [x, y], width, height
text_box 'reference rectangle', at: [x + 10, y - 10], width: width - 20
scale(2, origin: [x, y]) do
stroke_rectangle [x, y], width, height
text_box 'rectangle scaled from upper-left corner', at: [x, y - height - 5], width: width
end
x = 350
stroke_rectangle [x, y], width, height
text_box 'reference rectangle', at: [x + 10, y - 10], width: width - 20
scale(2, origin: [x + (width / 2), y - (height / 2)]) do
stroke_rectangle [x, y], width, height
text_box 'rectangle scaled from center', at: [x, y - height - 5], width: width
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/rotate.rb 0000664 0000000 0000000 00000001360 14571572164 020177 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Rotation'
text do
prose <<~TEXT
This transformation is used to rotate the user space. Give it an angle
and an :origin point about which to rotate and a block.
Everything inside the block will be drawn with the rotated coordinates.
The angle is in degrees.
If you omit the :origin option the page origin will be used.
TEXT
end
example do
fill_circle [270, 180], 2
12.times do |i|
rotate(i * 30, origin: [270, 180]) do
stroke_rectangle [350, 200], 80, 40
text_box "Rotated #{i * 30}°", size: 10, at: [360, 185]
end
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/rectangle.rb 0000664 0000000 0000000 00000001054 14571572164 020645 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Rectangles'
text do
prose <<~TEXT
To draw a rectangle, just provide the upper-left corner, width and height
to the rectangle method.
There's also rounded_rectangle. Just provide an additional
radius value for the rounded corners.
TEXT
end
example axes: true do
stroke do
rectangle [100, 300], 100, 200
rounded_rectangle [300, 300], 100, 200, 20
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/polygon.rb 0000664 0000000 0000000 00000001551 14571572164 020372 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Polygons'
text do
prose <<~TEXT
Drawing polygons in Prawn is easy, just pass a sequence of points to one
of the polygon family of methods.
Just like rounded_rectangle we also have
rounded_polygon. The only difference is the radius param
comes before the polygon points.
TEXT
end
example axes: true do
# Triangle
stroke_polygon [50, 200], [50, 300], [150, 300]
# Hexagon
fill_polygon [50, 150], [150, 200], [250, 150], [250, 50], [150, 0], [50, 50]
# Pentagram
pentagon_points = [500, 100], [430, 5], [319, 41], [319, 159], [430, 195]
pentagram_points = [0, 2, 4, 1, 3].map { |i| pentagon_points[i] }
stroke_rounded_polygon(20, *pentagram_points)
end
end
ruby-prawn-2.5.0.orig/manual/graphics/lines_and_curves.rb 0000664 0000000 0000000 00000002436 14571572164 022231 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Lines and Curves'
text do
prose <<~TEXT
Prawn supports drawing both lines and curves starting either at the
current position, or from a specified starting position.
line_to and curve_to set the drawing path from
the current drawing position to the specified point. The initial drawing
position can be set with move_to. They are useful when you
want to chain successive calls because the drawing position will be set
to the specified point afterwards.
line and curve set the drawing path between the
two specified points.
Both curve methods define a Bezier curve bounded by two aditional points
provided as the :bounds param.
TEXT
end
example axes: true do
# line_to and curve_to
stroke do
move_to 0, 0
line_to 100, 100
line_to 0, 100
curve_to [150, 200], bounds: [[20, 150], [120, 150]]
curve_to [200, 0], bounds: [[150, 200], [450, 10]]
end
# line and curve
stroke do
line [300, 200], [400, 50]
curve [500, 0], [400, 100], bounds: [[600, 200], [300, 290]]
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/line_width.rb 0000664 0000000 0000000 00000001704 14571572164 021031 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Line Width'
text do
prose <<~TEXT
The line_width= method sets the stroke width for subsequent
stroke calls.
Since Ruby assumes that an unknown variable on the left hand side of an
assignment is a local temporary, rather than a setter method, if you are
using the block call to Prawn::Document.generate without
passing params you will need to call line_width on self.
TEXT
end
example axes: true do
y = 225
3.times do |i|
case i
when 0 then line_width = 10 # This call will have no effect
when 1 then self.line_width = 10
when 2 then self.line_width = 25
end
stroke do
horizontal_line 25, 75, at: y
rectangle [225, y + 25], 50, 50
circle [450, y], 25
end
y -= 90
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/helper.rb 0000664 0000000 0000000 00000001747 14571572164 020171 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stroke Axis'
text do
prose <<~TEXT
To produce this manual we use the stroke_axis helper method
within the examples.
stroke_axis prints the x and y axis for the current bounding
box with markers in 100 increments. The defaults can be changed with
various options.
Note that the examples define a custom :height option so
that only the example canvas is used (as seen with the output of the
first line of the example code).
TEXT
end
example do
stroke_axis
stroke_axis(
at: [70, 70],
height: 200,
step_length: 50,
negative_axes_length: 5,
color: '0000FF',
)
stroke_axis(
at: [140, 140],
width: 200,
height: Integer(cursor) - 140,
step_length: 20,
negative_axes_length: 40,
color: 'FF0000',
)
end
end
ruby-prawn-2.5.0.orig/manual/graphics/gradients.rb 0000664 0000000 0000000 00000003162 14571572164 020663 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Gradients'
text do
prose <<~TEXT
Note that because of the way PDF renders radial gradients in order to get
solid fill your start circle must be fully inside your end circle.
Otherwise you will get triangle fill like illustrated in the example
below.
TEXT
end
example new_page: true do
self.line_width = 10
# Linear Gradients
fill_gradient [0, 250], [100, 150], 'ff0000', '0000ff'
fill_rectangle [0, 250], 100, 100
stroke_gradient [150, 150], [250, 250], '00ffff', 'ffff00'
stroke_rectangle [150, 250], 100, 100
fill_gradient [300, 250], [400, 150], 'ff0000', '0000ff'
stroke_gradient [300, 150], [400, 250], '00ffff', 'ffff00'
fill_and_stroke_rectangle [300, 250], 100, 100
rotate 45, origin: [500, 200] do
stops = { 0 => 'ff0000', 0.6 => '999900', 0.8 => '00cc00', 1 => '4444ff' }
fill_gradient from: [460, 240], to: [540, 160], stops: stops
fill_rectangle [460, 240], 80, 80
end
# Radial gradients
fill_gradient [50, 50], 0, [50, 50], 70.71, 'ff0000', '0000ff'
fill_rectangle [0, 100], 100, 100
stroke_gradient [200, 50], 45, [200, 50], 70.71, '00ffff', 'ffff00'
stroke_rectangle [150, 100], 100, 100
stroke_gradient [350, 50], 45, [350, 50], 70.71, '00ffff', 'ffff00'
fill_gradient [350, 50], 0, [350, 50], 70.71, 'ff0000', '0000ff'
fill_and_stroke_rectangle [300, 100], 100, 100
fill_gradient [500, 100], 50, [500, 0], 0, 'ff0000', '0000ff'
fill_rectangle [450, 100], 100, 100
end
end
ruby-prawn-2.5.0.orig/manual/graphics/fill_rules.rb 0000664 0000000 0000000 00000003003 14571572164 021035 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Fill Rules'
text do
prose <<~TEXT
Prawn's fill operators (fill and
fill_and_stroke both accept a :fill_rule
option. These rules determine which parts of the page are counted as
"inside" vs. "outside" the path. There are two fill rules:
TEXT
list(
':nonzero_winding_number (default): a point is inside the ' \
'path if a ray from that point to infinity crosses a nonzero "net ' \
'number" of path segments, where path segments intersecting in one ' \
'direction are counted as positive and those in the other direction ' \
'negative.',
':even_odd: A point is inside the path if a ray from that ' \
'point to infinity crosses an odd number of path segments, regardless ' \
'of direction.',
)
prose <<~TEXT
The differences between the fill rules only come into play with complex
paths; they are identical for simple shapes.
TEXT
end
example axes: true do
pentagram = [[181, 95], [0, 36], [111, 190], [111, 0], [0, 154]]
stroke_color 'ff0000'
line_width 2
text_box 'Nonzero Winding Number', at: [10, 200]
polygon(*pentagram.map { |x, y| [x + 50, y] })
fill_and_stroke
text_box 'Even-Odd', at: [330, 200]
polygon(*pentagram.map { |x, y| [x + 330, y] })
fill_and_stroke(fill_rule: :even_odd)
end
end
ruby-prawn-2.5.0.orig/manual/graphics/fill_and_stroke.rb 0000664 0000000 0000000 00000002402 14571572164 022036 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Fill and Stroke'
text do
prose <<~TEXT
There are two drawing primitives in Prawn: fill and
stroke.
These are the methods that actually draw stuff on the document. All the
other drawing shapes like rectangle, circle or
line_to define drawing paths. These paths need to be either
stroked or filled to gain form on the document.
Calling these methods without a block will act on the drawing path that
has been defined prior to the call.
Calling with a block will act on the drawing path set within the block.
Most of the methods which define drawing paths have methods of the same
name starting with stroke_ and fill_ which create the drawing path and
then stroke or fill it.
TEXT
end
example axes: true do
# No block
line [0, 200], [100, 150]
stroke
rectangle [0, 100], 100, 100
fill
# With block
stroke { line [200, 200], [300, 150] }
fill { rectangle [200, 100], 100, 100 }
# Method hook
stroke_line [400, 200], [500, 150]
fill_rectangle [400, 100], 100, 100
end
end
ruby-prawn-2.5.0.orig/manual/graphics/common_lines.rb 0000664 0000000 0000000 00000001454 14571572164 021367 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Common Lines'
text do
prose <<~TEXT
Prawn provides helpers for drawing some commonly used lines:
vertical_line and horizontal_line do just what
their names imply. Specify the start and end point at a fixed coordinate
to define the line.
horizontal_rule draws a horizontal line on the current
bounding box from border to border, using the current y position.
TEXT
end
example axes: true do
stroke_color 'ff0000'
stroke do
# just lower the current y position
move_down 50
horizontal_rule
vertical_line 100, 300, at: 50
horizontal_line 200, 500, at: 150
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics/color.rb 0000664 0000000 0000000 00000001232 14571572164 020015 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Color'
text do
prose <<~TEXT
We can change the stroke and fill colors providing an HTML rgb 6 digit
color code string ("AB1234") or 4 values for CMYK.
TEXT
end
example do
# Fill with Orange using RGB (Unlike css, there is no leading #)
fill_color 'FF8844'
fill_polygon [50, 150], [150, 200], [250, 150], [250, 50], [150, 0], [50, 50]
# Stroke with Purple using CMYK
stroke_color 50, 100, 0, 0
stroke_rectangle [300, 300], 200, 100
# Both together
fill_and_stroke_circle [400, 100], 50
end
end
ruby-prawn-2.5.0.orig/manual/graphics/circle_and_ellipse.rb 0000664 0000000 0000000 00000001160 14571572164 022477 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Circles and Ellipses'
text do
prose <<~TEXT
To define a circle all you need is the center point and the
radius.
To define an ellipse you provide the center point and two
radii (or axes) values. If the second radius value is omitted, both radii
will be equal and you will end up drawing a circle.
TEXT
end
example axes: true do
stroke_circle [100, 300], 100
fill_ellipse [200, 100], 100, 50
fill_ellipse [400, 100], 50
end
end
ruby-prawn-2.5.0.orig/manual/graphics/blend_mode.rb 0000664 0000000 0000000 00000004102 14571572164 020766 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Blend Modes'
text do
prose <<~TEXT
Blend modes can be used to change the way two layers (images, graphics,
text, etc.) are blended together. The blend_mode method
accepts a single blend mode or an array of blend modes. PDF viewers
should blend the layers based on the first recognized blend mode.
Valid blend modes in v1.4 of the PDF spec include :Normal,
:Multiply, :Screen, :Overlay,
:Darken, :Lighten, :ColorDodge,
:ColorBurn, :HardLight,
:SoftLight, :Difference,
:Exclusion, :Hue, :Saturation,
:Color, and :Luminosity.
TEXT
end
example new_page: true do
# https://commons.wikimedia.org/wiki/File:Blend_modes_2.-bottom-layer.jpg#/media/File:Blend_modes_2.-bottom-layer.jpg
bottom_layer = "#{Prawn::DATADIR}/images/blend_modes_bottom_layer.jpg"
# https://commons.wikimedia.org/wiki/File:Blend_modes_1.-top-layer.jpg#/media/File:Blend_modes_1.-top-layer.jpg
top_layer = "#{Prawn::DATADIR}/images/blend_modes_top_layer.jpg"
blend_modes = %i[
Normal Multiply Screen Overlay Darken Lighten ColorDodge
ColorBurn HardLight SoftLight Difference Exclusion Hue
Saturation Color Luminosity
]
blend_modes.each_with_index do |blend_mode, index|
x = 5 + (index % 4 * 130)
y = cursor - (index / 4 * 195) - 5
image bottom_layer, at: [x, y], fit: [120, 120]
blend_mode(blend_mode) do
image top_layer, at: [x, y], fit: [120, 120]
end
y -= 130
fill_color '009ddc'
fill_rectangle [x, y], 75, 25
blend_mode(blend_mode) do
fill_color 'fdb827'
fill_rectangle [x + 50, y], 70, 25
end
y -= 30
fill_color '000000'
text_box blend_mode.to_s, at: [x, y]
end
end
end
ruby-prawn-2.5.0.orig/manual/graphics.rb 0000664 0000000 0000000 00000001664 14571572164 016710 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Graphics')
prose <<-TEXT
Here we show all the drawing methods provided by Prawn. Use them to draw
the most beautiful imaginable things.
Most of the content that you'll add to your pdf document will use the
graphics package. Even text is rendered on a page just like a rectangle
so even if you never use any of the shapes described here you should at
least read the basic examples.
The examples show:
TEXT
list(
'All the possible ways that you can fill or stroke shapes on a page',
'How to draw all the shapes that Prawn has to offer from a measly ' \
'line to a mighty polygon or ellipse',
'The configuration options for stroking lines and filling shapes',
'How to apply transformations to your drawing space',
)
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options/ 0000775 0000000 0000000 00000000000 14571572164 021763 5 ustar root root ruby-prawn-2.5.0.orig/manual/document_and_page_options/print_scaling.rb 0000664 0000000 0000000 00000002152 14571572164 025144 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Print Scaling'
text do
prose <<~TEXT
(Optional; PDF 1.6) The page scaling option to be selected when a print
dialog is displayed for this document. Valid values are
None, which indicates that the print dialog should reflect
no page scaling, and AppDefault, which indicates that
applications should use the current print scaling. If this entry has an
unrecognized value, applications should use the current print scaling.
Default value: AppDefault.
Note: If the print dialog is suppressed and its parameters are provided
directly by the application, the value of this entry should still be
used.
TEXT
end
example eval: false, standalone: true do
Prawn::Document.generate(
'example.pdf',
page_layout: :landscape,
print_scaling: :none,
) do
text 'When you print this document, the scale to fit in print preview ' \
'should be disabled by default.'
end
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options/page_size.rb 0000664 0000000 0000000 00000002532 14571572164 024260 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Page Size'
text do
prose <<~TEXT
Prawn comes with support for most of the common page sizes so you'll only
need to provide specific values if your intended format is not supported.
To see a list with all supported sizes take a look at
PDF::Core::PageGeometry.
To define the size use :page_size when creating new
documents and :size when starting new pages. The default
page size for new documents is LETTER (612.00 x 792.00).
You may also define the orientation of the page to be either portrait
(default) or landscape. Use :page_layout when creating new
documents and :layout when starting new pages.
TEXT
end
example eval: false, standalone: true do
Prawn::Document.generate(
'example.pdf',
page_size: 'EXECUTIVE',
page_layout: :landscape,
) do
text 'EXECUTIVE landscape page.'
custom_size = [275, 326]
['A4', 'TABLOID', 'B7', custom_size].each do |size|
start_new_page(size: size, layout: :portrait)
text "#{size} portrait page."
start_new_page(size: size, layout: :landscape)
text "#{size} landscape page."
end
end
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options/page_margins.rb 0000664 0000000 0000000 00000002622 14571572164 024746 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Page Margins'
text do
prose <<~TEXT
The default margin for pages is 0.5 inch but you can change that with the
:margin option or if you'd like to have different margins
you can use the :left_margin, :right_margin,
:top_margin, :bottom_margin options.
These options are available both for starting new pages and creating new
documents.
TEXT
end
example eval: false, standalone: true do
Prawn::Document.generate('example.pdf', margin: 100) do
text '100 pts margins.'
stroke_bounds
start_new_page(left_margin: 300)
text '300 pts margin on the left.'
stroke_bounds
start_new_page(top_margin: 300)
text '300 pts margin both on the top and on the left. Notice that whenever ' \
'you set an option for a new page it will remain the default for the ' \
'following pages.'
stroke_bounds
start_new_page(margin: 50)
text '50 pts margins. Using the margin option will reset previous specific ' \
'calls to left, right, top and bottom margins.'
stroke_bounds
start_new_page(margin: [50, 100, 150, 200])
text 'There is also the shorthand CSS like syntax used here.'
stroke_bounds
end
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options/metadata.rb 0000664 0000000 0000000 00000001614 14571572164 024072 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Document Metadata'
text do
prose <<~TEXT
To set the document metadata just pass a hash to the :info
option when creating new documents.
The keys in the example below are arbitrary, so you may add whatever keys
you want.
TEXT
end
example eval: false, standalone: true do
info = {
Title: 'My title',
Author: 'John Doe',
Subject: 'My Subject',
Keywords: 'test metadata ruby pdf dry',
Creator: 'ACME Soft App',
Producer: 'Prawn',
CreationDate: Time.now,
}
Prawn::Document.generate('example.pdf', info: info) do
text 'This is a test of setting metadata properties via the info option.'
text 'While the keys are arbitrary, the above example sets common attributes.'
end
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options/background.rb 0000664 0000000 0000000 00000001565 14571572164 024436 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Background'
text do
prose <<~TEXT
Pass an image path to the :background option and it will be
used as the background for all pages.
This option can only be used on document creation.
TEXT
end
example eval: false, standalone: true do
img = "#{Prawn::DATADIR}/images/letterhead.jpg"
Prawn::Document.generate('example.pdf', background: img, margin: 100) do
text 'My report caption', size: 18, align: :right
move_down font.height * 2
text 'Here is my text explaining this report. ' * 20,
size: 12,
align: :left,
leading: 2
move_down font.height
text "I'm using a soft background. " * 40,
size: 12,
align: :left,
leading: 2
end
end
end
ruby-prawn-2.5.0.orig/manual/document_and_page_options.rb 0000664 0000000 0000000 00000001215 14571572164 022307 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Document and Page Options')
prose <<-TEXT
So far we've already seen how to create new documents and start new
pages. This chapter expands on the previous examples by showing other
options avialable. Some of the options are only available when creating
new documents.
The examples show:
TEXT
list(
'How to configure page size',
'How to configure page margins',
'How to use a background image',
'How to add metadata to the generated PDF',
)
end
end
ruby-prawn-2.5.0.orig/manual/cover.rb 0000664 0000000 0000000 00000002162 14571572164 016220 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
doc.move_down(200)
doc.image(
"#{Prawn::DATADIR}/images/prawn.png",
scale: 0.9,
at: [0, doc.cursor - 60],
)
doc.formatted_text_box(
[{ text: "Prawn\n", font: 'DejaVu', styles: [:bold], size: 85 }],
at: [160, doc.cursor - 50],
)
doc.formatted_text_box(
[{ text: 'by example', font: 'Iosevka', size: 58 }],
at: [165, doc.cursor - 130],
)
unless ENV['CI']
git_commit =
if Dir.exist?(File.expand_path('../.git', __dir__))
commit = `git show --pretty=%h`
"git commit: #{commit.lines.first}"
else
''
end
doc.canvas do
v_text = [
{
text: "Last Update: #{Time.now.strftime('%Y-%m-%d')}\n" \
"Prawn Version: #{Prawn::VERSION}\n#{git_commit}",
font: 'DejaVu',
size: 12,
},
]
h = doc.height_of_formatted(v_text)
doc.formatted_text_box(v_text, at: [370, h + 50])
end
end
end
end
ruby-prawn-2.5.0.orig/manual/contents.rb 0000664 0000000 0000000 00000001560 14571572164 016740 0 ustar root root # frozen_string_literal: true
# Generates the Prawn by example manual.
require_relative 'example_helper'
def prawn_manual_document
old_default_external_encoding = Encoding.default_external
Encoding.default_external = Encoding::UTF_8
Prawn::ManualBuilder::Example.new(
skip_page_creation: true,
page_size: 'FOLIO',
) do
load_page('', 'cover')
load_page('', 'how_to_read_this_manual')
# Core chapters
load_package('basic_concepts')
load_package('graphics')
load_package('text')
load_package('bounding_box')
# Remaining chapters
load_package('layout')
load_page('', 'table')
load_package('images')
load_package('document_and_page_options')
load_package('outline')
load_package('repeatable_content')
load_package('security')
end
ensure
Encoding.default_external = old_default_external_encoding
end
ruby-prawn-2.5.0.orig/manual/bounding_box/ 0000775 0000000 0000000 00000000000 14571572164 017231 5 ustar root root ruby-prawn-2.5.0.orig/manual/bounding_box/stretchy.rb 0000664 0000000 0000000 00000001670 14571572164 021427 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Stretchy Bounding Box'
text do
prose <<~TEXT
Bounding Boxes accept an optional :height parameter. Unless
it is provided the bounding box will be stretchy. It will expand the
height to fit all content generated inside it.
TEXT
end
example do
y_position = cursor
bounding_box([0, y_position], width: 200, height: 100) do
text 'This bounding box has a height of 100. If this text gets too large ' \
'it will flow to the next page.'
transparent(0.5) { stroke_bounds }
end
bounding_box([300, y_position], width: 200) do
text 'This bounding box has variable height. No matter how much text is ' \
'written here, the height will expand to fit.'
text ' _' * 100
text ' *' * 100
transparent(0.5) { stroke_bounds }
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/recursive_boxes.rb 0000664 0000000 0000000 00000001764 14571572164 022775 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Recursive Boxes'
text do
prose <<~TEXT
This example is mostly just for fun, and shows how nested bounding boxes
can simplify calculations. See the "Bounding Box" section of the manual
for more basic uses.
TEXT
end
example do
def combine(horizontal_span, vertical_span)
vertical_span.flat_map do |y|
horizontal_span.zip([y] * horizontal_span.size)
end
end
def recurse_bounding_box(max_depth = 4, depth = 1)
width = (bounds.width - 15) / 2
height = (bounds.height - 15) / 2
left_top_corners = combine([5, bounds.right - width - 5], [bounds.top - 5, height + 5])
left_top_corners.each do |lt|
bounding_box(lt, width: width, height: height) do
stroke_bounds
recurse_bounding_box(max_depth, depth + 1) if depth < max_depth
end
end
end
recurse_bounding_box
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/nesting.rb 0000664 0000000 0000000 00000003034 14571572164 021225 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Nesting Bounding Boxes'
text do
prose <<~TEXT
Normally when we provide the top left corner of a bounding box we express
the coordinates relative to the margin box. This is not the case when we
have nested bounding boxes. Once nested the inner bounding box
coordinates are relative to the outer bounding box.
This example shows some nested bounding boxes with fixed and stretchy
heights. Note how the cursor method returns coordinates
relative to the current bounding box.
TEXT
end
example new_page: true do
def box_content(string)
text(string)
transparent(0.5) { stroke_bounds }
end
gap = 20
bounding_box([50, cursor], width: 400, height: 200) do
box_content('Fixed height')
bounding_box([gap, cursor - gap], width: 300) do
text 'Stretchy height'
bounding_box([gap, bounds.top - gap], width: 100) do
text 'Stretchy height'
transparent(0.5) do
dash(1)
stroke_bounds
undash
end
end
bounding_box([gap * 7, bounds.top - gap], width: 100, height: 50) do
box_content('Fixed height')
end
transparent(0.5) do
dash(1)
stroke_bounds
undash
end
end
bounding_box([gap, cursor - gap], width: 300, height: 50) do
box_content('Fixed height')
end
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/indentation.rb 0000664 0000000 0000000 00000002431 14571572164 022072 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Bounding Box Indentation'
text do
prose <<~TEXT
Sometimes you just need to indent a portion of the contents of a bounding
box, and using a nested bounding box is pure overkill. The
indent method is what you might need.
Just provide a number for it to indent all content generated inside the
block.
TEXT
end
example new_page: true do
text 'No indentation on the margin box.'
indent(20) do
text 'Some indentation inside an indent block.'
end
move_down 20
bounding_box([50, cursor], width: 400, height: cursor) do
transparent(0.5) { stroke_bounds }
move_down 10
text 'No indentation inside this bounding box.'
indent(40) do
text 'Inside an indent block. And so is this horizontal line:'
stroke_horizontal_rule
end
move_down 10
text 'No indentation'
move_down 20
indent(60) do
text 'Another indent block.'
bounding_box([0, cursor], width: 200) do
text 'Note that this bounding box coordinates are relative to the indent block'
transparent(0.5) { stroke_bounds }
end
end
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/creation.rb 0000664 0000000 0000000 00000001503 14571572164 021361 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Bounding Box Creation'
text do
prose <<~TEXT
If you've read the basic concepts examples you probably know that the
origin of a page is on the bottom left corner and that the content flows
from top to bottom.
You also know that a Bounding Box is a structure for helping the content
flow.
A bounding box can be created with the bounding_box method.
Just provide the top left corner, a required :width option
and an optional :height.
TEXT
end
example do
bounding_box([200, cursor - 100], width: 200, height: 100) do
text 'Just your regular bounding box'
transparent(0.5) { stroke_bounds }
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/canvas.rb 0000664 0000000 0000000 00000001614 14571572164 021033 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Canvas'
text do
prose <<~TEXT
The origin example already mentions that a new document already comes
with a margin box whose bottom left corner is used as the origin for
calculating coordinates.
What has not been told is that there is one helper for "bypassing" the
margin box: canvas. This method is a shortcut for creating a
bounding box mapped to the absolute coordinates and evaluating the code
inside it.
The following snippet draws a circle on each of the four absolute
corners.
TEXT
end
example do
canvas do
fill_circle [bounds.left, bounds.top], 30
fill_circle [bounds.right, bounds.top], 30
fill_circle [bounds.right, bounds.bottom], 30
fill_circle [0, 0], 30
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box/bounds.rb 0000664 0000000 0000000 00000003430 14571572164 021050 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Bounding Box Creation'
text do
prose <<~TEXT
The bounds method returns the current bounding box. This is
useful because the Prawn::BoundingBox exposes some nice
boundary helpers.
top, bottom, left and
right methods return the bounding box boundaries relative to
its translated origin. top_left, top_right,
bottom_left and bottom_right return those
boundaries pairs inside arrays.
All these methods have an "absolute" version like
absolute_right. The absolute version returns the same
boundary relative to the page absolute coordinates.
The following snippet shows the boundaries for the margin box side by
side with the boundaries for a custom bounding box.
TEXT
end
example new_page: true do
def print_coordinates
text("top: #{bounds.top}")
text("bottom: #{bounds.bottom}")
text("left: #{bounds.left}")
text("right: #{bounds.right}")
move_down(10)
text("absolute top: #{Float(bounds.absolute_top).round(2)}")
text("absolute bottom: #{Float(bounds.absolute_bottom).round(2)}")
text("absolute left: #{Float(bounds.absolute_left).round(2)}")
text("absolute right: #{Float(bounds.absolute_right).round(2)}")
end
move_down 20
text 'Margin box bounds:'
move_down 5
print_coordinates
bounding_box([250, cursor + 140], width: 200, height: 150) do
text 'This bounding box bounds:'
move_down 5
print_coordinates
transparent(0.5) { stroke_bounds }
end
end
end
ruby-prawn-2.5.0.orig/manual/bounding_box.rb 0000664 0000000 0000000 00000001153 14571572164 017556 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Bounding Box')
prose <<-TEXT
Bounding boxes are the basic containers for structuring the content
flow. Even being low level building blocks sometimes their simplicity is
very welcome.
The examples show:
TEXT
list(
'How to create bounding boxes with specific dimensions',
'How to inspect the current bounding box for its coordinates',
'Stretchy bounding boxes',
'Nested bounding boxes',
'Indent blocks',
)
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/ 0000775 0000000 0000000 00000000000 14571572164 017533 5 ustar root root ruby-prawn-2.5.0.orig/manual/basic_concepts/view.rb 0000664 0000000 0000000 00000003323 14571572164 021033 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'View'
text do
prose <<~TEXT
The recommended way to extend Prawn's functionality is to include the
Prawn::View mixin in your own class, which will make all
Prawn::Document methods available to your custom objects.
This approach is preferred over inheriting from
Prawn::Document, as your state will be kept completely
separate from Prawn::Document's, thus avoiding accidental
method collisions.
Note that Prawn::View lazily instantiates a
Prawn::Document with default initialization settings, such
as page size, layout, margins, etc.
By defining your own document method you will be able to
override those settings and initialize a Prawn::Document to
your heart's content. This method will be called repeatedly by
Prawn::View, so be sure to memoize the object by assigning
it to an instance variable via the ||= operator.
TEXT
end
# rubocop: disable Lint/ConstantDefinitionInBlock
example eval: false, standalone: true do
class Greeter
include Prawn::View
def initialize(name)
@name = name
end
def document
@document ||= Prawn::Document.new(page_size: 'A4', margin: 30)
end
def say_hello
font('Courier') do
text("Hello, #{@name}!")
end
end
end
greeter = Greeter.new('Gregory')
greeter.say_hello
greeter.save_as('greetings.pdf')
end
# rubocop: enable Lint/ConstantDefinitionInBlock
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/other_cursor_helpers.rb 0000664 0000000 0000000 00000002444 14571572164 024324 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Other Cursor Helpers'
text do
prose <<~TEXT
Another group of helpers for changing the cursor position are the pad
methods. They accept a numeric value and a block. pad will
use the numeric value to move the cursor down both before and after the
block content. pad_top will only move the cursor before the
block while pad_bottom will only move after.
float is a method for not changing the cursor. Pass it a
block and the cursor will remain on the same place when the block
returns.
TEXT
end
example new_page: true do
stroke_horizontal_rule
pad(20) { text 'Text padded both before and after.' }
stroke_horizontal_rule
pad_top(20) { text 'Text padded on the top.' }
stroke_horizontal_rule
pad_bottom(20) { text 'Text padded on the bottom.' }
stroke_horizontal_rule
move_down 30
text 'Text written before the float block.'
float do
move_down 30
bounding_box([0, cursor], width: 200) do
text 'Text written inside the float block.'
stroke_bounds
end
end
text 'Text written after the float block.'
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/origin.rb 0000664 0000000 0000000 00000002627 14571572164 021356 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Origin'
text do
prose <<~TEXT
This is the most important concept you need to learn about Prawn:
PDF documents have the origin [0,0] at the bottom-left corner
of the page.
A bounding box is a structure which provides boundaries for inserting
content. A bounding box also has the property of relocating the origin to
its relative bottom-left corner. However, be aware that the location
specified when creating a bounding box is its top-left corner, not
bottom-left (hence the [100, 300] coordinates below).
Even if you never create a bounding box explicitly, each document already
comes with one called the margin box. This initial bounding box is the
one responsible for the document margins.
So practically speaking the origin of a page on a default generated
document isn't the absolute bottom left corner but the bottom left corner
of the margin box.
The following snippet strokes a circle on the margin box origin. Then
strokes the boundaries of a bounding box and a circle on its origin.
TEXT
end
example axes: true do
stroke_circle [0, 0], 10
bounding_box([100, 200], width: 300, height: 100) do
stroke_bounds
stroke_circle [0, 0], 10
end
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/measurement.rb 0000664 0000000 0000000 00000001476 14571572164 022415 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Measurement Extensions'
text do
prose <<~TEXT
The base unit in Prawn is the PDF Point. One PDF Point is equal to 1/72
of an inch.
There is no need to waste time converting this measure. Prawn provides
helpers for converting from other measurements to PDF Points.
Just require "prawn/measurement_extensions" and it will mix
some helpers onto Numeric for converting common measurement
units to PDF Points.
TEXT
end
example do
require 'prawn/measurement_extensions'
%i[mm cm dm m in yd ft].each do |measurement|
text "1 #{measurement} in PDF Points: #{1.public_send(measurement)} pt"
move_down 5.mm
end
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/cursor.rb 0000664 0000000 0000000 00000002270 14571572164 021376 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Cursor'
text do
prose <<~TEXT
We normally write our documents from top to bottom and it is no different
with Prawn. Even if the origin is on the bottom left corner we still fill
the page from the top to the bottom. In other words the cursor for
inserting content starts on the top of the page.
Most of the functions that insert content on the page will start at the
current cursor position and proceed to the bottom of the page.
The following snippet shows how the cursor behaves when we add some text
to the page and demonstrates some of the helpers to manage the cursor
position. The cursor method returns the current cursor
position.
TEXT
end
example axes: true do
text "the cursor is here: #{cursor}"
text "now it is here: #{cursor}"
move_down 100
text "on the first move the cursor went down to: #{cursor}"
move_up 50
text "on the second move the cursor went up to: #{cursor}"
move_cursor_to 50
text "on the last move the cursor went directly to: #{cursor}"
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/creation.rb 0000664 0000000 0000000 00000003104 14571572164 021662 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Creating a PDF Document'
text do
prose <<~TEXT
There are three ways to create a PDF Document in Prawn: creating a new
Prawn::Document instance, or using the
Prawn::Document.generate method with and without block
arguments.
The following snippet showcase each way by creating a simple document with
some text drawn.
When we instantiate the Prawn::Document object the actual pdf
document will only be created after we call render_file.
The generate method will render the actual pdf object after exiting the
block. When we use it without a block argument the provided block is
evaluated in the context of a newly created Prawn::Document
instance. When we use it with a block argument a
Prawn::Document instance is created and passed to the block.
The generate method without block arguments requires less typing and
defines and renders the pdf document in one shot. Almost all of the
examples are coded this way.
TEXT
end
example eval: false, standalone: true do
# Assignment
pdf = Prawn::Document.new
pdf.text('Hello World')
pdf.render_file('assignment.pdf')
# Implicit Block
Prawn::Document.generate('implicit.pdf') do
text 'Hello World'
end
# Explicit Block
Prawn::Document.generate('explicit.pdf') do |pdf|
pdf.text('Hello World')
end
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts/adding_pages.rb 0000664 0000000 0000000 00000002001 14571572164 022456 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Chapter.new do
title 'Adding Pages'
text do
prose <<~TEXT
A PDF document is a collection of pages. When we create a new document be
it with Document.new or on a Document.generate
block one initial page is created for us.
Some methods might create new pages automatically like text
which will create a new page whenever the text string cannot fit on the
current page.
But what if you want to go to the next page by yourself? That is easy.
Just use the start_new_page method and a shiny new page will
be created for you just like in the following snippet.
TEXT
end
example do
text "We are still on the initial page for this example. Now I'll ask " \
'Prawn to gently start a new page. Please follow me to the next page.'
start_new_page
text "See. We've left the previous page behind."
end
end
ruby-prawn-2.5.0.orig/manual/basic_concepts.rb 0000664 0000000 0000000 00000001744 14571572164 020066 0 ustar root root # frozen_string_literal: true
require 'prawn/manual_builder'
Prawn::ManualBuilder::Peritext.new do
text do
header_with_bg('Basic Concepts')
prose <<~TEXT
This chapter covers the minimum amount of functionality you'll need to
start using Prawn.
If you are new to Prawn this is the first chapter to read. Once you are
comfortable with the concepts shown here you might want to check the
Basics section of the Graphics, Bounding Box and Text sections.
The examples show:
TEXT
list(
'How to create new pdf documents in every possible way',
'Where the origin for the document coordinates is. What are Bounding ' \
'Boxes and how they interact with the origin',
'How the cursor behaves',
'How to start new pages',
'What the base unit for measurement and coordinates is and how to use ' \
'other convenient measures',
"How to build custom view objects that use Prawn's DSL",
)
end
end
ruby-prawn-2.5.0.orig/manual/absolute_position.pdf 0000664 0000000 0000000 00000113256 14571572164 021021 0 ustar root root %PDF-1.3
%
1 0 obj
<< /Creator Fzhѻ)k!"tA+X!M+[,hF)(ы=( 빩6ZX(F|ڧmg\1KYon N5k7~A> ,𠃦`U:
S7r|D~WS UyQ/
oUW3w-! ,&39«qrb4u .}0'x铭1h~됟uV#O19c~ˎ;K '/pf $ Wx.TȺo?+{PO_8(f,c+@P`eh'xr,C\EפtܵboB3|cW|Ϥi 'Y]lC;? >K~#D>\SЀ~Ղ?%^zwgG
O&t ~xUtAښݻwj`lཋD:cۨئNS|&߷c;
8
+^C~77TԁMC%*P#a[U ՟('e-m ~SQ.f2$'|InvwäI _d? fSآ&c~fݵ \n˷ïuM2\>{ q2ҝI~W?Ѥ84FJ]cȯ#D~lٻjo&*rƚh,
q~ah<Ŭ}CY;F
`8D#7R˄&1nFɖUCy*
OMr3P
xѾԕ x7`dMbĝbsNtEآػTi-c
ܮ~TU
~ )QIXC$PW(E_3બ
L~w T+F܊,~#
+D~?épPpa] S^Ёo3u]J]
$K|ǬA;Be v۩ FħwhPϾ?cӯ$O_+*VC*`G5. @qF XOsz
x"p Cq WP I *gPwLz-Sܵ\&b82S0& /8=7LۓZi`Z&xwKnB]uAJ=s1+ߝR3^Bǩfm\KHݐ Nߊ576B2v$F~1? oZ^@y ~q>=?5!{3b1 N ܻ
=vjM< vؑVopwo'` ~3Pa=tɠ3Z6'g" bY䶝ۂ6=L:_y{܃ r:ݴocz)6$v&GN ~@"(|y_,yA0#&r1; ݫ Q$'L6 V}n039 ,.^LC Jm;(ӒׂyKx~?q|hZ z+̎
ӧ J|kAVbʴ?tygubR"J4DEBjGf" KW*Cnv~]
W*)M,dfbK ąO$ANjCFźVhdhc ]'m4օt2q8p)yqgIX3OlO